nightshade-renderer 0.57.0

//! The default frame driver: renders one frame from a composed
//! [`RenderInputs`], filling [`FrameOutputs`] with the writes that belong to
//! the caller. Any host that can compose the inputs and own a surface can
//! call [`render_frame`] directly; the graph executes per camera with
//! viewport caching, then the retained UI composites over the result.

use crate::wgpu::lights::build_render_lighting;
use crate::wgpu::pass_sync;
use crate::wgpu::passes;
use crate::wgpu::picking::dispatch_pick_compute;
use crate::wgpu::presentation;
use crate::wgpu::render_configs::{
    CameraFrameInputs, CameraTarget, FrameOutputs, RenderInputs, RendererCommand,
};
use crate::wgpu::rendergraph;
use crate::wgpu::rendergraph::{
    render_graph_enable_only_passes, render_graph_execute,
    render_graph_restore_pass_enabled_states, render_graph_save_pass_enabled_states,
    render_graph_set_external_texture, render_graph_set_pass_enabled,
};
use crate::wgpu::texture_uploads;
use crate::wgpu::view::build_render_view;

fn fit_constrained_aspect(tile_width: u32, tile_height: u32, aspect: f32) -> (u32, u32) {
    let aspect = aspect.max(0.0001);
    let tile_aspect = tile_width as f32 / tile_height.max(1) as f32;
    if tile_aspect > aspect {
        let width = (tile_height as f32 * aspect).round() as u32;
        (width.max(1), tile_height.max(1))
    } else {
        let height = (tile_width as f32 / aspect).round() as u32;
        (tile_width.max(1), height.max(1))
    }
}

/// Renders one frame. The renderer's persistent [`IblViews`](crate::config::IblViews)
/// are swapped into the inputs for the duration of the frame and reclaimed
/// afterward, so the caller never holds image-based-lighting state.
pub fn render_frame(
    renderer: &mut crate::wgpu::WgpuRenderer,
    inputs: &mut RenderInputs,
    outputs: &mut FrameOutputs,
) -> Result<(), crate::wgpu::rendergraph::RenderGraphError> {
    // The timing brackets the whole frame from out here rather than reaching
    // into the graph, because submission order is preserved and a frame takes
    // several different paths through `run_frame` depending on what it is
    // drawing. Opening before and closing after spans all of them without any
    // pass having to know it is being timed.
    if let Some(open) = renderer.timing.open(&renderer.device) {
        renderer.queue.submit(std::iter::once(open));
    }

    std::mem::swap(&mut renderer.ibl_views, &mut inputs.ibl_views);
    let result = run_frame(renderer, inputs, outputs);
    std::mem::swap(&mut renderer.ibl_views, &mut inputs.ibl_views);

    if let Some(close) = renderer.timing.close(&renderer.device) {
        renderer.queue.submit(std::iter::once(close));
    }
    // Polled after the close is submitted, never before: a map asked for on a
    // buffer whose copy is still unsubmitted is ordered ahead of that copy.
    renderer.timing.poll();

    result
}

/// Renders one single-view frame straight from a
/// [`SingleViewHost`](crate::wgpu::render_configs::SingleViewHost): composes
/// the inputs, runs the frame, and moves the host's state back so the loop can
/// call this and nothing else. A frame that fails to execute (surface lost,
/// occluded, or timed out) leaves [`FrameOutputs::frame_executed`] false and the
/// host state intact for the next attempt.
///
/// The returned outputs are safe to drop when the host does not track per-frame
/// results; read [`FrameOutputs::frame_executed`] to react to a frame that did
/// not render, such as a lost surface.
pub fn render_single_view(
    renderer: &mut crate::wgpu::WgpuRenderer,
    host: &mut crate::wgpu::render_configs::SingleViewHost,
    frame: crate::wgpu::render_configs::ViewFrame,
) -> FrameOutputs {
    let mut inputs = crate::wgpu::render_configs::compose_single_view(host, frame);
    let mut outputs = FrameOutputs::default();
    if render_frame(renderer, &mut inputs, &mut outputs).is_err() {
        outputs.frame_executed = false;
    }
    crate::wgpu::render_configs::restore_single_view(host, inputs);
    outputs
}

