Skip to content

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

7.6 KB
Raw Blame
//! Shot strip adapters. Commands own saved intent; the kit owns every control and layout.
use crate::ui_kit::BackingTooltipExt as _;
use crate::{SolveApp, ui_kit};
use serde_json::json;
use solidcraft_engine::{doc::render_settings::RenderSettings, render::job::Phase};

pub(super) const SIZE_PRESETS: [(&str, u32, u32); 3] = [("HD", 1280, 720), ("Full HD", 1920, 1080), ("4K UHD", 3840, 2160)];

pub(super) fn camera_modified(app: &SolveApp, name: &str) -> bool {
    app.session.doc.render.setups.get(name).is_some_and(|setup| setup.camera != app.cam)
}

pub(crate) fn contents(app: &mut SolveApp, ui: &mut egui::Ui) {
    super::thumbnails::refresh(app, ui.ctx());
    let status = app.render_workspace.view.job.and_then(|job| app.session.render_job_handle(job).ok()).and_then(|handle| handle.status().ok());
    let progress = status
        .as_ref()
        .filter(|s| matches!(s.progress.phase, Phase::Queued | Phase::Preparing | Phase::Running | Phase::Encoding | Phase::Cancelling))
        .map(|s| (s.progress.done as f64 / s.progress.total.max(1) as f64).clamp(0.0, 1.0) as f32);
    if progress.is_some() {
        ui.ctx().request_repaint_after(std::time::Duration::from_millis(100));
    }
    let ready = super::job_ready(app, "render.start");
    let draft = &app.render_workspace.view.draft;
    let size_label = format!("{} × {}", draft.width, draft.height);
    let completed = app
        .render_workspace
        .view
        .completed
        .and_then(|job| app.session.render_job_handle(job).ok())
        .and_then(|handle| handle.frame().ok().flatten())
        .map(|frame| frame.info.clone());
    let result_label = completed
        .as_ref()
        .map(|frame| {
            crate::i18n::format(
                "render.shots_result",
                &[("number", &frame.job.serial.to_string()), ("width", &frame.width.to_string()), ("height", &frame.height.to_string())],
            )
        })
        .unwrap_or_else(|| app.tr("render.shots_no_result").to_string());
    let queue = app.session.render_queue_state();
    let queue_label = crate::i18n::format("render.batch_status", &[("running", &queue.running.to_string()), ("waiting", &queue.waiting.to_string())]);
    let (mut hide, mut start, mut save, mut chosen, mut size) = (false, false, false, None, None);
    let mut visible = Vec::new();
    ui_kit::Panel::strip_contents(
        ui,
        |ui| {
            let response = ui_kit::strip_toggle(ui, true, crate::i18n::tr_label("Hide Shots strip"));
            crate::scenario::publish_target("render:shots:hide", response.rect);
            hide = response.clicked();
            let response = ui_kit::completion_text(ui, &queue_label, false);
            crate::scenario::publish_rect("render:shots:queue", response.rect);
            let response = ui_kit::icon_label_action(ui, app.tr("cmd.render_start"), Some("play"), ready.is_ok(), true);
            let response = if let Err(reason) = &ready { response.backing_on_disabled_hover_text(reason) } else { response };
            crate::scenario::publish_target("render:shots:render", response.rect);
            start = response.clicked();
            let response = ui_kit::compact_dropdown_menu(ui, "render_shots_size", &size_label, |ui| {
                for (label, width, height) in SIZE_PRESETS {
                    let text = format!("{label} · {width} × {height}");
                    let mark = super::inspector::size_mark(app, &text, Some((u64::from(width), u64::from(height))));
                    let mut response =
                        ui_kit::list_picker(ui, label, mark.as_deref().unwrap_or(&text), draft.width == width && draft.height == height);
                    if mark.is_some() {
                        response = response.backing_on_hover_text(super::inspector::size_limit_reason(app, width, height));
                    }
                    if response.clicked() {
                        size = Some((width, height));
                        ui.close();
                    }
                }
            });
            crate::scenario::publish_target("render:shots:size", response.rect);
            let response = ui_kit::completion_text(ui, &result_label, completed.is_some());
            crate::scenario::publish_rect("render:shots:status", response.rect);
        },
        |ui| {
            let heading = ui_kit::StripHeading::new(ui.painter(), crate::i18n::tr_label("Shots"));
            let response = heading.show(ui);
            crate::scenario::publish_rect("render:shots:heading", response.rect);
            let response = ui.add_enabled_ui(super::setups::snapshot(app).is_ok(), |ui| ui_kit::add_choice(ui, app.tr("render.shots_save"))).inner;
            crate::scenario::publish_target("render:shots:save", response.rect);
            save = response.clicked();
            for name in app.session.doc.render.setups.keys() {
                let active = name == &app.render_workspace.view.name;
                let response = ui_kit::thumbnail_choice(
                    ui,
                    &format!("shot:{name}"),
                    name,
                    ui_kit::ThumbnailChoice {
                        texture: app.render_workspace.thumbnails.texture(name),
                        selected: active,
                        modified: active && camera_modified(app, name),
                        progress: if app.render_workspace.view.job_shot.as_ref() == Some(name) { progress } else { None },
                    },
                );
                crate::scenario::publish_target(&format!("render:shots:setup:{name}"), response.rect);
                if visible.len() < super::thumbnails::LIMIT && response.rect.intersects(ui.clip_rect()) {
                    visible.push(name.clone());
                }
                if response.clicked() {
                    chosen = Some(name.clone());
                }
            }
        },
    );
    app.render_workspace.thumbnails.show(visible, ui.ctx());
    if hide {
        let _ = app.run("view.shots_strip", json!({"visible":false}));
    }
    if start {
        app.start("render.start");
    }
    if save {
        app.start("render.settings.set");
    }
    if let Some(name) = chosen {
        super::switch_shot(app, name);
    }
    if let Some((width, height)) = size {
        app.render_workspace.view.draft.width = width;
        app.render_workspace.view.draft.height = height;
        app.render_workspace.view.dirty = true;
    }
}

pub(super) fn confirmation(app: &mut SolveApp, ctx: &egui::Context) {
    let Some(mut name) = app.render_workspace.view.save_shot_name.take() else { return };
    let valid = RenderSettings::validate_name(name.trim()).is_ok() && !app.session.doc.render.setups.contains_key(name.trim());
    let title = app.tr("render.shots_save").to_string();
    let cancel = app.tr("ui.cancel").to_string();
    let (closed, answer) =
        ui_kit::Confirm::new(egui::Id::unique("render_save_shot"), "save", &title).actions(&title, &cancel, None).show(ctx, valid, |ui| {
            ui_kit::text(ui, app.tr("render.shots_name_help"), ui_kit::Text::Note("render.shots_name_help"));
            ui_kit::row(ui, app.tr("render.shot_new_name"), |ui| {
                ui_kit::focused_text_field(ui, &mut name, "");
            });
        });
    if closed || answer == ui_kit::Action::Cancel {
        return;
    }
    if answer == ui_kit::Action::Ok {
        let previous = app.render_workspace.view.name.clone();
        app.render_workspace.view.name = name.trim().to_owned();
        if let Err(error) = super::setups::save(app) {
            app.render_workspace.view.name = previous;
            app.set_status(error, true);
        } else {
            return;
        }
    }
    app.render_workspace.view.save_shot_name = Some(name);
}