Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

53.7 KB
Raw Blame
//! Standalone Environment inspector body. Drawing and source browsing never save a setup.
use super::{ImageMethod, Stage, cpu, hdr, setups, studio};
use crate::ui_kit::BackingTooltipExt as _;
use crate::{SolveApp, theme::Tokens, ui_kit};
use serde_json::{Value, json};
use solidcraft_engine::doc::render_settings::{RenderJob, RenderSetup};
use std::sync::{Arc, Weak};

#[derive(Clone, Debug, Default)]
pub(super) struct RingView {
    pub geometry: Option<Ring>,
    drag: Option<RingDrag>,
    suppress_primary: bool,
}

#[derive(Clone, Copy, Debug)]
pub(super) struct Ring {
    pub center: egui::Pos2,
    pub radius: f32,
}

#[derive(Clone, Debug)]
struct RingDrag {
    ring: Ring,
    viewport: egui::Rect,
    document: Weak<solidcraft_engine::doc::Document>,
    revision: u64,
    name: String,
    start: f64,
    initial: f64,
    current: f64,
    moved: bool,
}

/// Clockwise screen-space angle. An undefined centre or collapsed ring is not a gesture.
pub(super) fn pointer_angle(pointer: egui::Pos2, center: egui::Pos2, radius: f32) -> Option<f64> {
    if !pointer.is_finite() || !center.is_finite() || !radius.is_finite() || !(1.0..=1e6).contains(&radius) {
        return None;
    }
    let x = f64::from(pointer.x) - f64::from(center.x);
    let y = f64::from(pointer.y) - f64::from(center.y);
    (x.hypot(y) >= 1e-6).then(|| y.atan2(x).to_degrees())
}

pub(super) fn drag_rotation(initial: f64, start: f64, angle: f64, snap: bool) -> Option<f64> {
    if [initial, start, angle].iter().any(|value| !value.is_finite() || value.abs() > 1e6) {
        return None;
    }
    let delta = (angle - start + 180.0).rem_euclid(360.0) - 180.0;
    let value = initial + delta;
    let value = if snap { (value / 15.0).round() * 15.0 } else { value };
    Some((value + 180.0).rem_euclid(360.0) - 180.0)
}

fn ring_target(app: &SolveApp) -> bool {
    let view = &app.render_workspace.view;
    super::active(app)
        && !view.result
        && view.selection == super::RenderSelection::Environment
        && environment_values(app).is_some_and(|(_, _, _, rotates)| rotates)
        && !app.session.model.is_stale()
}

fn ring_geometry(app: &SolveApp, viewport: egui::Rect) -> Option<Ring> {
    let free = crate::render_ui::canvas(app, viewport);
    if !viewport.is_finite() || !viewport.is_positive() || !free.is_finite() || !free.is_positive() {
        return None;
    }
    let world = crate::open_meshing::shown_world(app);
    let bounds = crate::viewport::body_bounds(app, &world)
        .iter()
        .filter(|(name, _)| app.session.body_visible(name))
        .fold(solidcraft_engine::geom::Aabb3::EMPTY, |a, (_, b)| a.union(b));
    if bounds.is_empty() {
        return None;
    }
    let subject = crate::viewport::screen_box(&crate::viewport::projection(app, viewport), &bounds, 0.0)?;
    let center = subject.center();
    if !subject.is_finite() || !center.is_finite() || !free.contains(center) {
        return None;
    }
    let t = Tokens::get();
    let maximum = (center.x - free.left()).min(free.right() - center.x).min(center.y - free.top()).min(free.bottom() - center.y) - t.space_12;
    let minimum = t.control_height * 2.0;
    if !maximum.is_finite() || maximum < minimum {
        return None;
    }
    let radius = (subject.size().length() * 0.5 + t.space_24).clamp(minimum, maximum.min(1e6));
    Some(Ring { center, radius })
}

/// Own the complete primary gesture before shared camera navigation or product picking sees it.
pub(super) fn ring_input(app: &mut SolveApp, ui: &mut egui::Ui, viewport: egui::Rect, response: &egui::Response) -> bool {
    if app.render_workspace.view.environment_ring.suppress_primary {
        app.render_workspace.view.environment_ring.suppress_primary = ui.input(|i| i.pointer.primary_down());
        return true;
    }
    let mut drag = app.render_workspace.view.environment_ring.drag.take();
    let captured = drag.is_some();
    let valid = ring_target(app) && setups::snapshot(app).is_ok();
    let fresh = drag.as_ref().is_none_or(|d| {
        d.revision == app.session.revision
            && d.name == app.render_workspace.view.name
            && d.viewport == viewport
            && Weak::ptr_eq(&d.document, &Arc::downgrade(&app.session.doc))
            && environment_values(app).is_some_and(|(rotation, _, _, _)| rotation == d.initial)
    });
    if !valid || !fresh {
        app.render_workspace.view.environment_ring.geometry = None;
        app.render_workspace.view.environment_ring.suppress_primary = captured && ui.input(|i| i.pointer.primary_down());
        return captured;
    }
    let geometry = drag.as_ref().map(|d| d.ring).or_else(|| ring_geometry(app, viewport));
    app.render_workspace.view.environment_ring.geometry = geometry;
    let Some(ring) = geometry else { return captured };
    let (pointer, origin, pressed, down, released, shift, escape) = ui.input(|i| {
        (
            i.pointer.latest_pos(),
            i.pointer.press_origin(),
            i.pointer.button_pressed(egui::PointerButton::Primary),
            i.pointer.primary_down(),
            i.pointer.button_released(egui::PointerButton::Primary),
            i.modifiers.shift,
            i.key_pressed(egui::Key::Escape),
        )
    });
    let hit = |p: egui::Pos2| p.is_finite() && (p.distance(ring.center) - ring.radius).abs() <= Tokens::get().space_8;
    if drag.is_none()
        && pressed
        && ui.is_enabled()
        && response.contains_pointer()
        && !egui::Popup::is_any_open(ui.ctx())
        && app.dialog.is_none()
        && let Some(origin) = origin.filter(|p| !crate::shell::covered(app, *p) && hit(*p))
        && let Some(start) = pointer_angle(origin, ring.center, ring.radius)
        && let Some((initial, _, _, _)) = environment_values(app)
    {
        drag = Some(RingDrag {
            ring,
            viewport,
            document: Arc::downgrade(&app.session.doc),
            revision: app.session.revision,
            name: app.render_workspace.view.name.clone(),
            start,
            initial,
            current: initial,
            moved: false,
        });
    }
    if let Some(mut drag) = drag {
        app.begin_external_navigation();
        app.viewport.orbit_from = None;
        app.viewport.primary_nav = None;
        app.viewport.modifier_nav = None;
        app.viewport.key_hold = None;
        app.viewport.device_motion = None;
        ui.ctx().set_cursor_icon(egui::CursorIcon::Grabbing);
        let angle = pointer.and_then(|p| pointer_angle(p, ring.center, ring.radius)).and_then(|angle| {
            drag.moved |= drag_rotation(0.0, drag.start, angle, false).is_some_and(|delta| delta.abs() > 1e-6);
            drag_rotation(drag.initial, drag.start, angle, shift && drag.moved)
        });
        if escape || angle.is_none() || (!down && !released) {
            app.render_workspace.view.environment_ring.suppress_primary = down;
            return true;
        }
        if let Some(angle) = angle {
            drag.current = angle;
        }
        if released {
            if drag.moved
                && (drag.current - drag.initial).abs() > 1e-9
                && let Err(error) = commit_environment(app, json!({"rotation_deg":drag.current}))
            {
                app.set_status(error, true);
            }
        } else {
            app.render_workspace.view.environment_ring.drag = Some(drag);
        }
        ui.ctx().request_repaint();
        return true;
    }
    if ui.is_enabled() && pointer.is_some_and(hit) && response.contains_pointer() {
        ui.ctx().set_cursor_icon(egui::CursorIcon::Grab);
    }
    false
}

