Skip to content

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

22.1 KB
Raw Blame
//! Render scene content in the shared Browser host and row painter.
use super::{ImageMethod, RenderSelection, cpu, hdr, inspector, setups, studio};
use crate::{
    SolveApp,
    browser::{self, Row},
    context_menu::{self, Item},
    theme::Tokens,
    ui_kit,
};
use egui::Color32;
use serde_json::json;
use solidcraft_engine::{
    Sel,
    doc::{ModelBody, appearance::Look},
};

#[derive(Default)]
pub(crate) struct Decoration {
    pub swatch: Option<Color32>,
    pub name: String,
    pub count: String,
}

pub(crate) fn decoration(app: &SolveApp, names: &[String]) -> Decoration {
    if !super::active(app) {
        return Decoration::default();
    }
    let state = crate::open_meshing::session_world(&app.session);
    let bodies: Vec<_> = names.iter().filter_map(|name| state.body(name)).collect();
    let Some(body) = bodies.first() else { return Decoration::default() };
    let look = object_look(app, body);
    let mixed = bodies.iter().any(|b| object_look(app, b) != look);
    let count = bodies.iter().map(|b| app.session.doc.face_colors(b).len()).fold(0usize, usize::saturating_add);
    Decoration {
        swatch: Some(if mixed { Tokens::get().text_dim } else { look_color(app, body, look.as_ref()) }),
        name: if mixed { app.tr("render.tree_mixed").into() } else { look_name(app, look.as_ref()) },
        count: if count == 0 {
            String::new()
        } else {
            crate::i18n::format(if count == 1 { "render.tree_face_one" } else { "render.tree_face_count" }, &[("count", &count.to_string())])
        },
    }
}

fn object_look(app: &SolveApp, body: &ModelBody) -> Option<Look> {
    let face = app.session.selection.iter().rev().find_map(|s| match s {
        Sel::Face { body: name, index, .. } if name == &body.name => Some(*index),
        _ => None,
    });
    face.map_or_else(|| app.session.doc.model_display_look(body), |face| app.session.doc.model_face_look(body, face))
}

pub(crate) fn same_look(app: &SolveApp, names: &[String]) -> bool {
    let state = crate::open_meshing::session_world(&app.session);
    let mut looks = names.iter().filter_map(|name| state.body(name)).map(|body| app.session.doc.model_display_look(body));
    let Some(first) = looks.next() else { return false };
    looks.all(|look| look == first)
}

fn look_name(app: &SolveApp, look: Option<&Look>) -> String {
    look.map_or_else(|| app.tr("render.tree_default").into(), |look| look.name.clone())
}
fn look_color(app: &SolveApp, body: &ModelBody, look: Option<&Look>) -> Color32 {
    let color = look.map(|l| l.color).or_else(|| app.session.doc.body_color(body).map(|c| c.map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8)));
    color.map_or(Tokens::get().body, |rgb| crate::theme::srgb(rgb.map(|channel| f32::from(channel) / 255.0)))
}

fn section(app: &mut SolveApp, ui: &mut egui::Ui, key: &str) -> bool {
    let id = format!("render:tree:{key}");
    let open = browser::is_open(app, &id, true);
    let label = app.tr(&format!("render.tree_{key}")).to_string();
    let add_label = app.tr(if key == "lights" { "render.tree_add_light" } else { "render.tree_add_shot" }).to_string();
    let pending = app.tr("render.method_limit_raster").to_string();
    let actions = [ui_kit::TreeAction {
        icon: "plus",
        hover_only: false,
        label: &add_label,
        reason: (key == "lights" && app.render_workspace.view.method == ImageMethod::Raster).then_some(pending.as_str()),
        target: if key == "lights" { "render:tree:lights:add" } else { "render:tree:shots:add" },
    }];
    let row = browser::draw_row(
        ui,
        ui.scope_id().with(&id),
        &Row {
            label: &label,
            name: true,
            icon: match key {
                "lights" => "render_scene",
                "shots" => "camera",
                _ => "box",
            },
            secondary: &match key {
                "lights" => light_types(app).len(),
                "shots" => app.session.doc.render.setups.len(),
                _ => crate::open_meshing::session_world(&app.session).bodies.len(),
            }
            .to_string(),
            fold: Some(open),
            selected: key == "lights" && app.render_workspace.view.selection == RenderSelection::Lighting,
            actions: if matches!(key, "lights" | "shots") { &actions } else { &[] },
            ..Default::default()
        },
    );
    if let Some(rect) = row.rect {
        crate::scenario::publish_target(&id, rect);
    }
    if row.actions.iter().any(|r| r.clicked()) {
        // Shot naming and saving use the existing Save shot prompt.
        if key == "lights" {
            if let Err(error) = super::light::edit(app, "render.lights.add", None, Some(json!({"kind":"area"}))) {
                app.set_status(error, true);
            }
        } else {
            app.start("render.settings.set");
        }
    }
    if row.clicked && key == "lights" {
        select(app, "lighting", None);
    }
    if row.fold || (row.clicked && key != "lights") {
        browser::toggle(app, &id, true);
    }
    open
}