fn run_frame(
    renderer: &mut crate::wgpu::WgpuRenderer,
    inputs: &mut RenderInputs,
    outputs: &mut FrameOutputs,
) -> Result<(), crate::wgpu::rendergraph::RenderGraphError> {
    let _span = tracing::info_span!("render_frame").entered();
    pass_sync::sync_gpu_profile(renderer, inputs);
    renderer.frame_state.index = renderer.frame_state.index.wrapping_add(1);
    pass_sync::sync_taa_jitter(renderer, inputs);

    if let Some(matrices) = inputs
        .frame
        .active_camera_frame
        .as_ref()
        .and_then(|camera| camera.matrices)
    {
        let view_projection: [[f32; 4]; 4] = (matrices.projection * matrices.view).into();
        inputs.scene.prev_view_projection = inputs.scene.view_projection;
        inputs.scene.view_projection = view_projection;
    }

    inputs.shadow_atlas = passes::shadow_depth::atlas::assign_spotlight_atlas(
        &inputs.scene_world,
        inputs.frame.active_camera_frame.as_ref(),
        inputs.view.camera_tile_rects.is_empty(),
        passes::shadow_depth::atlas::shadow_atlas_size(),
    );

    renderer.sync_present_mode(inputs.settings.vsync_enabled);
    pass_sync::sync_settings_version(renderer, inputs);

    let frame_time_ms = inputs.view.delta_time * 1000.0;
    if frame_time_ms > 0.0 {
        inputs
            .scene
            .adaptive_sampling
            .record_frame_time(frame_time_ms);
    }

    #[cfg(all(not(target_arch = "wasm32"), feature = "screenshot"))]
    presentation::poll_screenshot_readback(renderer);

    // Only when nothing else will size them. The per-camera dispatch resizes to
    // each camera's target below, so doing it here too makes every frame resize
    // the whole graph twice when the cameras render at a size other than the
    // window's, which is always the case in stereo.
    if inputs.frame.cameras.is_empty() {
        renderer.resize_render_buffers(
            renderer.surface_config.width,
            renderer.surface_config.height,
        );
    }

    let mut hdr_skybox_commands = Vec::new();
    #[cfg(all(not(target_arch = "wasm32"), feature = "screenshot"))]
    let mut screenshot_request: Option<(Option<std::path::PathBuf>, Option<u32>)> = None;

    for command in std::mem::take(&mut inputs.frame.commands) {
        match command {
            RendererCommand::UploadUiImageLayer {
                layer,
                rgba_data,
                width,
                height,
            } => {
                crate::wgpu::texture_array_pool::upload_layer(
                    &renderer.ui_texture_array,
                    &renderer.queue,
                    layer,
                    &rgba_data,
                    width,
                    height,
                );
            }
            RendererCommand::ReloadTexture {
                name,
                rgba_data,
                width,
                height,
            } => {
                texture_uploads::reload_material_texture(
                    renderer,
                    &inputs.texture_cache,
                    name,
                    &rgba_data,
                    width,
                    height,
                );
            }
            RendererCommand::LoadHdrSkybox { hdr_data } => {
                hdr_skybox_commands.push(hdr_data);
            }
            RendererCommand::SetColorLut { data } => {
                pass_sync::set_color_lut(renderer, data);
            }
            #[cfg(all(not(target_arch = "wasm32"), feature = "screenshot"))]
            RendererCommand::CaptureScreenshot {
                path,
                max_dimension,
            } => {
                screenshot_request = Some((path, max_dimension));
            }
            #[cfg(not(all(not(target_arch = "wasm32"), feature = "screenshot")))]
            RendererCommand::CaptureScreenshot { .. } => {
                tracing::warn!(
                    "CaptureScreenshot ignored: renderer built without the `screenshot` feature"
                );
            }
        }
    }

    #[cfg(feature = "hdr")]
    crate::wgpu::ibl::load_hdr_skyboxes(renderer, &mut inputs.ibl_views, hdr_skybox_commands);
    #[cfg(not(feature = "hdr"))]
    drop(hdr_skybox_commands);

    #[cfg(feature = "hdr")]
    crate::wgpu::ibl::sync_procedural_ibl(renderer, inputs);

    if let Some(lines_pass) = pass_sync::lines_pass_mut(&mut renderer.graph) {
        lines_pass.upload_lines(
            &renderer.device,
            &renderer.queue,
            &inputs.frame.debug_lines.lines,
        );
        match &inputs.frame.debug_lines.bounding_volumes {
            Some(bounding_volumes) => {
                lines_pass.upload_bounding_volumes(
                    &renderer.device,
                    &renderer.queue,
                    bounding_volumes,
                );
            }
            None => lines_pass.clear_bounding_volumes(),
        }
        match &inputs.frame.debug_lines.normals {
            Some(normals) => {
                lines_pass.upload_normals(&renderer.device, &renderer.queue, normals);
            }
            None => lines_pass.clear_normals(),
        }
    }

    pass_sync::sync_point_shadow_cubemap(renderer);

    crate::wgpu::ibl::apply_ibl_bracket_blend(renderer, inputs);

    #[cfg(feature = "egui")]
    if let Some(egui) = inputs.frame.egui.take() {
        pass_sync::prepare_egui_pass(
            renderer,
            &egui.textures_delta,
            egui.pixels_per_point,
            egui.paint_jobs,
        );
    }

    // A camera rendering into its own target does not need the window: an
    // occluded, minimized, or lost surface stops the window presenting but must
    // not stop the cameras, because the window may not be where the frame is
    // going. A headset is the case that makes this concrete.
    let surface_texture = presentation::acquire_surface_frame(renderer);
    let has_surface = surface_texture.is_some();
    if !has_surface && inputs.frame.cameras.is_empty() {
        return Ok(());
    }
    outputs.frame_executed = true;

    // Taken only after a surface frame is secured: on a skipped frame the
    // state stays in the inputs and the caller's restore merges it back, so
    // dirty marks captured while occluded are not lost.
    if let Some(frame_state) = inputs.frame.mesh_frame_state.take() {
        pass_sync::apply_frame_dirty_state(renderer, frame_state, &mut inputs.mesh_cache);
    }

    let active_camera_entities: std::collections::HashSet<nightshade_ecs::Entity> = inputs
        .frame
        .cameras
        .iter()
        .map(|camera| camera.entity)
        .collect();
    renderer.cleanup_unused_camera_viewports(&active_camera_entities);

    // The renderer owns the live GPU textures; swap the persisted store into the
    // inputs so the passes can sample it while the graph runs, then reclaim it.
    std::mem::swap(&mut renderer.texture_store, &mut inputs.texture_store);
    let dispatch_result = dispatch_window_renders(renderer, inputs, outputs, has_surface);
    std::mem::swap(&mut renderer.texture_store, &mut inputs.texture_store);
    dispatch_result?;

    #[cfg(all(not(target_arch = "wasm32"), feature = "screenshot"))]
    if let Some((path, max_dimension)) = screenshot_request {
        presentation::request_screenshot_copy(renderer, path, max_dimension);
    }

    if let Some(surface_texture) = surface_texture {
        surface_texture.present();
    }

    Ok(())
}