pub(super) fn ring_overlay(app: &mut SolveApp, ui: &mut egui::Ui, viewport: egui::Rect) {
    if !ring_target(app) {
        return;
    }
    let view = &app.render_workspace.view.environment_ring;
    let Some(ring) = view.geometry else { return };
    let angle = view.drag.as_ref().map(|drag| drag.current).or_else(|| environment_values(app).map(|v| v.0)).unwrap_or(0.0);
    let t = Tokens::get();
    let free = crate::render_ui::canvas(app, viewport);
    let painter = ui.painter().with_clip_rect(free.intersect(viewport));
    painter.circle_stroke(ring.center, ring.radius, egui::Stroke::new(t.space_2, t.form_primary));
    let radians = angle.to_radians();
    let handle = ring.center + egui::vec2(radians.cos() as f32, radians.sin() as f32) * ring.radius;
    painter.circle_filled(handle, t.space_6, t.form_primary);
    painter.circle_stroke(handle, t.space_6, t.control_border_stroke(t.on_accent));
    crate::scenario::publish_target("render:environment:ring", egui::Rect::from_center_size(ring.center, egui::Vec2::splat(ring.radius * 2.0)));
    crate::scenario::publish_target("render:environment:ring-handle", egui::Rect::from_center_size(handle, egui::Vec2::splat(t.space_16)));
    let chip = ui_kit::Container::navigation_card(
        ui.ctx(),
        egui::Id::unique("render_environment_rotation"),
        ring.center + egui::vec2(0.0, ring.radius - t.control_height - t.space_8),
        egui::Align2::CENTER_BOTTOM,
        |ui| ui_kit::text(ui, &format!("{angle:.0}°"), ui_kit::Text::Inline).backing_on_hover_text(app.tr("render.env_ring_help")),
    );
    crate::scenario::publish_target("render:environment:ring-degrees", chip.response.rect);
}

pub(super) fn editor(app: &mut SolveApp, ui: &mut egui::Ui) {
    ui_kit::scope(ui, |ui| {
        source(app, ui);
        let title = app.tr("render.environment.orientation").to_string();
        ui_kit::section(ui, "render_environment_orientation", &title, true, |ui| {
            let snapshot = setups::snapshot(app);
            let controls = environment_values(app);
            let valid = snapshot.is_ok() && controls.is_some();
            let (rotation, intensity, maximum, rotates) = controls.unwrap_or((0.0, 1.0, 100.0, false));
            ui.add_enabled_ui(valid, |ui| {
                let mut request = None;
                ui_kit::row(ui, app.tr("render.env_rotate"), |ui| {
                    ui.add_enabled_ui(rotates, |ui| {
                        if let Some(value) = edit(app, ui, "rotation-slider", rotation, |ui, value| {
                            let response =
                                ui_kit::slider(ui, value, -180.0..=180.0, ui_kit::Slider { format: |v| format!("{v:.0}°"), ..Default::default() });
                            crate::scenario::publish_target("render:environment:rotation-slider", response.rect);
                            crate::scenario::publish_target("render:environment:rotation", response.rect);
                            response
                        }) {
                            request = Some(json!({"rotation_deg":value}));
                        }
                    });
                });
                ui_kit::row(ui, app.tr("render.env_intensity"), |ui| {
                    if let Some(value) = edit(app, ui, "intensity", intensity, |ui, value| {
                        let response =
                            ui_kit::slider(ui, value, 0.0..=maximum, ui_kit::Slider { format: |v| format!("{v:.2}"), ..Default::default() });
                        crate::scenario::publish_target("render:environment:intensity", response.rect);
                        response
                    }) {
                        request = Some(json!({"intensity":value}));
                    }
                });
                if let Some(request) = request
                    && let Err(error) = commit_environment(app, request)
                {
                    app.set_status(error, true);
                }
            });
            if valid && !rotates {
                note(app, ui, "render.environment.rotation_hdr");
            }
            if !valid {
                let reason = snapshot.err().unwrap_or_else(|| app.tr("render.env_choose_source").into());
                ui_kit::text(ui, &reason, ui_kit::Text::Note("render:environment:unavailable"));
            }
        });
        backdrop(app, ui);
        ground(app, ui);
        atmosphere(app, ui);
    });
    stage_confirmation(app, ui.ctx());
}

pub(super) fn open_sources(app: &mut SolveApp) {
    super::library::open_category(app, "hdr");
    if let Err(error) = app.run("view.render_stage", json!({"stage":Stage::Light.key()})) {
        app.set_status(error, true);
    }
}

fn note(app: &SolveApp, ui: &mut egui::Ui, key: &str) {
    ui_kit::text(ui, app.tr(key), ui_kit::Text::Note(key));
}

