capture

@contextlib.contextmanager
def applied_frame_range(window, start, end, step):
    """Context manager for setting frame range."""
    # Store current frame range
    current_frame_start = window.scene.frame_start
    current_frame_end = window.scene.frame_end
    current_frame_step = window.scene.frame_step
    # Apply frame range
    window.scene.frame_start = start
    window.scene.frame_end = end
    window.scene.frame_step = step
    try:
        yield
    finally:
        # Restore frame range
        window.scene.frame_start = current_frame_start
        window.scene.frame_end = current_frame_end
        window.scene.frame_step = current_frame_step

@contextlib.contextmanager
def applied_image_settings(window, options):
    """Context manager to override image settings."""

    options = (options or ImageSettings).copy()
    ffmpeg = options.pop("ffmpeg", {})
    render = window.scene.render

    # Enforce order to certain attributes, because the first value may
    # influence what can be set as the second value
    order = ["media_type", "file_format", "color_mode", "color_depth"]
    for key in order:
        if key in options:
            # Pop them and re-add them at the end
            options[key] = options.pop(key)

    # Store current image settings
    original = {}
    for opt in options.copy():
        try:
            original[opt] = getattr(render.image_settings, opt)
        except ValueError:
            options.pop(opt)

    # Store current ffmpeg settings
    original_ffmpeg = {}
    for opt in ffmpeg.copy():
        try:
            original_ffmpeg[opt] = getattr(render.ffmpeg, opt)
        except ValueError:
            ffmpeg.pop(opt)

    # Apply image settings
    for opt, value in options.items():
        setattr(render.image_settings, opt, value)

    # Apply ffmpeg settings
    for opt, value in ffmpeg.items():
        setattr(render.ffmpeg, opt, value)

    try:
        yield
    finally:
        # Restore previous settings
        for opt, value in original.items():
            setattr(render.image_settings, opt, value)
        for opt, value in original_ffmpeg.items():
            setattr(render.ffmpeg, opt, value)

@contextlib.contextmanager
def applied_render_options(window, options):
    """Context manager for setting render options."""
    render = window.scene.render

    # Store current settings
    original = {}
    for opt in options.copy():
        try:
            original[opt] = getattr(render, opt)
        except ValueError:
            options.pop(opt)

    # Apply settings
    _apply_options(render, options)

    try:
        yield
    finally:
        # Restore previous settings
        _apply_options(render, original)

def applied_view(window, camera, isolate=None, options=None, background_images=False, log=None):
    """Apply view options to window."""
    area = window.screen.areas[0]
    area.ui_type = "VIEW_3D"
    space = area.spaces[0]

    types = {"MESH", "GPENCIL", "CAMERA"}
    objects = [obj for obj in window.scene.objects if obj.type in types]

    if camera == "AUTO":
        space.region_3d.view_perspective = "ORTHO"
        isolate_objects(window, isolate or objects)
    else:
        isolate_objects(window, isolate or objects)
        space.camera = window.scene.objects.get(camera)
        space.region_3d.view_perspective = "CAMERA"

    if isinstance(options, dict):
        _apply_options(space, options)
    else:
        space.shading.type = "SOLID"
        space.shading.color_type = "MATERIAL"
        space.show_gizmo = False
        space.overlay.show_overlays = False

    if background_images:
        if log:
            log.warning("Overlay visibility must be enabled to display background images (image planes).")
        space.overlay.show_overlays = True