/// Copies the frame's depth into a camera's caller-owned depth image.
///
/// Taken here rather than after the frame because the depth buffer is shared:
/// the next camera to render overwrites it.
fn publish_camera_depth(
    renderer: &mut crate::wgpu::WgpuRenderer,
    camera_entity: nightshade_ecs::Entity,
    width: u32,
    height: u32,
) {
    let Some((destination, array_layer)) = renderer
        .camera_viewports
        .get(&camera_entity)
        .and_then(|viewport| viewport.depth_target.clone())
    else {
        return;
    };
    let Some(source) =
        crate::wgpu::rendergraph::render_graph_get_texture(&renderer.graph, renderer.targets.depth)
            .cloned()
    else {
        return;
    };

    let mut encoder = renderer
        .device
        .create_command_encoder(&wgpu::CommandEncoderDescriptor {
            label: Some("camera depth publish"),
        });
    encoder.copy_texture_to_texture(
        wgpu::TexelCopyTextureInfo {
            texture: &source,
            mip_level: 0,
            origin: wgpu::Origin3d::ZERO,
            aspect: wgpu::TextureAspect::All,
        },
        wgpu::TexelCopyTextureInfo {
            texture: &destination,
            mip_level: 0,
            origin: wgpu::Origin3d {
                x: 0,
                y: 0,
                z: array_layer,
            },
            aspect: wgpu::TextureAspect::All,
        },
        wgpu::Extent3d {
            width,
            height,
            depth_or_array_layers: 1,
        },
    );
    renderer.queue.submit(std::iter::once(encoder.finish()));
}