pub(super) fn persist(app: &mut SolveApp) {
    let file = hdr::active(app).and_then(|target| match hdr::input(app, target) {
        input @ hdr::Input::FileCaptured { .. } => Some((target, input.clone())),
        _ => None,
    });
    app.render_workspace.view.dirty = true;
    if let Err(error) = setups::save_numerical(app) {
        app.set_status(error, true);
    }
    // Keep the checked path available for rechecking; the engine has captured its bytes.
    if let Some((target, input)) = file {
        match target {
            hdr::Target::Gpu => app.render_workspace.view.studio.hdr = input,
            hdr::Target::Cpu => app.render_workspace.view.cpu.hdr = input,
        }
    }
}

fn source(app: &mut SolveApp, ui: &mut egui::Ui) {
    let title = app.tr("render.env_source").to_string();
    ui_kit::section(ui, "render_environment_source", &title, true, |ui| {
        let method = app.render_workspace.view.method;
        let gpu = method == ImageMethod::GpuRaytrace;
        let target = if gpu { hdr::Target::Gpu } else { hdr::Target::Cpu };
        let selected = match method {
            ImageMethod::GpuRaytrace => match app.render_workspace.view.studio.environment {
                studio::Environment::None => 0,
                studio::Environment::Sky => 1,
                studio::Environment::Hdr => {
                    if hdr::input(app, target).embedded() {
                        3
                    } else {
                        2
                    }
                }
            },
            ImageMethod::CpuRaytrace => match app.render_workspace.view.cpu.environment {
                cpu::Environment::None => 0,
                cpu::Environment::Constant => 1,
                cpu::Environment::Sky => 4,
                cpu::Environment::Hdr => 2,
            },
            ImageMethod::Raster => 0,
        };
        let keys: &[&str] = if gpu {
            &["render.environment.none", "render.studio_sky", "render.environment.hdr_file", "render.environment.builtin"]
        } else {
            &["render.environment.none", "render.environment.constant", "render.environment.hdr", "render.environment.builtin", "render.studio_sky"]
        };
        if matches!(selected, 2 | 3) && hdr::input(app, target).embedded() {
            let name = source_name(app, ui.ctx());
            ui_kit::banner(ui, ui_kit::AssistantTone::Neutral, |ui| {
                ui_kit::text(ui, &name, ui_kit::Text::NameCell(true));
                let kind = app.tr(if gpu { "render.environment.builtin" } else { "render.environment.hdr_file" });
                let detail = hdr::metadata(app, target).map_or_else(|| kind.to_string(), |info| format!("{kind} · {} × {}", info.width, info.height));
                ui_kit::text(ui, &detail, ui_kit::Text::Inline);
                note(app, ui, "render.environment.embedded");
            });
        }
        let mut changed = false;
        ui_kit::row(ui, app.tr("render.env_source"), |ui| {
            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                let change = ui_kit::button(ui, app.tr("render.env_change"), ui_kit::Button::Normal);
                crate::scenario::publish_target("render:environment:change", change.rect);
                if change.clicked() {
                    open_sources(app);
                }

                ui.add_enabled_ui(method != ImageMethod::Raster, |ui| {
                    let picker =
                        ui_kit::dropdown_menu(ui, "render_environment_source_kind", app.tr(keys.get(selected).copied().unwrap_or(keys[0])), |ui| {
                            for (index, key) in keys.iter().enumerate() {
                                let allowed = gpu || index != 4 || app.render_workspace.view.raytrace.path.is_some();
                                let item = ui.add_enabled_ui(allowed, |ui| ui_kit::list_picker(ui, key, app.tr(key), index == selected)).inner;
                                crate::scenario::publish_target(&format!("render:environment:source:{index}"), item.rect);
                                let item = if allowed { item } else { item.on_hover_text(app.tr("render.cpu_celestial_path_required")) };
                                if item.clicked() {
                                    if index == 3 {
                                        open_sources(app);
                                    } else if index != selected {
                                        if gpu {
                                            app.render_workspace.view.studio.environment = match index {
                                                1 => studio::Environment::Sky,
                                                2 => studio::Environment::Hdr,
                                                _ => studio::Environment::None,
                                            };
                                            if index == 2 {
                                                app.render_workspace.view.studio.hdr = hdr::Input::Empty;
                                            }
                                        } else {
                                            app.render_workspace.view.cpu.environment = match index {
                                                1 => cpu::Environment::Constant,
                                                2 => cpu::Environment::Hdr,
                                                4 => cpu::Environment::Sky,
                                                _ => cpu::Environment::None,
                                            };
                                            if index == 0 || index == 4 {
                                                app.render_workspace.view.raytrace.environment = None;
                                            }
                                        }
                                        changed = true;
                                    }
                                    ui.close();
                                }
                            }
                        });
                    crate::scenario::publish_target("render:environment:source", picker.rect);
                });
            });
        });
        if method == ImageMethod::Raster {
            note(app, ui, "render.environment.source_raytrace");
        }
        if (selected == 1 && gpu) || (!gpu && selected == 4) {
            for (key, index) in [("render.environment.zenith", 0), ("render.environment.horizon", 1), ("render.environment.sky_ground", 2)] {
                let gradient = if gpu { app.render_workspace.view.studio.gradient } else { app.render_workspace.view.cpu.gradient };
                let mut value = match index {
                    0 => gradient.zenith,
                    1 => gradient.horizon,
                    _ => gradient.ground,
                }
                .map(f64::from);
                if ui_kit::row(ui, app.tr(key), |ui| ui_kit::linear_color_field(ui, &mut value, 1e6)).changed() {
                    let gradient = if gpu { &mut app.render_workspace.view.studio.gradient } else { &mut app.render_workspace.view.cpu.gradient };
                    let field = match index {
                        0 => &mut gradient.zenith,
                        1 => &mut gradient.horizon,
                        _ => &mut gradient.ground,
                    };
                    *field = value.map(|v| v as f32);
                    changed = true;
                }
            }
            note(app, ui, "render.environment.sky_note");
        } else if selected == 1 {
            let mut color = app.render_workspace.view.cpu.color;
            if ui_kit::row(ui, app.tr("render.env_colour"), |ui| ui_kit::linear_color_field(ui, &mut color, 1.0)).changed() {
                app.render_workspace.view.cpu.color = color;
                changed = true;
            }
            if method == ImageMethod::CpuRaytrace && app.render_workspace.view.raytrace.path.is_none() {
                note(app, ui, "render.cpu_constant_direct_help");
                let sampling = app.render_workspace.view.raytrace.progressive.unwrap_or_default();
                let detail = crate::i18n::format(
                    "render.cpu_constant_enable_indirect_plan",
                    &[
                        ("depth", &solidcraft_engine::render::job::CpuPathOptions::default().max_depth.to_string()),
                        ("spp", &sampling.samples_per_pixel.to_string()),
                        ("seed", &sampling.seed.to_string()),
                    ],
                );
                let action = ui_kit::button(ui, app.tr("render.cpu_volume_enable_path"), ui_kit::Button::Normal).on_hover_text(detail);
                crate::scenario::publish_target("render:environment:enable-indirect", action.rect);
                if action.clicked()
                    && let Err(error) = enable_indirect_lighting(app)
                {
                    app.set_status(error, true);
                }
            }
        } else if matches!(selected, 2 | 3) {
            let before = hdr::input(app, target).clone();
            hdr::controls(app, ui, target);
            changed |= &before != hdr::input(app, target);
            let label = app.tr("render.environment.primaries").to_string();
            ui.add_enabled_ui(gpu, |ui| {
                changed |= ui_kit::checkbox(ui, &label, &mut app.render_workspace.view.studio.assume_linear_srgb).changed();
            });
            if !gpu {
                note(app, ui, "render.environment.primaries_gpu");
            }
            ui.add_enabled_ui(!gpu, |ui| {
                let samples = app.render_workspace.view.cpu.samples;
                ui_kit::row(ui, app.tr("render.environment.lighting_samples"), |ui| {
                    ui_kit::dropdown_menu(ui, "render_environment_lighting_samples", &samples.to_string(), |ui| {
                        for count in [1, 4, 16, 64] {
                            if ui_kit::list_picker(ui, &count.to_string(), &count.to_string(), count == samples).clicked() {
                                app.render_workspace.view.cpu.samples = count;
                                changed = true;
                                ui.close();
                            }
                        }
                    });
                });
            });
            if gpu {
                note(app, ui, "render.environment.samples_cpu");
            }
        }
        if changed {
            app.render_workspace.view.dirty = true;
            // An unchecked path stays in the existing draft until the user checks it.
            if hdr::active(app).is_none_or(|target| hdr::input(app, target).resource().is_some()) {
                persist(app);
            }
        }
    });
}