fn select(app: &mut SolveApp, kind: &str, id: Option<&str>) {
    let params = id.map_or_else(|| json!({"kind":kind}), |id| json!({"kind":kind,"id":id}));
    let _ = app.run("view.render_select", params);
}

pub(crate) fn light_types(app: &SolveApp) -> Vec<&'static str> {
    super::light::rows(app)
        .unwrap_or_default()
        .iter()
        .map(|light| match light.geometry {
            solidcraft_engine::schema::render_lights::Geometry::Directional { angular_radius_rad: Some(_), .. } => "render.tree_sun",
            solidcraft_engine::schema::render_lights::Geometry::Directional { .. } => "render.tree_directional",
            solidcraft_engine::schema::render_lights::Geometry::Point { .. } => "render.tree_point",
            solidcraft_engine::schema::render_lights::Geometry::Spot { .. } => "render.tree_spot",
            solidcraft_engine::schema::render_lights::Geometry::Area { .. } => "render.tree_rectangle",
        })
        .collect()
}
pub(crate) fn environment(app: &SolveApp) -> (String, String) {
    let view = &app.render_workspace.view;
    if view.method == ImageMethod::GpuRaytrace && view.studio.environment == studio::Environment::None && view.studio.lighting_enabled {
        // An explicit constant, including black, is not the implicit studio.
        // It owns RGB radiance, not the legacy draft rotation/intensity pair.
        return (app.tr("render.tree_constant").to_string(), String::new());
    }
    let fixed = || (app.tr("render.tree_fixed_studio").to_string(), view.draft.environment_rotation, view.draft.environment_intensity);
    let source = |input: &hdr::Input| match input {
        hdr::Input::EmbeddedResource { resource } => format!("{} {resource}", app.tr("render.tree_hdr")),
        hdr::Input::FileCaptured { path, .. } | hdr::Input::FilePending { path } => {
            std::path::Path::new(path).file_name().map(|s| s.to_string_lossy().into_owned()).unwrap_or_else(|| app.tr("render.tree_hdr").into())
        }
        hdr::Input::Empty => app.tr("render.tree_no_environment").into(),
    };
    let (name, rotation, intensity) = match view.method {
        ImageMethod::CpuRaytrace => match view.cpu.environment {
            cpu::Environment::Hdr => (source(&view.cpu.hdr), view.cpu.rotation_rad, view.cpu.intensity),
            cpu::Environment::Sky => (app.tr("render.studio_sky").into(), view.cpu.rotation_rad, view.cpu.intensity),
            cpu::Environment::Constant => (app.tr("render.tree_constant").into(), 0.0, view.cpu.intensity),
            cpu::Environment::None => fixed(),
        },
        ImageMethod::GpuRaytrace => match view.studio.environment {
            studio::Environment::Hdr => (source(&view.studio.hdr), view.studio.rotation_rad, view.studio.intensity),
            studio::Environment::Sky => (app.tr("render.tree_sky").into(), view.studio.rotation_rad, view.studio.intensity),
            studio::Environment::None => fixed(),
        },
        ImageMethod::Raster => fixed(),
    };
    (
        name,
        crate::i18n::format(
            "render.tree_environment_values",
            &[("rotation", &format!("{:.0}", rotation.to_degrees())), ("intensity", &format!("{intensity:.2}"))],
        ),
    )
}

