Skip to content

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

9.1 KB
Raw Blame
//! One floating editor for the selected Render item.
use super::{RenderSelection, environment, inspector, library, light, setups, shot, wear};
use crate::ui_kit::BackingTooltipExt as _;
use crate::{SolveApp, ui_kit};
use inspector::selection_appearance;
use serde_json::json;

pub(crate) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) {
    // Reviews belong to the workspace, including when their originating editor closes.
    inspector::confirmation(app, ui.ctx());
    library::review::dialog(app, ui.ctx());
    library::review::confirmation(app, ui.ctx());
    if app.render_workspace.view.inspector.hidden || app.render_workspace.view.selection != RenderSelection::Environment {
        environment::stage_confirmation(app, ui.ctx());
    }
    if app.render_workspace.view.inspector.hidden {
        crate::shell::register_panel(app, "render:inspector", None, None);
        return;
    }
    setups::refresh_dirty(app);
    setups::sync_revision(app);
    let selection = app.render_workspace.view.selection.clone();
    let kind = kind(&selection);
    let appearance = matches!(selection, RenderSelection::Object(_));
    let (title, icon) = title(app, &selection);
    let scope = selection_appearance::scope_label(app).to_owned();
    let bounds = crate::shell::panel_bounds(app, ui.available_rect_before_wrap());
    let mut side = app.preferences.render_inspector_side.clone();
    let mut width = app.preferences.render_inspector_width;
    let action = std::cell::Cell::new(None);
    let content = ui_kit::Panel::workspace_with_header(
        ui,
        ui_kit::WorkspaceOptions {
            id: "render:inspector",
            title: &title,
            icon,
            bounds,
            fill_height: true,
            compact: crate::render_ui::compact(app, bounds.width()),
            editor: appearance,
            enabled: true,
            header_actions: None,
        },
        &mut side,
        &mut width,
        false,
        |ui, options| {
            if appearance {
                action.set(ui_kit::inspector_header(ui, options.icon, options.title, &scope));
            } else {
                ui_kit::panel::header(ui, options.icon, options.title, || action.set(Some(ui_kit::InspectorAction::Close)));
            }
        },
        |ui| {
            if appearance {
                ui_kit::Panel::editor_footer(ui, "render_appearance_footer", |ui| selection_appearance::footer(app, ui));
            } else if selection == RenderSelection::Output {
                ui_kit::Panel::pinned_footer(ui, "render_output_footer", 1, |ui| {
                    output_actions(app, ui);
                    crate::scenario::publish_rect("render:output-footer", ui.min_rect());
                });
            }
            egui::ScrollArea::vertical()
                .max_width(ui.available_width())
                .id_salt(("render_inspector", kind, app.docs.active))
                .auto_shrink([false, false])
                .show(ui, |ui| {
                    let before = setups::draft(app).ok();
                    let rollback = app.render_workspace.view.clone();
                    let response = ui.scope(|ui| match &selection {
                        RenderSelection::Nothing => inspector::scene_controls(app, ui),
                        RenderSelection::Object(_) => {
                            selection_appearance::controls(app, ui);
                        }
                        RenderSelection::Wear => wear::controls(app, ui),
                        RenderSelection::Environment => environment::editor(app, ui),
                        RenderSelection::Lighting => light::lighting(app, ui),
                        RenderSelection::Light(id) => light::editor(app, ui, id),
                        RenderSelection::Shot(name) => shot::editor(app, ui, name),
                        RenderSelection::Output => inspector::output_editor(app, ui),
                        RenderSelection::Sampling => inspector::sampling_editor(app, ui),
                        RenderSelection::Effects => super::effects::output_controls(app, ui),
                        RenderSelection::Check => inspector::check_editor(app, ui),
                    });
                    if matches!(selection, RenderSelection::Output | RenderSelection::Sampling | RenderSelection::Effects | RenderSelection::Wear)
                        && let Some(before) = before
                        && let Err(error) = setups::persist_editor(app, &before)
                    {
                        // Refuse the numerical edit without undoing transient editor navigation.
                        let inspector = std::mem::take(&mut app.render_workspace.view.inspector);
                        app.render_workspace.view = rollback;
                        app.render_workspace.view.inspector = inspector;
                        app.set_status(error, true);
                    }
                    crate::scenario::publish_rect(&format!("render:editor:{kind}"), response.response.rect);
                });
        },
    );
    match action.get() {
        Some(ui_kit::InspectorAction::Close) => {
            let _ = app.run("view.render_inspector", json!({"visible":false}));
        }
        Some(ui_kit::InspectorAction::Remove) => selection_appearance::remove(app),
        None => {}
    }
    app.preferences.render_inspector_width = width;
    let requested = content
        .as_ref()
        .and_then(|c| c.inner.1)
        .map(str::to_string)
        .or_else(|| (app.preferences.render_inspector_side != side).then(|| side.clone()));
    if let Some(side) = requested {
        let _ = app.run("view.render_dock", json!({"panel":"inspector","side":side}));
    }
    let rect = content.map(|content| content.response.rect);
    crate::shell::register_panel(app, "render:inspector", rect, Some(if side == "left" { ui_kit::Edge::Left } else { ui_kit::Edge::Right }));
    if let Some(rect) = rect {
        crate::scenario::publish_rect("render:inspector", rect);
    }
}