fn source_name(app: &mut SolveApp, ctx: &egui::Context) -> String {
    let source = match app.render_workspace.view.method {
        ImageMethod::CpuRaytrace => {
            app.render_workspace.view.cpu.hdr.resource().filter(|_| app.render_workspace.view.cpu.environment == cpu::Environment::Hdr)
        }
        ImageMethod::GpuRaytrace => {
            app.render_workspace.view.studio.hdr.resource().filter(|_| app.render_workspace.view.studio.environment == studio::Environment::Hdr)
        }
        ImageMethod::Raster => None,
    };
    if let Some(source) = source {
        type Names = std::sync::Arc<std::collections::BTreeMap<String, String>>;
        let cache = egui::Id::unique("render_environment_catalog_names");
        let names = ctx.data_mut(|data| data.get_temp::<Names>(cache)).unwrap_or_else(|| {
            let mut names = std::collections::BTreeMap::new();
            if let Ok(reply) = app.run("render.library.list", json!({"kind":"hdr","limit":128})) {
                for entry in reply["items"].as_array().into_iter().flatten().take(128) {
                    if let Some(id) = entry["id"].as_str()
                        && let Ok(detail) = app.run("render.library.describe", json!({"kind":"hdr","id":id}))
                        && let (Some(digest), Some(name)) = (detail["resource"]["sha256"].as_str(), detail["resource"]["name"].as_str())
                    {
                        names.insert(digest.to_string(), name.to_string());
                    }
                }
            }
            let names = std::sync::Arc::new(names);
            ctx.data_mut(|data| data.insert_temp(cache, names.clone()));
            names
        });
        if let Some(name) = names.get(&source.to_string()) {
            return name.clone();
        }
    }
    super::scene::environment(app).0
}

fn environment_values(app: &SolveApp) -> Option<(f64, f64, f64, bool)> {
    let v = &app.render_workspace.view;
    match v.method {
        ImageMethod::GpuRaytrace if v.studio.environment != studio::Environment::None => {
            Some((wrapped_degrees(v.studio.rotation_rad), v.studio.intensity, 100.0, true))
        }
        ImageMethod::CpuRaytrace if v.cpu.environment != cpu::Environment::None => Some((
            wrapped_degrees(v.cpu.rotation_rad),
            v.cpu.intensity,
            if v.cpu.environment == cpu::Environment::Sky { 100.0 } else { 64.0 },
            v.cpu.environment != cpu::Environment::Constant,
        )),
        _ => None,
    }
}

fn wrapped_degrees(radians: f64) -> f64 {
    let degrees = radians.to_degrees();
    if degrees.is_finite() { (degrees + 180.0).rem_euclid(360.0) - 180.0 } else { 0.0 }
}

pub(super) fn commit_environment(app: &mut SolveApp, mut request: Value) -> Result<(), String> {
    let fields = request.as_object_mut().ok_or_else(|| app.tr("render.env_invalid_edit").to_string())?;
    fields.insert("name".into(), json!(app.render_workspace.view.name));
    let mut setup = serde_json::to_value(setups::snapshot(app)?).map_err(|error| error.to_string())?;
    if let Some(fields) = setup.as_object_mut() {
        fields.remove("camera");
    }
    fields.insert("set".into(), setup);
    app.run("render.environment.set", request)?;
    setups::reload_numerical(app);
    Ok(())
}

fn save(app: &mut SolveApp, setup: RenderSetup) -> Result<(), String> {
    // Numerical environment edits keep the shot's explicit Update camera policy.
    let mut patch = serde_json::to_value(setup).map_err(|error| error.to_string())?;
    if let Some(fields) = patch.as_object_mut() {
        fields.remove("camera");
    }
    app.run("render.settings.set", json!({"name":app.render_workspace.view.name,"set":patch}))?;
    setups::reload_numerical(app);
    Ok(())
}

pub(super) fn commit_backdrop(app: &mut SolveApp, color: [u8; 3], transparent: bool) -> Result<(), String> {
    let mut setup = setups::snapshot(app)?;
    setup.background = color;
    match &mut setup.job {
        Some(RenderJob::Raster { transparent_background }) => *transparent_background = transparent,
        Some(RenderJob::GpuPath { transparent_background, options }) => {
            *transparent_background = transparent;
            options.backdrop = None;
        }
        Some(RenderJob::CpuRaytrace { options, transparent_background }) => {
            *transparent_background = transparent;
            if let Some(output) = &mut options.output {
                output.backdrop = None;
            }
        }
        _ => {}
    }
    save(app, setup)
}