fn dispatch_window_renders(
    renderer: &mut crate::wgpu::WgpuRenderer,
    inputs: &mut RenderInputs,
    outputs: &mut FrameOutputs,
    has_surface: bool,
) -> Result<(), crate::wgpu::rendergraph::RenderGraphError> {
    let _span = tracing::info_span!(
        "dispatch_window_renders",
        cameras = inputs.frame.cameras.len(),
    )
    .entered();

    let surface_width = renderer.surface_config.width;
    let surface_height = renderer.surface_config.height;
    let has_viewports = !inputs.frame.cameras.is_empty();
    let _ = render_graph_set_pass_enabled(&mut renderer.graph, "viewport_blit_pass", has_viewports);
    let _ =
        render_graph_set_pass_enabled(&mut renderer.graph, "viewport_compose_pass", has_surface);

    if !has_viewports {
        renderer.resize_render_buffers_for_window(surface_width, surface_height);
    }

    inputs.view.camera_tile_render_iteration = 0;
    let original_active_camera = inputs.view.active_camera;
    let frame_settings_version = inputs.scene.settings_version;
    let focus_policy = inputs.scene.focus_policy;
    let global_dirty_signal = inputs.frame.global_dirty_signal;

    let ui_pass_states_before_loop = if has_viewports && has_surface {
        let saved_states = render_graph_save_pass_enabled_states(&renderer.graph);
        let saved = (
            saved_states.get("ui_pass").copied().unwrap_or(true),
            saved_states.get("ui_image_pass").copied().unwrap_or(true),
        );
        let _ = render_graph_set_pass_enabled(&mut renderer.graph, "ui_pass", false);
        let _ = render_graph_set_pass_enabled(&mut renderer.graph, "ui_image_pass", false);
        Some(saved)
    } else {
        None
    };

    let mouse_focused_camera = inputs
        .view
        .camera_tile_rects
        .iter()
        .find(|(_, rect)| rect.contains(inputs.frame.mouse_position))
        .map(|(entity, _)| *entity);
    let focused_camera = mouse_focused_camera.or(original_active_camera);

    texture_uploads::sync_material_texture_bindings(
        renderer,
        inputs.settings.material_anisotropy_filtering,
    );

    let cameras: Vec<CameraFrameInputs> = inputs.frame.cameras.clone();

    // Freezing captures the current view once and holds it, so the cut stays put
    // as the camera flies away from the frustum that chose it. Capturing every
    // frame instead would track the camera and freeze nothing. Cleared the
    // moment freezing turns off. The source is the active camera, whether the
    // frame renders one camera or several. Surface resolution sets the frustum
    // and the pixels-per-unit the cull needs.
    if inputs.debug_draw.meshlet_freeze_cull_to_active {
        if renderer.meshlet_frozen_cull_view.is_none() {
            let source = original_active_camera
                .and_then(|active| cameras.iter().find(|camera| camera.entity == active))
                .or(inputs.frame.active_camera_frame.as_ref());
            renderer.meshlet_frozen_cull_view = source.and_then(|camera| {
                build_render_view(
                    camera,
                    inputs.scene.taa_jitter,
                    (surface_width.max(1), surface_height.max(1)),
                )
            });
        }
    } else {
        renderer.meshlet_frozen_cull_view = None;
    }
    inputs.scene.frozen_cull_view = renderer.meshlet_frozen_cull_view.clone();

    for (iteration_index, camera) in cameras.iter().enumerate() {
        let camera_entity = camera.entity;
        let (tile_width, tile_height) = inputs
            .view
            .camera_tile_rects
            .get(&camera_entity)
            .map(|rect| {
                (
                    (rect.width.round() as u32).max(1),
                    (rect.height.round() as u32).max(1),
                )
            })
            .unwrap_or((surface_width.max(1), surface_height.max(1)));
        let (display_width, display_height) = if let Some(aspect) = camera.constrained_aspect {
            fit_constrained_aspect(tile_width, tile_height, aspect)
        } else {
            (tile_width, tile_height)
        };
        let render_scale = inputs.settings.render_scale.clamp(0.25, 4.0);
        let is_main_viewport_camera = Some(camera_entity) == original_active_camera;
        // Render scale decides how many pixels the renderer allocates, so it
        // applies wherever the renderer is the one allocating. A host-owned
        // texture already exists at a size nothing here chose, and scaling that
        // would render into part of it and present the rest as garbage.
        let (render_width, render_height) = match camera.target {
            Some(CameraTarget {
                size,
                host_owned: true,
            }) => size,
            Some(CameraTarget {
                size: (width, height),
                host_owned: false,
            }) => (
                ((width as f32 * render_scale).round() as u32).max(1),
                ((height as f32 * render_scale).round() as u32).max(1),
            ),
            None => (
                ((display_width as f32 * render_scale).round() as u32).max(1),
                ((display_height as f32 * render_scale).round() as u32).max(1),
            ),
        };

        // A host-owned target was bound by the host before the frame; allocating
        // one here would replace it with an empty texture nothing presents.
        if !matches!(
            camera.target,
            Some(CameraTarget {
                host_owned: true,
                ..
            })
        ) {
            renderer.ensure_camera_viewport(camera_entity, render_width, render_height);
        }
        renderer.resize_render_buffers_for_window(render_width, render_height);

        let viewport_cloned = renderer
            .camera_viewports
            .get(&camera_entity)
            .map(|viewport| {
                (
                    viewport.texture.clone(),
                    viewport.view.clone(),
                    viewport.size,
                    viewport.has_rendered_at_least_once,
                    viewport.last_active_view,
                    viewport.last_settings_version,
                    viewport.last_camera_world_transform,
                )
            });

        if let Some((
            texture,
            view,
            size,
            has_rendered_once,
            last_active_view,
            last_settings_version,
            last_camera_world_transform,
        )) = viewport_cloned
        {
            render_graph_set_external_texture(
                &mut renderer.graph,
                renderer.targets.viewport_resource,
                Some(texture),
                view,
                render_width,
                render_height,
            );

            inputs.view.active_camera = Some(camera_entity);
            inputs.view.camera_tile_render_iteration = iteration_index as u32;

            let effective = camera.effective_shading;

            let is_focused_view = Some(camera_entity) == focused_camera;
            let focus_forces_render = matches!(
                focus_policy,
                crate::config::ViewportFocusPolicy::FocusedAlways
            ) && is_focused_view;
            let view_changed = last_active_view != Some(effective);
            let settings_changed = last_settings_version != frame_settings_version;
            let camera_self_dirty = match (last_camera_world_transform, camera.world_transform) {
                (Some(prev), Some(curr)) => prev != curr,
                (None, _) => true,
                (_, None) => false,
            };
            let frustum_dirty = if let Some(matrices) = camera.matrices.as_ref() {
                let view_proj = matrices.projection * matrices.view;
                let frustum_planes = passes::geometry::extract_frustum_planes(&view_proj);
                inputs
                    .frame
                    .dirty_world_spheres
                    .iter()
                    .any(|(center, radius)| {
                        passes::geometry::sphere_in_frustum(center, *radius, &frustum_planes)
                    })
            } else {
                !inputs.frame.dirty_world_spheres.is_empty()
            };
            let pick_forces_render = is_main_viewport_camera && inputs.frame.pick_request.is_some();
            let camera_force_render = inputs.frame.force_render_cameras.contains(&camera_entity);
            let should_render = pick_forces_render
                || camera_force_render
                || match camera.update_mode {
                    crate::config::ViewportUpdateMode::Always => true,
                    crate::config::ViewportUpdateMode::WhenVisible => true,
                    crate::config::ViewportUpdateMode::WhenDirty => {
                        focus_forces_render
                            || !has_rendered_once
                            || global_dirty_signal
                            || settings_changed
                            || view_changed
                            || camera_self_dirty
                            || frustum_dirty
                    }
                    crate::config::ViewportUpdateMode::Once => !has_rendered_once,
                    crate::config::ViewportUpdateMode::Disabled => !has_rendered_once,
                };

            // Velocity and the temporal resolve both reproject against this,
            // and both have to see the same thing, so it is set once here from
            // the camera about to render rather than taken from whichever
            // camera happens to be active.
            let camera_view_projection = camera
                .matrices
                .as_ref()
                .map(|matrices| (matrices.projection * matrices.view).into());
            if let Some(view_projection) = camera_view_projection {
                inputs.scene.prev_view_projection = renderer
                    .camera_viewports
                    .get(&camera_entity)
                    .and_then(|viewport| viewport.last_view_projection)
                    .unwrap_or(view_projection);
                inputs.scene.view_projection = view_projection;
            }

            inputs.scene.active_view = effective;
            inputs.scene.render_view = build_render_view(
                camera,
                inputs.scene.taa_jitter,
                (render_width, render_height),
            );
            let lighting = build_render_lighting(&inputs.scene_world, Some(camera));
            inputs.scene.render_lighting = Some(lighting);
            pass_sync::sync_conditional_pass_toggles(
                renderer,
                inputs,
                inputs.frame.pick_request.is_some(),
                inputs.frame.has_skinned_meshes,
            );

            let phase = if should_render {
                rendergraph::ExecutePhase::Full
            } else {
                rendergraph::ExecutePhase::ComposeOnly
            };
            let command_buffers = {
                let _span = tracing::info_span!("render_graph_execute", phase = ?phase).entered();
                rendergraph::render_graph_execute_with_phase(
                    &mut renderer.graph,
                    &renderer.device,
                    &renderer.queue,
                    inputs,
                    phase,
                )?
            };
            {
                let _span = tracing::info_span!("queue_submit").entered();
                renderer.queue.submit(command_buffers);
            }

            if should_render {
                publish_camera_depth(renderer, camera_entity, render_width, render_height);
            }

            if should_render
                && let Some(viewport) = renderer.camera_viewports.get_mut(&camera_entity)
            {
                viewport.has_rendered_at_least_once = true;
                viewport.last_active_view = Some(effective);
                viewport.last_settings_version = frame_settings_version;
                viewport.last_render_frame = renderer.frame_state.index;
                viewport.last_camera_world_transform = camera.world_transform;
                if let Some(view_projection) = camera_view_projection {
                    viewport.last_view_projection = Some(view_projection);
                }
            }
            if should_render && camera_force_render {
                outputs.force_render_cleared.push(camera_entity);
            }

            if is_main_viewport_camera
                && !renderer.depth_pick.pending
                && let Some((screen_x, screen_y)) = inputs.frame.pick_request.take()
            {
                dispatch_pick_compute(renderer, screen_x, screen_y, Some(camera_entity));
            }

            outputs.viewport_texture_sizes.push(size);
        }
    }

    inputs.view.active_camera = original_active_camera;
    inputs.scene.active_view = match inputs
        .frame
        .active_camera_frame
        .as_ref()
        .filter(|_| inputs.frame.cameras.is_empty())
    {
        Some(camera) => camera.effective_shading,
        None => inputs.frame.fallback_shading,
    };
    pass_sync::sync_conditional_pass_toggles(
        renderer,
        inputs,
        inputs.frame.pick_request.is_some(),
        inputs.frame.has_skinned_meshes,
    );

    if let Some((ui_was_enabled, ui_image_was_enabled)) = ui_pass_states_before_loop {
        let _span = tracing::info_span!("ui_composite").entered();

        let _ = rendergraph::render_graph_resize_transient_resource(
            &mut renderer.graph,
            &renderer.device,
            renderer.targets.ui_depth,
            surface_width.max(1),
            surface_height.max(1),
        );

        let saved_pass_states = render_graph_save_pass_enabled_states(&renderer.graph);
        render_graph_enable_only_passes(
            &mut renderer.graph,
            &[
                ("ui_pass", ui_was_enabled),
                ("ui_image_pass", ui_image_was_enabled),
            ],
        );
        let command_buffers = {
            let _span = tracing::info_span!("ui_composite_execute").entered();
            render_graph_execute(
                &mut renderer.graph,
                &renderer.device,
                &renderer.queue,
                inputs,
            )?
        };
        renderer.queue.submit(command_buffers);

        render_graph_restore_pass_enabled_states(&mut renderer.graph, &saved_pass_states);
        let _ = render_graph_set_pass_enabled(&mut renderer.graph, "ui_pass", ui_was_enabled);
        let _ = render_graph_set_pass_enabled(
            &mut renderer.graph,
            "ui_image_pass",
            ui_image_was_enabled,
        );
    }

    if inputs.frame.cameras.is_empty() {
        inputs.view.camera_tile_render_iteration = 0;

        if inputs.settings.render_world_to_swapchain {
            inputs.scene.render_view =
                inputs
                    .frame
                    .active_camera_frame
                    .as_ref()
                    .and_then(|camera| {
                        build_render_view(
                            camera,
                            inputs.scene.taa_jitter,
                            renderer.render_buffer_size,
                        )
                    });
            let lighting = build_render_lighting(
                &inputs.scene_world,
                inputs.frame.active_camera_frame.as_ref(),
            );
            inputs.scene.render_lighting = Some(lighting);
            let command_buffers = render_graph_execute(
                &mut renderer.graph,
                &renderer.device,
                &renderer.queue,
                inputs,
            )?;
            renderer.queue.submit(command_buffers);
            if !renderer.depth_pick.pending
                && let Some((screen_x, screen_y)) = inputs.frame.pick_request.take()
            {
                dispatch_pick_compute(renderer, screen_x, screen_y, inputs.view.active_camera);
            }
        } else {
            presentation::clear_swapchain(renderer, inputs.ui.background_color);

            let _ = rendergraph::render_graph_resize_transient_resource(
                &mut renderer.graph,
                &renderer.device,
                renderer.targets.ui_depth,
                surface_width.max(1),
                surface_height.max(1),
            );

            let saved_pass_states = render_graph_save_pass_enabled_states(&renderer.graph);
            render_graph_enable_only_passes(
                &mut renderer.graph,
                &[("ui_pass", true), ("ui_image_pass", true)],
            );

            let command_buffers = render_graph_execute(
                &mut renderer.graph,
                &renderer.device,
                &renderer.queue,
                inputs,
            )?;
            renderer.queue.submit(command_buffers);

            render_graph_restore_pass_enabled_states(&mut renderer.graph, &saved_pass_states);
            let _ = render_graph_set_pass_enabled(&mut renderer.graph, "ui_pass", true);
            let _ = render_graph_set_pass_enabled(&mut renderer.graph, "ui_image_pass", true);
        }
    }

    let dispatched_settings_version = inputs.scene.settings_version;
    renderer.record_window_dispatch(dispatched_settings_version);
    Ok(())
}