pub(super) fn output_actions(app: &mut SolveApp, ui: &mut egui::Ui) {
    ui.horizontal_wrapped(|ui| {
        for (id, label, target) in [
            ("render.start", app.tr("cmd.render_start").to_owned(), "render:output:render"),
            (
                "render.batch",
                crate::i18n::format("render.batch_all_shots", &[("count", &app.session.doc.render.setups.len().to_string())]),
                "render:output:all-shots",
            ),
        ] {
            let ready = super::ribbon::action_ready(app, id);
            let response = ui_kit::icon_label_action(ui, &label, Some("play"), ready.is_ok(), id == "render.start");
            let response = if let Err(reason) = ready { response.backing_on_disabled_hover_text(reason) } else { response };
            crate::scenario::publish_target(target, response.rect);
            if response.clicked() {
                app.start(id);
            }
        }
    });
}

fn kind(selection: &RenderSelection) -> &'static str {
    match selection {
        RenderSelection::Nothing => "scene",
        RenderSelection::Object(_) => "appearance",
        RenderSelection::Wear => "wear",
        RenderSelection::Environment => "environment",
        RenderSelection::Lighting => "lighting",
        RenderSelection::Light(_) => "light",
        RenderSelection::Shot(_) => "shot",
        RenderSelection::Output => "output",
        RenderSelection::Sampling => "sampling",
        RenderSelection::Effects => "effects",
        RenderSelection::Check => "check",
    }
}

fn title(app: &SolveApp, selection: &RenderSelection) -> (String, &'static str) {
    let (key, icon) = match selection {
        RenderSelection::Nothing => ("render.page_scene", "render_scene"),
        RenderSelection::Object(items) => {
            let name = items
                .last()
                .and_then(|item| match item {
                    solidcraft_engine::Sel::Body { name } | solidcraft_engine::Sel::Face { body: name, .. } => Some(name.clone()),
                    solidcraft_engine::Sel::Occurrence { path } => app.session.occurrence_placement(path).ok().map(|p| p.name),
                    _ => None,
                })
                .unwrap_or_else(|| app.tr("render.page_appearance").to_owned());
            return (name, "body");
        }
        RenderSelection::Shot(name) => return (name.clone(), "camera"),
        RenderSelection::Light(id) => {
            let name = light::rows(app)
                .ok()
                .and_then(|rows| rows.into_iter().find(|row| &row.id == id))
                .map(|row| light::name(app, &row))
                .unwrap_or_else(|| app.tr("render.tree_lights").to_owned());
            return (name, "render_scene");
        }
        RenderSelection::Wear => ("render.wear_title", "appearance"),
        RenderSelection::Environment => ("render.page_environment", "environment_map"),
        RenderSelection::Lighting => ("render.page_lighting", "render_scene"),
        RenderSelection::Output => ("render.page_output", "export"),
        RenderSelection::Sampling => ("render.children.sampling", "settings"),
        RenderSelection::Effects => ("render.page_effects", "camera"),
        RenderSelection::Check => ("render.children.check", "inspect"),
    };
    (app.tr(key).to_owned(), icon)
}