// Keep an in-progress gesture outside the design. Release/Enter commits once;
// external commands, undo and document switches invalidate its temporary identity.
fn edit<T: Clone + PartialEq + Send + Sync + 'static>(
    app: &SolveApp,
    ui: &mut egui::Ui,
    key: &str,
    current: T,
    draw: impl FnOnce(&mut egui::Ui, &mut T) -> egui::Response,
) -> Option<T> {
    let id = ui.scope_id().with((
        "render-environment",
        key,
        &app.render_workspace.view.name,
        std::sync::Arc::as_ptr(&app.session.doc),
        app.session.revision,
    ));
    let (_, mut value, mut pending) = ui
        .data_mut(|data| data.get_temp::<(T, T, bool)>(id))
        .filter(|(original, _, _)| original == &current)
        .unwrap_or((current.clone(), current.clone(), false));
    let response = draw(ui, &mut value);
    pending |= response.changed();
    let escape = ui.input(|input| input.key_pressed(egui::Key::Escape));
    let finished =
        response.drag_stopped() || response.lost_focus() || (!ui.input(|input| input.pointer.any_down()) && !ui.ctx().egui_wants_keyboard_input());
    if escape || (pending && finished) {
        ui.data_mut(|data| data.remove::<(T, T, bool)>(id));
        return (!escape).then_some(value);
    }
    ui.data_mut(|data| data.insert_temp(id, (current, value, pending)));
    None
}

fn backdrop(app: &mut SolveApp, ui: &mut egui::Ui) {
    use solidcraft_engine::render::job::finishing::BackdropMode;
    let title = app.tr("render.env_backdrop").to_string();
    ui_kit::section(ui, "render_environment_backdrop", &title, true, |ui| {
        let raytrace = app.render_workspace.view.method != ImageMethod::Raster;
        let mut mode = if app.render_workspace.view.transparent {
            3
        } else if app.render_workspace.view.studio.backdrop_enabled && raytrace {
            2
        } else {
            1
        };
        let before_mode = mode;
        ui_kit::segmented(
            ui,
            &mut mode,
            &[app.tr("render.environment.world"), app.tr("render.env_colour"), app.tr("render.environment.gradient"), app.tr("render.env_clear")],
            ui_kit::Segments {
                enabled: &[false, true, raytrace && !app.render_workspace.view.transparent, true],
                targets: &["render:environment:world", "render:environment:colour", "render:environment:gradient", "render:environment:clear"],
                ..Default::default()
            },
        );
        if mode == 2 && !raytrace {
            app.set_status(app.tr("render.output_raytrace_only").to_string(), true);
            mode = before_mode;
        }
        if mode != before_mode {
            let result = if mode == 2 {
                commit_gradient(app, true, app.render_workspace.view.studio.backdrop)
            } else {
                commit_backdrop(app, app.render_workspace.view.draft.background, mode == 3)
            };
            if let Err(error) = result {
                app.set_status(error, true);
            }
        }
        if mode == 1 {
            let color = edit(app, ui, "backdrop-colour", app.render_workspace.view.draft.background, |ui, value| {
                ui_kit::row(ui, app.tr("render.env_colour"), |ui| {
                    let response = ui_kit::color_field(ui, value);
                    crate::scenario::publish_target("render:environment:backdrop-colour", response.rect);
                    response
                })
            });
            if let Some(color) = color
                && let Err(error) = commit_backdrop(app, color, false)
            {
                app.set_status(error, true);
            }
        }
        if mode == 2 || !raytrace {
            let mut gradient = app.render_workspace.view.studio.backdrop;
            let mut changed = false;
            ui.add_enabled_ui(raytrace && !app.render_workspace.view.transparent, |ui| {
                let mut mode = match gradient.mode {
                    BackdropMode::Vertical => 0,
                    BackdropMode::Horizontal => 1,
                    BackdropMode::Radial => 2,
                };
                changed |= ui_kit::row(ui, app.tr("render.environment.mode"), |ui| {
                    ui_kit::segmented(
                        ui,
                        &mut mode,
                        &[app.tr("render.environment.vertical"), app.tr("render.environment.horizontal"), app.tr("render.environment.radial")],
                        Default::default(),
                    )
                });
                gradient.mode = match mode {
                    1 => BackdropMode::Horizontal,
                    2 => BackdropMode::Radial,
                    _ => BackdropMode::Vertical,
                };
                for (key, value) in [("render.environment.start", &mut gradient.first_srgb), ("render.environment.end", &mut gradient.second_srgb)] {
                    if let Some(color) = edit(app, ui, key, *value, |ui, value| ui_kit::row(ui, app.tr(key), |ui| ui_kit::color_field(ui, value))) {
                        *value = color;
                        changed = true;
                    }
                }
                ui.add_enabled_ui(gradient.mode == BackdropMode::Radial, |ui| {
                    for (index, key) in [(0, "render.backdrop_x"), (1, "render.backdrop_y")] {
                        if let Some(value) = gradient.center.get_mut(index)
                            && let Some(number) = edit(app, ui, key, *value, |ui, value| {
                                ui_kit::row(ui, app.tr(key), |ui| ui_kit::number_field(ui, value, 0.0..=1.0, 0.01, ""))
                            })
                        {
                            *value = number;
                            changed = true;
                        }
                    }
                    if let Some(number) = edit(app, ui, "gradient-radius", gradient.radius, |ui, value| {
                        ui_kit::row(ui, app.tr("render.backdrop_radius"), |ui| ui_kit::number_field(ui, value, 0.05..=4.0, 0.01, ""))
                    }) {
                        gradient.radius = number;
                        changed = true;
                    }
                });
                if gradient.mode != BackdropMode::Radial {
                    note(app, ui, "render.environment.radial_only");
                }
            });
            if changed && let Err(error) = commit_gradient(app, true, gradient) {
                app.set_status(error, true);
            }
        }
        ui.add_enabled_ui(false, |ui| {
            ui_kit::row(ui, app.tr("render.env_blur"), |ui| {
                ui_kit::slider(ui, &mut 0.0, 0.0..=100.0, ui_kit::Slider { format: |v| format!("{v:.0} %"), ..Default::default() })
            });
        });
        note(app, ui, "render.environment.blur_pending");
        note(app, ui, "render.environment.backdrop_note");
        note(app, ui, "render.environment.world_pending");
        if !raytrace {
            note(app, ui, "render.output_raytrace_only");
        }
    });
}