def capture(
    camera=None,
    width=None,
    height=None,
    filename=None,
    start_frame=None,
    end_frame=None,
    step_frame=None,
    sound=None,
    isolate=None,
    maintain_aspect_ratio=True,
    overwrite=False,
    image_settings=None,
    display_options=None,
    background_images=False,
    log=None,
) -> str:
    """Playblast in an independent windows
    Arguments:
        camera (str, optional): Name of camera, defaults to "Camera"
        width (int, optional): Width of output in pixels
        height (int, optional): Height of output in pixels
        filename (str, optional): Name of output file path. Defaults to current
            render output path.
        start_frame (int, optional): Defaults to current start frame.
        end_frame (int, optional): Defaults to current end frame.
        step_frame (int, optional): Defaults to 1.
        sound (str, optional):  Specify the sound node to be used during
            playblast. When None (default) no sound will be used.
        isolate (list): List of nodes to isolate upon capturing
        maintain_aspect_ratio (bool, optional): Modify height in order to
            maintain aspect ratio.
        overwrite (bool, optional): Whether or not to overwrite if file
            already exists. If disabled and file exists and error will be
            raised.
        image_settings (dict, optional): Supplied image settings for render,
            using `ImageSettings`
        display_options (dict, optional): Supplied display options for render
        background_images (bool, optional): Whether to enable background images during capture
        Returns:
            str: The path to the captured playblast file.
    """

    scene = bpy.context.scene
    camera = camera or "Camera"

    # Ensure camera exists.
    if camera not in scene.objects and camera != "AUTO":
        raise RuntimeError("Camera does not exist: {0}".format(camera))

    # Ensure resolution.
    if width and height:
        maintain_aspect_ratio = False
    width = width or scene.render.resolution_x
    height = height or scene.render.resolution_y
    if maintain_aspect_ratio:
        ratio = scene.render.resolution_x / scene.render.resolution_y
        height = round(width / ratio)

    # Get frame range.
    if start_frame is None:
        start_frame = scene.frame_start
    if end_frame is None:
        end_frame = scene.frame_end
    if step_frame is None:
        step_frame = 1
    frame_range = (start_frame, end_frame, step_frame)

    if filename is None:
        filename = scene.render.filepath

    render_options = {
        "filepath": "{}.".format(filename.rstrip(".")),
        "resolution_x": width,
        "resolution_y": height,
        "use_overwrite": overwrite,
    }

    if get_blender_version() >= (5, 0, 0):
        # Enforce `media_type` is set to IMAGE
        image_settings["media_type"] = "IMAGE"

    with _independent_window() as window:

        applied_view(
            window,
            camera,
            isolate,
            options=display_options,
            background_images=background_images,
            log=log,
        )

        with contextlib.ExitStack() as stack:
            stack.enter_context(
                maintain_camera_settings(window, camera, background_images=background_images)
            )
            stack.enter_context(applied_frame_range(window, *frame_range))
            stack.enter_context(applied_render_options(window, render_options))
            stack.enter_context(applied_image_settings(window, image_settings))
            stack.enter_context(maintained_time())

            bpy.ops.render.opengl(
                animation=True,
                render_keyed_only=False,
                sequencer=False,
                write_still=False,
                view_context=True
            )

    return filename

def isolate_objects(window, objects):
    """Isolate selection"""
    deselect_all()

    # Only select objects that happen to be in the view layer to avoid
    # errors that object can't be selected because it is not in View Layer.
    view_layer_objects = window.view_layer.objects
    for obj in objects:
        if obj.name in view_layer_objects:
            obj.select_set(True)

    context = create_blender_context(selected=objects, window=window)

    with bpy.context.temp_override(**context):
        bpy.ops.view3d.view_axis(type="FRONT")
        bpy.ops.view3d.localview()

    deselect_all()

@contextlib.contextmanager
def maintain_camera_settings(window, camera, background_images):
    """Context manager to override camera."""
    current_camera = window.scene.camera
    target_camera = window.scene.objects.get(camera)
    current_image_plane = None
    if target_camera:
        window.scene.camera = target_camera
        if hasattr(target_camera.data, "show_background_images"):
            current_image_plane = target_camera.data.show_background_images
            target_camera.data.show_background_images = bool(background_images)
    try:
        yield
    finally:
        window.scene.camera = current_camera
        if target_camera and current_image_plane is not None:
            target_camera.data.show_background_images = current_image_plane

def restore_global_view(window):
    """Exit local view if active.

    Blender currently does not exit localview when closing windows.
    """

    types = {"MESH", "GPENCIL"}
    objects = [obj for obj in window.scene.objects if obj.type in types]

    context = create_blender_context(selected=objects, window=window)

    with bpy.context.temp_override(**context):
        # Only toggle back if in local view
        if bpy.context.space_data.local_view:
            bpy.ops.view3d.localview()