pub(crate) fn sections(app: &mut SolveApp, ui: &mut egui::Ui) {
    setups::refresh_dirty(app);
    let (source, _detail) = environment(app);
    let open = browser::is_open(app, "render:tree:environment", true);
    let environment_label = app.tr("render.tree_environment").to_string();
    let row = browser::draw_row(
        ui,
        ui.scope_id().with("render_environment"),
        &Row {
            label: &environment_label,
            name: true,
            icon: "environment_map",
            subtitle: &source,
            fold: Some(open),
            selected: app.render_workspace.view.selection == RenderSelection::Environment,
            ..Default::default()
        },
    );
    if let Some(rect) = row.rect {
        crate::scenario::publish_target("render:tree:environment", rect);
        crate::scenario::publish_target("render:tree:environment:current", rect);
    }
    if row.fold {
        browser::toggle(app, "render:tree:environment", true);
    }
    if row.clicked {
        select(app, "environment", None);
    }
    if section(app, ui, "lights") {
        for (index, light) in super::light::rows(app).unwrap_or_default().iter().enumerate() {
            let label = super::light::name(app, light);
            let id = &light.id;
            let visible = app.render_workspace.view.lights.visibility.visible(id);
            let solo = app.render_workspace.view.lights.visibility.solo.as_deref() == Some(id);
            let solo_target = format!("render:tree:light:{index}:solo");
            let solo_label = app.tr("render.tree_solo").to_string();
            let actions = [ui_kit::TreeAction { icon: "lookat", hover_only: true, label: &solo_label, reason: None, target: &solo_target }];
            let row = browser::draw_row(
                ui,
                ui.scope_id().with(("render_light", id)),
                &Row {
                    depth: 1,
                    label: &label,
                    name: true,
                    icon: "render_scene",
                    eye: Some(visible),
                    dim: !visible,
                    actions: &actions,
                    selected: app.render_workspace.view.selection == RenderSelection::Light(id.clone()),
                    ..Default::default()
                },
            );
            if let Some(rect) = row.rect {
                crate::scenario::publish_target(&format!("render:tree:light:{index}"), rect);
            }
            if let Some(rect) = row.eye_rect.filter(|rect| rect.is_positive()) {
                crate::scenario::publish_target(&format!("render:tree:light:{index}:mute"), rect);
            }
            if row.eye {
                if !visible && app.render_workspace.view.lights.visibility.solo.is_some() {
                    let _ = app.run("render.lights.solo", json!({"solo":false}));
                }
                let _ = app.run("render.lights.mute", json!({"id":id,"mute":visible}));
            }
            if row.actions.iter().any(|response| response.clicked()) {
                let _ = app.run("render.lights.solo", json!({"id":id,"solo":!solo}));
            }
            if row.clicked {
                select(app, "light", Some(id));
            }
        }
    }
    if section(app, ui, "shots") {
        let names: Vec<_> = app.session.doc.render.setups.keys().cloned().collect();
        for name in names {
            let active = name == app.render_workspace.view.name;
            let row = browser::draw_row(
                ui,
                ui.scope_id().with(("render_shot", &name)),
                &Row {
                    depth: 1,
                    label: &name,
                    name: true,
                    icon: "camera",
                    selected: app.render_workspace.view.selection == RenderSelection::Shot(name.clone()),
                    radio: Some(active),
                    radio_hint: app.tr("render.tree_switch"),
                    modified: active && app.render_workspace.view.dirty,
                    ..Default::default()
                },
            );
            if let Some(rect) = row.rect {
                crate::scenario::publish_target(&format!("render:tree:shot:{name}"), rect);
            }
            if row.clicked || row.radio {
                select(app, "shot", Some(&name));
                super::switch_shot(app, name.clone());
            }
            if let Some(response) = row.resp {
                ui_kit::Menu::context(&response, |ui| {
                    for (command, key) in [
                        ("render.settings.apply", "render.tree_switch"),
                        ("render.shot.rename", "render.shot_rename"),
                        ("render.shot.duplicate", "render.shot_duplicate"),
                        ("render.shot.remove", "render.shot_remove"),
                    ] {
                        let item = Item::action(command, app.tr(key), "");
                        if context_menu::list_row(ui, &item).is_some() {
                            if command == "render.settings.apply" {
                                super::switch_shot(app, name.clone());
                            } else {
                                inspector::shot_row_action(app, name.clone(), command);
                            }
                            ui.close();
                        }
                    }
                });
            }
        }
    }
}