pub(super) fn commit_gradient(
    app: &mut SolveApp,
    enabled: bool,
    gradient: solidcraft_engine::render::job::finishing::Backdrop,
) -> Result<(), String> {
    let mut setup = setups::snapshot(app)?;
    match &mut setup.job {
        Some(RenderJob::GpuPath { options, .. }) => options.backdrop = enabled.then_some(gradient),
        Some(RenderJob::CpuRaytrace { options, .. }) => {
            options.output.get_or_insert_with(Box::default).backdrop = enabled.then_some(gradient);
        }
        _ => return Err(app.tr("render.output_raytrace_only").into()),
    }
    save(app, setup)
}

#[derive(Clone)]
pub(super) struct Ground {
    pub margin: f64,
    pub gap: f64,
    pub color: [f64; 3],
}

fn ground_values(app: &SolveApp, setup: &RenderSetup) -> Ground {
    let mut value = Ground { margin: 0.25, gap: 0.1, color: [0.18; 3] };
    if let Some(panel) = setup.stage.iter().find(|panel| matches!(panel.id.as_str(), "ground" | "studio_ground")) {
        value.color = panel.reflectance_linear;
        if let Ok(scene) = solidcraft_engine::product_scene::extract(&app.session)
            && !scene.bounds.is_empty()
        {
            let bounds = scene.bounds;
            let size = bounds.max - bounds.min;
            let extent = size.x.max(size.y).max(size.z).max(0.001);
            value.margin = ((panel.half_u_mm.first().copied().unwrap_or(0.0).abs() - (size.x * 0.5).max(0.001)) / extent).clamp(0.0, 10.0);
            value.gap = (bounds.min.z - panel.center_mm.get(2).copied().unwrap_or(bounds.min.z)).clamp(0.0001, 1000.0);
        }
    }
    value
}

pub(super) fn commit_ground(app: &mut SolveApp, enabled: bool, value: Ground) -> Result<(), String> {
    let set = setups::snapshot(app)?;
    let request = if enabled {
        json!({"name":app.render_workspace.view.name,"set":set,"margin_fraction":value.margin,"gap_mm":value.gap,"reflectance_linear":value.color,"replace_stage":true})
    } else {
        json!({"name":app.render_workspace.view.name,"set":set})
    };
    app.run(if enabled { "render.stage.ground" } else { "render.stage.clear" }, request)?;
    setups::load(app);
    Ok(())
}

#[derive(Clone)]
struct GroundForm {
    value: Ground,
    replace: bool,
}

#[derive(Clone)]
struct StageRemoval {
    document: Weak<solidcraft_engine::doc::Document>,
    revision: u64,
    name: String,
    set: RenderSetup,
}

pub(super) fn request_stage_removal(app: &SolveApp, ctx: &egui::Context) {
    if let Ok(set) = setups::snapshot(app) {
        ctx.data_mut(|data| {
            data.insert_temp(
                egui::Id::unique("render_remove_stage"),
                StageRemoval {
                    document: Arc::downgrade(&app.session.doc),
                    revision: app.session.revision,
                    name: app.render_workspace.view.name.clone(),
                    set,
                },
            )
        });
    }
}

pub(super) fn stage_confirmation(app: &mut SolveApp, ctx: &egui::Context) {
    let id = egui::Id::unique("render_remove_stage");
    let Some(pending) = ctx.data_mut(|data| data.get_temp::<StageRemoval>(id)) else { return };
    if pending.revision != app.session.revision
        || pending.name != app.render_workspace.view.name
        || !Weak::ptr_eq(&pending.document, &Arc::downgrade(&app.session.doc))
        || setups::snapshot(app).as_ref() != Ok(&pending.set)
    {
        ctx.data_mut(|data| data.remove::<StageRemoval>(id));
        return;
    }
    let title = app.tr("render.environment.remove_confirm").to_string();
    let remove = app.tr("render.environment.remove").to_string();
    let cancel = app.tr("render.environment.keep").to_string();
    let detail = crate::i18n::Locale::for_language(&app.preferences.language)
        .format("render.environment.remove_note", &[("count", &pending.set.stage.len().to_string())]);
    let (closed, action) =
        ui_kit::Confirm::new(id, "delete", &title).tone(ui_kit::Tone::Danger).actions(&remove, &cancel, None).show(ctx, true, |ui| {
            ui_kit::text(ui, &detail, ui_kit::Text::Note("render.environment.remove_note"));
        });
    if closed || matches!(action, ui_kit::Action::Cancel | ui_kit::Action::Ok) {
        ctx.data_mut(|data| data.remove::<StageRemoval>(id));
    }
    if !closed && action == ui_kit::Action::Ok {
        match app.run("render.stage.clear", json!({"name":pending.name,"set":pending.set})) {
            Ok(_) => setups::load(app),
            Err(error) => app.set_status(error, true),
        }
    }
}

