From Python¶

def __init__(
    self,
    video: str | os.PathLike[str] | None = None,
    *,
    frames: FrameSink | None = None,
    plays: PlayHook | None = None,
    take: Take | None = None,
    preset: X264Preset = "ultrafast",
    crf: float = 18.0,
) -> None:
    if preset not in get_args(X264Preset):
        raise ValueError(f"unknown x264 preset {preset!r}")
    if not 0 <= crf <= 51:
        raise ValueError(
            f"x264 CRF must be a finite number from 0 to 51, not {crf}"
        )
    fps = config.frame_rate
    if video is not None and fps != int(fps):
        raise ValueError(
            f"a video needs a whole number of frames per second, not {fps}"
        )
    width, height = config.pixel_width, config.pixel_height
    if video is not None and (width % 2 or height % 2):  # H.264's 4:2:0 halves both
        raise ValueError(
            f"a video needs an even width and height, not {width}x{height}"
        )
    self.fps = Fraction(fps).limit_denominator(1000)
    """How many frames a second the film has: the configuration's when it began."""
    # the GPU draws the film; or its take is recorded, to be drawn by manimgx's player: by
    # choice, or where the engine has no GPU (in Pyodide)
    self._player: _engine.Player | None = None
    self._recorder: _engine.Recorder | None = None
    drawn: _engine.Player | _engine.Recorder
    if take is None and (gpu := feed.Player) is not None:
        if video is not None or frames is not None:
            _engine.start_gpu()  # the film draws: the GPU comes up as it begins
        self._player = drawn = gpu(width, height)
        if video is not None:
            drawn.begin_export(
                os.fspath(video), fps=int(fps), preset=preset, crf=crf
            )
    elif video is None and frames is None:
        self._recorder = drawn = _engine.Recorder(width, height, fps)
    else:
        raise ValueError(
            "a film recorded as a take is drawn by manimgx's player, not here: it"
            " has no video or pixels"
            + ("" if feed.Player else " (this Python has no GPU)")
        )
    self._take = take
    self.feeder = Feeder(width, height, drawn)
    self.video = None if video is None else os.fspath(video)
    """The path of the video being written; None once it is written, and if there is
    none."""
    self.frames = frames
    """The function each drawn frame is handed to, if any."""
    self.frame_count = 0
    """How many frames the film has so far, a hold counting every frame it lasts."""
    self.plays: list[Play] = []
    """The plays and waits the scene has run, in order: each a
    [`Play`][manimgx.rendering.film.Play]."""
    self.sections: list[Section] = [
        Section("unnamed", Fraction(0), 0, "default.normal", "")
    ]
    """The film's sections, in order: each a [`Section`][manimgx.rendering.film.Section],
    lasting until the next begins. The first begins with the film."""
    self.subcaptions: list[Caption] = []
    """The captions the scene added (see
    [`add_subcaption`][manimgx.Scene.add_subcaption]); [`captions`]
    [manimgx.Film.captions] adds those of its speech."""
    self.clips: list[Clip] = []
    """The sounds the scene placed, in the order it placed them: each a
    [`Clip`][manimgx.audio.sound.Clip], from its start in scene time."""
    self.export: Export | None = None
    """How the video was made, once it is written: an
    [`Export`][manimgx.rendering.film.Export]; None until then, and with no video."""
    self._hook = plays
    self._pending: tuple[bytes, bytes, list[CameraView], int] | None = (
        None  # sent once it ends
    )
    self._first = 0  # the index of the pending frame
    self._key = False  # the next frame begins a section: a keyframe of its own
    self._pending_key = False  # the pending frame is one

def __init__(self, title: str = "manimgx", *, time: float = 0.0) -> None:
    self._process = subprocess.Popen(
        [
            sys.executable,
            "-c",
            "from manimgx.rendering.window import _main; _main()",
        ]
        + [title, repr(float(time))],
        stdin=subprocess.PIPE,
        stdout=subprocess.PIPE,
    )
    self._asked: queue.Queue[str] = queue.Queue()
    self.failure: str | None = None
    """Why the window failed, if it did (no screen to open on, no GPU): it is closed."""
    self._listening = threading.Thread(target=self._listen, daemon=True)
    self._listening.start()

def __init__(
    self, index: int, repeat: int, draw: Callable[[], bytes], key: bool = False
) -> None:
    self.index = index
    """Where it is in the film: the number of the first frame it is shown as, from
    0."""
    self.repeat = repeat
    """How many frames it is shown for: more than 1 for a hold."""
    self.key = key
    """Whether it begins a [section][manimgx.rendering.film.Section] of the film: the picture
    the section before it ends on."""
    self._draw = draw