pub(crate) fn output(app: &mut SolveApp, ui: &mut egui::Ui) {
    let (size, format) = super::output_summary(app);
    let subtitle = format!("{size} · {format}");
    let row = browser::draw_row(
        ui,
        ui.scope_id().with("render_output"),
        &Row {
            label: app.tr("render.tree_output"),
            icon: "render_image",
            name: true,
            subtitle: &subtitle,
            selected: app.render_workspace.view.selection == RenderSelection::Output,
            ..Default::default()
        },
    );
    if let Some(rect) = row.rect {
        crate::scenario::publish_target("render:tree:output", rect);
    }
    if row.clicked {
        select(app, "output", None);
    }
    for (kind, key, selection) in [
        ("sampling", "render.children.sampling", RenderSelection::Sampling),
        ("effects", "render.output_effects", RenderSelection::Effects),
        ("check", "render.children.check", RenderSelection::Check),
    ] {
        let subtitle = crate::render_workspace::output_child_summary(app, kind);
        let row = browser::draw_row(
            ui,
            ui.scope_id().with(("render_output_child", kind)),
            &Row {
                depth: 1,
                label: app.tr(key),
                name: true,
                subtitle: &subtitle,
                selected: app.render_workspace.view.selection == selection,
                ..Default::default()
            },
        );
        if let Some(rect) = row.rect {
            crate::scenario::publish_target(&format!("render:tree:output:{kind}"), rect);
        }
        if row.clicked {
            select(app, kind, None);
        }
    }
}

#[derive(Debug)]
pub(crate) struct LookGroup {
    pub look: Option<Look>,
    pub objects: Vec<String>,
}

pub(crate) fn groups(app: &SolveApp) -> Vec<LookGroup> {
    let mut groups: Vec<LookGroup> = Vec::new();
    for body in &crate::open_meshing::session_world(&app.session).bodies {
        for look in app.session.doc.model_used_looks(body) {
            if let Some(group) = groups.iter_mut().find(|g| g.look == look) {
                group.objects.push(body.name.clone());
            } else {
                groups.push(LookGroup { look, objects: vec![body.name.clone()] });
            }
        }
    }
    groups.sort_by_key(|g| look_name(app, g.look.as_ref()));
    groups
}

pub(crate) fn wear_subtitle(app: &SolveApp) -> String {
    let count = app.render_workspace.view.studio.aging.len();
    if count == 0 {
        app.tr("render.wear_no_layers").into()
    } else {
        crate::i18n::format(if count == 1 { "render.wear_layer_one" } else { "render.wear_layer_count" }, &[("count", &count.to_string())])
    }
}

fn wear(app: &mut SolveApp, ui: &mut egui::Ui) {
    let subtitle = wear_subtitle(app);
    let row = browser::draw_row(
        ui,
        ui.scope_id().with("render_wear"),
        &Row {
            depth: 1,
            label: app.tr("render.wear_title"),
            name: true,
            icon: "appearance",
            subtitle: &subtitle,
            selected: app.render_workspace.view.selection == RenderSelection::Wear,
            ..Default::default()
        },
    );
    if let Some(rect) = row.rect {
        crate::scenario::publish_target("render:tree:wear", rect);
    }
    if row.clicked {
        select(app, "wear", None);
    }
}