fn ground(app: &mut SolveApp, ui: &mut egui::Ui) {
    let title = app.tr("render.environment.ground").to_string();
    ui_kit::section(ui, "render_environment_ground", &title, true, |ui| {
        let snapshot = setups::snapshot(app);
        let id = ui.scope_id().with(("ground-form", Arc::as_ptr(&app.session.doc), app.session.revision, &app.render_workspace.view.name));
        let mut form = ui.data_mut(|data| data.get_temp::<GroundForm>(id)).unwrap_or_else(|| GroundForm {
            value: snapshot.as_ref().map(|set| ground_values(app, set)).unwrap_or(Ground { margin: 1.0, gap: 0.1, color: [0.18; 3] }),
            replace: false,
        });
        let supported = app.render_workspace.view.method != ImageMethod::Raster;
        ui.add_enabled_ui(supported, |ui| {
            for (key, value, range, speed, unit) in [
                ("render.environment.margin", &mut form.value.margin, 0.0..=10.0, 0.05, "×"),
                ("render.environment.gap", &mut form.value.gap, 0.0001..=1000.0, 0.01, " mm"),
            ] {
                ui_kit::row(ui, app.tr(key), |ui| ui_kit::number_field(ui, value, range, speed, unit));
            }
            vector_row(ui, app.tr("render.environment.reflectance"), &mut form.value.color, 0.0..=1.0, 0.01, "");
            ui_kit::checkbox(ui, app.tr("render.environment.replace"), &mut form.replace);
            let ready = snapshot.as_ref().is_ok_and(|set| set.stage.is_empty() || form.replace);
            let fit = ui
                .add_enabled_ui(ready, |ui| {
                    ui.with_layout(egui::Layout::top_down_justified(egui::Align::Min), |ui| {
                        ui_kit::button(ui, app.tr("render.environment.fit"), ui_kit::Button::Primary)
                    })
                    .inner
                })
                .inner;
            crate::scenario::publish_target("render:environment:fit-ground", fit.rect);
            if fit.clicked()
                && let Err(error) = commit_ground(app, true, form.value.clone())
            {
                app.set_status(error, true);
            }
            ui.horizontal(|ui| {
                for (kind, key) in [("floor_wall", "render.environment.floor_wall"), ("cyclorama", "render.environment.cyclorama")] {
                    if ui_kit::button(ui, app.tr(key), ui_kit::Button::Enabled(ready)).clicked()
                        && let Ok(set) = &snapshot
                    {
                        let request = json!({"name":app.render_workspace.view.name,"set":set,"kind":kind,"expected_revision":app.session.revision,
                            "replace_stage":form.replace,"reflectance_linear":form.value.color});
                        match app.run("render.stage.backdrop", request) {
                            Ok(_) => setups::load(app),
                            Err(error) => app.set_status(error, true),
                        }
                    }
                }
            });
        });
        if !supported {
            note(app, ui, "render.environment.stage_raytrace");
        }
        ui.horizontal(|ui| {
            let count = app.render_workspace.view.draft.stage.len();
            ui_kit::text(
                ui,
                &crate::i18n::Locale::for_language(&app.preferences.language)
                    .format("render.environment.saved_panels", &[("count", &count.to_string())]),
                ui_kit::Text::Inline,
            );
            let remove = ui_kit::icon_label_button(ui, app.tr("render.environment.remove"), "delete", count > 0 && snapshot.is_ok(), true);
            crate::scenario::publish_target("render:stage-clear", remove.rect);
            if remove.clicked() {
                request_stage_removal(app, ui.ctx());
            }
        });
        ui.data_mut(|data| data.insert_temp(id, form));
        if let Err(error) = snapshot {
            ui_kit::text(ui, &error, ui_kit::Text::Note("render:environment:ground-unavailable"));
        }
    });
}

/// Compact vector row; the shared row and number fields own spacing and interaction.
fn vector_row(ui: &mut egui::Ui, label: &str, value: &mut [f64; 3], range: std::ops::RangeInclusive<f64>, speed: f64, unit: &str) -> bool {
    ui_kit::row(ui, label, |ui| {
        ui.horizontal(|ui| {
            let mut changed = false;
            let width = ((ui.available_width() - Tokens::get().space_8) / 3.0).max(Tokens::get().space_16);
            for (index, component) in value.iter_mut().enumerate() {
                ui.push_id(index, |ui| {
                    ui.set_width(width);
                    changed |= ui_kit::number_field(ui, component, range.clone(), speed, unit).changed();
                });
            }
            changed
        })
        .inner
    })
}

/// Full prospective validation, shared by visible controls and method adoption.
pub(super) fn validate_atmosphere(app: &SolveApp) -> Result<(), String> {
    validate_volume_value(app, app.render_workspace.view.studio.volume)
}

fn validate_volume_value(app: &SolveApp, value: Option<solidcraft_engine::render::job::volume::HomogeneousVolume>) -> Result<(), String> {
    let view = &app.render_workspace.view;
    let Some(volume) = value else { return Ok(()) };
    volume.validate().map_err(|error| error.to_string())?;
    if view.method == ImageMethod::Raster {
        return Err(app.tr("render.output_raytrace_only").into());
    }
    if !volume.active() {
        return Ok(());
    }
    if view.method == ImageMethod::CpuRaytrace && view.raytrace.path.is_none() {
        return Err(app.tr("render.cpu_volume_path_required").into());
    }
    if view.studio.denoise {
        return Err(app.tr("render.volume_denoise_required").into());
    }
    if !view.draft.optics.is_empty()
        || (view.method == ImageMethod::CpuRaytrace && !view.raytrace.dielectrics.is_empty())
        || (view.materials.enabled && view.materials.bindings.iter().any(|binding| binding.enabled && binding.glass_enabled))
    {
        return Err(app.tr("render.volume_glass_required").into());
    }
    if view.method == ImageMethod::GpuRaytrace {
        if view.studio.transmission_samples != 1 {
            return Err(app.tr("render.volume_single_stratum_required").into());
        }
        if !view.studio.lighting_enabled && view.studio.environment == studio::Environment::None {
            return Err(app.tr("render.volume_lighting_required").into());
        }
        volume.relative_bounds([app.cam.target.x, app.cam.target.y, app.cam.target.z]).map_err(|error| error.to_string())?;
    }
    Ok(())
}

/// Change only the volume intent through one non-camera numerical transaction.
/// Corrective removal never needs an invalid previous volume to validate.
pub(super) fn commit_atmosphere(app: &mut SolveApp, volume: Option<solidcraft_engine::render::job::volume::HomogeneousVolume>) -> Result<(), String> {
    if app.render_workspace.view.method == ImageMethod::Raster {
        return Err(app.tr("render.output_raytrace_only").into());
    }
    if setups::has_unportable_bindings(app) {
        return Err(app.tr("render.setup_runtime_unsupported").into());
    }
    let before = setups::draft(app)?;
    let source = Arc::downgrade(&app.session.doc.render);
    let rig = super::light::rows(app)?;
    let previous = app.render_workspace.view.clone();
    app.render_workspace.view.studio.volume = volume;
    let result = validate_atmosphere(app).and_then(|()| setups::persist_editor(app, &before));
    if let Err(error) = result {
        app.render_workspace.view = previous;
        return Err(error);
    }
    super::light::volume_edited(app, &source, previous.method, &before, &rig);
    Ok(())
}

