preview_animation

@contextlib.contextmanager
def play_preview_when_done(has_autoplay):
    """Set preview playback option during context

    Args:
        has_autoplay (bool): autoplay during creating
            preview animation
    """
    current_playback = rt.preferences.playPreviewWhenDone
    try:
        rt.preferences.playPreviewWhenDone = has_autoplay
        yield
    finally:
        rt.preferences.playPreviewWhenDone = current_playback

def render_preview_animation(
        filepath,
        ext,
        camera,
        start_frame=None,
        end_frame=None,
        percentSize=100.0,
        width=1920,
        height=1080,
        viewport_options=None):
    """Render camera review animation
    Args:
        filepath (str): filepath to render to, without frame number and
            extension
        ext (str): output file extension
        camera (str): viewport camera for preview render
        start_frame (int): start frame
        end_frame (int): end frame
        percentSize (float): render resolution multiplier by 100
            e.g. 100.0 is 1x, 50.0 is 0.5x, 150.0 is 1.5x
        width (int): render resolution width
        height (int): render resolution height
        viewport_options (dict): viewport setting options
    Returns:
        list: Rendered output files
    """
    if start_frame is None:
        start_frame = int(rt.animationRange.start)
    if end_frame is None:
        end_frame = int(rt.animationRange.end)

    if viewport_options is None:
        viewport_options = viewport_options_for_preview_animation()
    with play_preview_when_done(False):
        with viewport_layout_and_camera(camera):
            if int(get_max_version()) < 2024:
                with viewport_preference_setting(
                        viewport_options["general_viewport"],
                        viewport_options["nitrous_manager"],
                        viewport_options["nitrous_viewport"],
                        viewport_options["vp_btn_mgr"]
                ):
                    return _render_preview_animation_max_pre_2024(
                        filepath,
                        start_frame,
                        end_frame,
                        width,
                        height,
                        percentSize,
                        ext
                    )
            else:
                with render_resolution(width, height):
                    return _render_preview_animation_max_2024(
                        filepath,
                        start_frame,
                        end_frame,
                        percentSize,
                        ext,
                        viewport_options
                    )

@contextlib.contextmanager
def viewport_layout_and_camera(camera, layout="layout_1"):
    """Set viewport layout and camera during context
    ***For 3dsMax 2024+
    Args:
        camera (str): viewport camera
        layout (str): layout to use in viewport, defaults to `layout_1`
            Use None to not change viewport layout during context.
    """
    needs_maximise = 0
    # Set to first active non extended viewport
    rt.viewport.activeViewportEx(1)
    original_camera = rt.viewport.getCamera()
    original_type = rt.viewport.getType()
    review_camera = rt.getNodeByName(camera)

    try:
        if rt.viewport.getLayout() != rt.name(layout):
            rt.execute("max tool maximize")
            needs_maximise = 1
        rt.viewport.setCamera(review_camera)
        yield
    finally:
        if needs_maximise == 1:
            rt.execute("max tool maximize")
        if original_type == rt.Name("view_camera"):
            rt.viewport.setCamera(original_camera)
        else:
            rt.viewport.setType(original_type)

def viewport_options_for_preview_animation():
    """Get default viewport options for `render_preview_animation`.

    Returns:
        dict: viewport setting options
    """
    # viewport_options should be the dictionary
    if int(get_max_version()) < 2024:
        return {
            "visualStyleMode": "defaultshading",
            "viewportPreset": "highquality",
            "vpTexture": False,
            "dspGeometry": True,
            "dspShapes": False,
            "dspLights": False,
            "dspCameras": False,
            "dspHelpers": False,
            "dspParticles": True,
            "dspBones": False,
            "dspBkg": True,
            "dspGrid": False,
            "dspSafeFrame": False,
            "dspFrameNums": False
        }
    else:
        viewport_options = {}
        viewport_options["general_viewport"] = {
            "dspBkg": True,
            "dspGrid": False
        }
        viewport_options["nitrous_manager"] = {
            "AntialiasingQuality": "None"
        }
        viewport_options["nitrous_viewport"] = {
            "VisualStyleMode": "defaultshading",
            "ViewportPreset": "highquality",
            "UseTextureEnabled": False
        }
        viewport_options["vp_btn_mgr"] = {
            "EnableButtons": False}
        return viewport_options

@contextlib.contextmanager
def viewport_preference_setting(general_viewport,
                                nitrous_manager,
                                nitrous_viewport,
                                vp_button_mgr):
    """Function to set viewport setting during context
    ***For Max Version < 2024
    Args:
        camera (str): Viewport camera for review render
        general_viewport (dict): General viewport setting
        nitrous_manager (dict): Nitrous graphic manager
        nitrous_viewport (dict): Nitrous setting for
            preview animation
        vp_button_mgr (dict): Viewport button manager Setting
        preview_preferences (dict): Preview Preferences Setting
    """
    orig_vp_grid = rt.viewport.getGridVisibility(1)
    orig_vp_bkg = rt.viewport.IsSolidBackgroundColorMode()

    nitrousGraphicMgr = rt.NitrousGraphicsManager
    viewport_setting = nitrousGraphicMgr.GetActiveViewportSetting()
    vp_button_mgr_original = {
        key: getattr(rt.ViewportButtonMgr, key) for key in vp_button_mgr
    }
    nitrous_manager_original = {
        key: getattr(nitrousGraphicMgr, key) for key in nitrous_manager
    }
    nitrous_viewport_original = {
        key: getattr(viewport_setting, key) for key in nitrous_viewport
    }

    try:
        rt.viewport.setGridVisibility(1, general_viewport["dspGrid"])
        rt.viewport.EnableSolidBackgroundColorMode(general_viewport["dspBkg"])
        for key, value in vp_button_mgr.items():
            setattr(rt.ViewportButtonMgr, key, value)
        for key, value in nitrous_manager.items():
            setattr(nitrousGraphicMgr, key, value)
        for key, value in nitrous_viewport.items():
            if nitrous_viewport[key] != nitrous_viewport_original[key]:
                setattr(viewport_setting, key, value)
        yield

    finally:
        rt.viewport.setGridVisibility(1, orig_vp_grid)
        rt.viewport.EnableSolidBackgroundColorMode(orig_vp_bkg)
        for key, value in vp_button_mgr_original.items():
            setattr(rt.ViewportButtonMgr, key, value)
        for key, value in nitrous_manager_original.items():
            setattr(nitrousGraphicMgr, key, value)
        for key, value in nitrous_viewport_original.items():
            setattr(viewport_setting, key, value)