/// Returns true when the object section is closed or the By look lens drew its objects.
pub(crate) fn objects(app: &mut SolveApp, ui: &mut egui::Ui, hover_bodies: &mut Vec<String>, hovered: &mut bool) -> bool {
    if app.tree.reveal.is_some() {
        app.tree.collapsed.remove("render:tree:objects");
    }
    if !section(app, ui, "objects") {
        return true;
    }
    wear(app, ui);
    if !app.render_workspace.view.by_look {
        return false;
    }
    for (index, group) in groups(app).into_iter().enumerate() {
        let key = format!("render:look:{:?}", group.look);
        if app.tree.reveal.as_ref().is_some_and(|b| group.objects.contains(b)) {
            app.tree.collapsed.remove(&key);
        }
        let open = browser::is_open(app, &key, true);
        let label = look_name(app, group.look.as_ref());
        let count = crate::i18n::format(
            if group.objects.len() == 1 { "render.tree_user_one" } else { "render.tree_users" },
            &[("count", &group.objects.len().to_string())],
        );
        let row = browser::draw_row(
            ui,
            ui.scope_id().with(("render_look", &key)),
            &Row {
                depth: 1,
                label: &label,
                name: true,
                fold: Some(open),
                count: &count,
                swatch: Some(
                    group.look.as_ref().map_or(Tokens::get().body, |l| crate::theme::srgb(l.color.map(|channel| f32::from(channel) / 255.0))),
                ),
                ..Default::default()
            },
        );
        if let Some(rect) = row.rect {
            crate::scenario::publish_target(&format!("render:tree:look:{index}"), rect);
        }
        if row.fold {
            browser::toggle(app, &key, true);
        }
        let source = group.objects.first().and_then(|name| {
            let state = crate::open_meshing::session_world(&app.session);
            let body = state.body(name)?;
            let face = if app.session.doc.model_display_look(body) == group.look {
                None
            } else {
                app.session.doc.face_colors(body).into_iter().find(|(_, look)| Some(look) == group.look.as_ref()).map(|(index, _)| index)
            };
            Some(json!({"body":name,"face":face}))
        });
        if row.clicked
            && let Some(params) = &source
        {
            let _ = app.run("select.same_look", params.clone());
        }
        if let Some(response) = row.resp {
            ui_kit::Menu::context(&response, |ui| {
                let item = context_menu::cmd(app, "select.same_look", "Select Same Look");
                if context_menu::list_row(ui, &item).is_some()
                    && let Some(params) = &source
                {
                    let _ = app.run("select.same_look", params.clone());
                    ui.close();
                }
            });
        }
        if open {
            for name in group.objects {
                let decoration = decoration(app, std::slice::from_ref(&name));
                if !matches_query(app, &name, &decoration.name) {
                    continue;
                }
                let visible = !app.session.visibility.hidden_bodies.contains(&name);
                let selected = app.session.selection.iter().any(|s| match s {
                    Sel::Occurrence { path } => app.session.occurrence_bodies(path, true).is_ok_and(|bodies| bodies.contains(&name)),
                    _ => browser::picked_body(s) == Some(&name),
                });
                let row = browser::draw_row(
                    ui,
                    ui.scope_id().with((&key, &name)),
                    &Row {
                        depth: 2,
                        label: &name,
                        name: true,
                        eye: Some(visible),
                        selected,
                        dim: !app.session.body_visible(&name),
                        swatch: decoration.swatch,
                        secondary: &decoration.name,
                        count: &decoration.count,
                        ..Default::default()
                    },
                );
                if row.clicked {
                    let _ = app.run(
                        "select.set",
                        json!({"items":[Sel::Body {name:name.clone()}],"add":ui.input(|i|i.modifiers.command || i.modifiers.ctrl)}),
                    );
                }
                if row.eye {
                    let _ = app.run("browser.visibility", json!({"items":[name],"visible":!visible}));
                }
                if row.hovered {
                    *hover_bodies = vec![name.clone()];
                    *hovered = true;
                }
                if app.tree.reveal.as_ref() == Some(&name)
                    && let Some(rect) = row.rect
                {
                    ui.scroll_to_rect(rect, Some(egui::Align::Center));
                }
                if let Some(at) = row.secondary {
                    context_menu::open_for(app, at, context_menu::Target::Body { name });
                }
            }
        }
    }
    true
}

pub(crate) fn matches_query(app: &SolveApp, name: &str, look: &str) -> bool {
    let query = app.render_workspace.view.object_query.trim().to_lowercase();
    !app.render_workspace.view.search_objects || query.is_empty() || name.to_lowercase().contains(&query) || look.to_lowercase().contains(&query)
}