/// Explicit, camera-neutral adoption shared by constant environment and Atmosphere.
/// Every authored field is retained unless this action names its transport change.
pub(super) fn enable_indirect_lighting(app: &mut SolveApp) -> Result<(), String> {
    if app.render_workspace.view.method != ImageMethod::CpuRaytrace {
        return Err(app.tr("render.cpu_indirect_method_required").into());
    }
    if setups::has_unportable_bindings(app) {
        return Err(app.tr("render.setup_runtime_unsupported").into());
    }
    let before = setups::draft(app)?;
    let source = Arc::downgrade(&app.session.doc.render);
    let rig = super::light::rows(app)?;
    let previous = app.render_workspace.view.clone();
    let options = &mut app.render_workspace.view.raytrace;
    options.path.get_or_insert_default();
    options.progressive.get_or_insert_default();
    options.primary_samples = 1;
    options.shadows = true;
    app.render_workspace.view.cpu_sampling_initialized = true;
    let result = super::materials::path_compatibility(app)
        .and_then(|()| cpu::validate_progressive_image(app))
        .and_then(|()| validate_atmosphere(app))
        // Pure full authored intent: includes lens/camera, legacy environment,
        // resources and the selected image/profile without IO or source capture.
        .and_then(|()| setups::snapshot(app).map(|_| ()))
        .and_then(|()| setups::persist_editor(app, &before));
    if let Err(error) = result {
        app.render_workspace.view = previous;
        return Err(error);
    }
    super::light::volume_edited(app, &source, previous.method, &before, &rig);
    Ok(())
}

fn volume_vector_row(
    app: &SolveApp,
    ui: &mut egui::Ui,
    key: &str,
    id: &str,
    current: [f64; 3],
    range: std::ops::RangeInclusive<f64>,
    speed: f64,
) -> Option<[f64; 3]> {
    let mut value = current;
    let mut changed = false;
    ui_kit::row(ui, app.tr(key), |ui| {
        ui.columns(3, |columns| {
            for (index, (ui, component)) in columns.iter_mut().zip(current).enumerate() {
                let width = ui.available_width().max(0.0);
                ui.spacing_mut().text_edit_width = width;
                ui.spacing_mut().interact_size.x = width;
                ui.set_clip_rect(ui.clip_rect().intersect(ui.max_rect()));
                if let Some(edited) = edit(app, ui, &format!("volume-{id}-{index}"), component, |ui, value| {
                    let response = ui_kit::number_field_preserving(ui, value, range.clone(), speed, "");
                    crate::scenario::publish_target(&format!("render:volume:{id}:{index}"), response.rect);
                    response
                }) {
                    value[index] = edited;
                    changed = true;
                }
            }
        });
    });
    changed.then_some(value)
}

/// One common authoring surface; CPU/GPU preserve the same world-mm box intent.
pub(super) fn atmosphere(app: &mut SolveApp, ui: &mut egui::Ui) {
    let title = app.tr("render.environment.atmosphere").to_string();
    ui_kit::section_method(ui, "render_environment_atmosphere", &title, true, "CPU / GPU", |ui| {
        let method = app.render_workspace.view.method;
        let before = app.render_workspace.view.studio.volume;
        let mut volume = before.unwrap_or_default();
        let mut enabled = before.is_some();
        let mut changed = false;
        let cpu = method == ImageMethod::CpuRaytrace;
        let path = app.render_workspace.view.raytrace.path.is_some();
        let prospective_reason = if before.is_none() { validate_volume_value(app, Some(volume)).err() } else { None };
        let supported = method == ImageMethod::GpuRaytrace || (cpu && (path || before.is_some()));
        ui.add_enabled_ui(supported, |ui| {
            let toggle = ui
                .add_enabled_ui(before.is_some() || prospective_reason.is_none(), |ui| {
                    ui_kit::checkbox(ui, app.tr("render.environment.medium"), &mut enabled)
                })
                .inner;
            let toggle = if let Some(reason) = &prospective_reason { toggle.on_disabled_hover_text(reason) } else { toggle };
            crate::scenario::publish_target("render:volume-enable", toggle.rect);
            changed |= toggle.changed();
            ui.add_enabled_ui(enabled, |ui| {
                if let Some(value) = volume_vector_row(app, ui, "render.environment.min", "min", volume.min_mm, -1e9..=1e9, 1.0) {
                    volume.min_mm = value;
                    changed = true;
                }
                if let Some(value) = volume_vector_row(app, ui, "render.environment.max", "max", volume.max_mm, -1e9..=1e9, 1.0) {
                    volume.max_mm = value;
                    changed = true;
                }
                if let Some(value) = edit(app, ui, "volume-extinction", volume.extinction_per_mm, |ui, value| {
                    ui_kit::row(ui, app.tr("render.environment.extinction"), |ui| {
                        let response = ui_kit::number_field_preserving(ui, value, 0.0..=1000.0, 0.0001, " /mm");
                        crate::scenario::publish_target("render:volume:extinction", response.rect);
                        response
                    })
                }) {
                    volume.extinction_per_mm = value;
                    changed = true;
                }
                if let Some(value) = volume_vector_row(app, ui, "render.environment.albedo", "albedo", volume.scattering_albedo, 0.0..=1.0, 0.01) {
                    volume.scattering_albedo = value;
                    changed = true;
                }
                if let Some(value) = edit(app, ui, "volume-anisotropy", volume.anisotropy, |ui, value| {
                    ui_kit::row(ui, app.tr("render.environment.phase"), |ui| {
                        let response = ui_kit::number_field_preserving(ui, value, -0.95..=0.95, 0.01, "");
                        crate::scenario::publish_target("render:volume:anisotropy", response.rect);
                        response
                    })
                }) {
                    volume.anisotropy = value;
                    changed = true;
                }
            });
        });
        if method == ImageMethod::Raster {
            note(app, ui, "render.output_raytrace_only");
        }
        if cpu {
            note(app, ui, "render.cpu_volume_help");
            if !path {
                let sampling = app.render_workspace.view.raytrace.progressive.unwrap_or_default();
                let detail = crate::i18n::format(
                    "render.cpu_volume_enable_path_plan",
                    &[
                        ("depth", &solidcraft_engine::render::job::CpuPathOptions::default().max_depth.to_string()),
                        ("spp", &sampling.samples_per_pixel.to_string()),
                        ("seed", &sampling.seed.to_string()),
                    ],
                );
                let action = ui_kit::button(ui, app.tr("render.cpu_volume_enable_path"), ui_kit::Button::Normal).on_hover_text(detail);
                crate::scenario::publish_target("render:volume-enable-path", action.rect);
                if action.clicked()
                    && let Err(error) = enable_indirect_lighting(app)
                {
                    app.set_status(error, true);
                }
            }
        }
        if let Some(reason) = prospective_reason.or_else(|| validate_atmosphere(app).err()) {
            ui_kit::text(ui, &reason, ui_kit::Text::Note("render:volume:reason"));
        }
        if changed && let Err(error) = commit_atmosphere(app, enabled.then_some(volume)) {
            app.set_status(error, true);
        }
    });
}