Skip to content

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

12.7 KB
Raw Blame
//! Thin file/provenance controls. Native codecs run once on a scratch-session worker;
//! only a complete, still-current command transaction reaches the displayed design.
use super::*;

#[derive(Clone, Debug)]
pub(super) struct View {
    pub(super) path: String,
    pub(super) author: String,
    pub(super) source: String,
    pub(super) license: String,
    pub(super) repeat_mm: [f64; 2],
    pub(super) reveal: bool,
    pub(super) pending: Option<Pending>,
}
impl Default for View {
    fn default() -> Self {
        Self {
            path: String::new(),
            author: String::new(),
            source: String::new(),
            license: String::new(),
            repeat_mm: [100.0; 2],
            reveal: false,
            pending: None,
        }
    }
}

type Imported = Result<solidcraft_engine::ComputedCommands, String>;
#[derive(Clone)]
pub(super) struct Pending {
    pub(super) result: Arc<std::sync::Mutex<std::sync::mpsc::Receiver<Imported>>>,
    pub(super) document: Weak<Document>,
    pub(super) revision: u64,
    pub(super) shot: String,
    pub(super) method: ImageMethod,
    pub(super) snapshot: Value,
}
impl std::fmt::Debug for Pending {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("PendingSurfaceImport").field("revision", &self.revision).field("shot", &self.shot).finish_non_exhaustive()
    }
}

#[cfg(not(target_arch = "wasm32"))]
static WORKER_ACTIVE: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
#[cfg(not(target_arch = "wasm32"))]
struct WorkerPermit;
#[cfg(not(target_arch = "wasm32"))]
impl Drop for WorkerPermit {
    fn drop(&mut self) {
        WORKER_ACTIVE.store(false, std::sync::atomic::Ordering::Release);
    }
}

pub(super) fn pick(app: &mut SolveApp, previous: String) {
    let document = Arc::downgrade(&app.session.doc);
    let revision = app.session.revision;
    let shot = app.render_workspace.view.name.clone();
    let method = app.render_workspace.view.method;
    let extensions: &[&str] = if method == ImageMethod::CpuRaytrace { &["png"] } else { &["png", "jpg", "jpeg"] };
    app.pick_open_for(extensions, move |app, path| {
        if app.session.revision != revision
            || !Weak::ptr_eq(&document, &Arc::downgrade(&app.session.doc))
            || app.render_workspace.view.name != shot
            || app.render_workspace.view.method != method
            || app.render_workspace.view.library.imported.path != previous
        {
            return;
        }
        if let Some(path) = path {
            app.render_workspace.view.library.imported.path = path;
        }
    });
}

pub(super) fn request(app: &mut SolveApp, view: &super::View) -> Result<Value, String> {
    if app.render_workspace.view.method == ImageMethod::Raster {
        return Err(app.tr("render.surface_import.raytrace_required").into());
    }
    if !current_target(app, view) {
        return Err(app.tr("render.material_revalidate_needed").into());
    }
    let input = &view.imported;
    if input.path.trim().is_empty() || [&input.author, &input.source, &input.license].into_iter().any(|text| text.trim().is_empty()) {
        return Err(app.tr("render.surface_import.complete").into());
    }
    let target = view.target.as_ref().ok_or_else(|| app.tr("render.material_choose_body").to_string())?;
    let scene = app.run("render.scene", json!({}))?;
    let body = scene["bodies"]
        .get(target.ordinal)
        .filter(|body| body["name"].as_str() == Some(target.name.as_str()))
        .ok_or_else(|| app.tr("render.material_revalidate_needed").to_string())?;
    let min: Vec3 = serde_json::from_value(body["bounds"]["min"].clone()).map_err(|e| e.to_string())?;
    let max: Vec3 = serde_json::from_value(body["bounds"]["max"].clone()).map_err(|e| e.to_string())?;
    let center = (min + max) * 0.5;
    let [width, height] = input.repeat_mm;
    let (sin, cos) = view.mapping_angle_deg.to_radians().sin_cos();
    let (u, v) = match view.mapping_plane {
        1 => ([0.0, cos * width, sin * width], [0.0, -sin * height, cos * height]),
        2 => ([sin * width, 0.0, cos * width], [cos * height, 0.0, -sin * height]),
        _ => ([cos * width, sin * width, 0.0], [-sin * height, cos * height, 0.0]),
    };
    let frame = solidcraft_engine::render::job::textures::PlanarFrame { origin: [center.x, center.y, center.z], u, v };
    frame.validate().map_err(|e| e.to_string())?;
    Ok(json!({"name":app.render_workspace.view.name,"set":patch(app)?,"body_index":target.ordinal,"body_name":target.name,
        "frame":frame,"maps":{"base_color_srgb":{"path":input.path}},
        "provenance":{"author":input.author,"source":input.source,"license":input.license},
        "normal_strength":1.0,"flip_v":false,"replace":true}))
}

fn finish(app: &mut SolveApp, imported: Imported) -> Result<(), String> {
    if app.file_load.busy() || app.file_picker_busy() {
        return Err("a file operation is in progress".into());
    }
    let replies = app.session.accept_commands(imported?).map_err(|e| e.to_string())?;
    for (id, reply) in replies {
        super::super::apply_command(app, &id, &reply)?;
        app.command_completed(&id, Ok(reply))?;
    }
    setups::load(app);
    Ok(())
}

fn begin(app: &mut SolveApp, view: &mut super::View, ctx: &egui::Context) -> Result<(), String> {
    let params = request(app, view)?;
    let session = app.session.scratch();
    let commands = vec![("render.surface.import".into(), params)];
    #[cfg(not(target_arch = "wasm32"))]
    {
        if WORKER_ACTIVE.compare_exchange(false, true, std::sync::atomic::Ordering::AcqRel, std::sync::atomic::Ordering::Acquire).is_err() {
            return Err(app.tr("render.surface_import.busy").into());
        }
        let permit = WorkerPermit;
        let (sender, receiver) = std::sync::mpsc::channel();
        let pending = Pending {
            result: Arc::new(std::sync::Mutex::new(receiver)),
            document: Arc::downgrade(&app.session.doc),
            revision: app.session.revision,
            shot: app.render_workspace.view.name.clone(),
            method: app.render_workspace.view.method,
            snapshot: patch(app)?,
        };
        let repaint = ctx.clone();
        std::thread::Builder::new()
            .name("surface import".into())
            .spawn(move || {
                let _permit = permit;
                let result = session.compute_commands(&commands, None).map_err(|e| e.to_string());
                let _ = sender.send(result);
                repaint.request_repaint();
            })
            .map_err(|e| e.to_string())?;
        view.imported.pending = Some(pending);
        ctx.request_repaint();
        Ok(())
    }
    #[cfg(target_arch = "wasm32")]
    {
        // The browser host has no Rust worker threads. Codec validation is bounded
        // by the same 1024-square resource admission; the async picker uses its VFS.
        let _ = ctx;
        finish(app, session.compute_commands(&commands, None).map_err(|e| e.to_string()))
    }
}

pub(super) fn poll(app: &mut SolveApp, ctx: &egui::Context) {
    let Some(pending) = app.render_workspace.view.library.imported.pending.as_ref() else { return };
    let current = pending.revision == app.session.revision
        && Weak::ptr_eq(&pending.document, &Arc::downgrade(&app.session.doc))
        && pending.shot == app.render_workspace.view.name
        && pending.method == app.render_workspace.view.method
        && patch(app).ok().as_ref() == Some(&pending.snapshot);
    if !current {
        app.render_workspace.view.library.imported.pending = None;
        return;
    }
    let result = match pending.result.lock() {
        Ok(receiver) => match receiver.try_recv() {
            Ok(result) => Some(result),
            Err(std::sync::mpsc::TryRecvError::Empty) => None,
            Err(std::sync::mpsc::TryRecvError::Disconnected) => Some(Err(app.tr("render.surface_import.failed").into())),
        },
        Err(_) => Some(Err(app.tr("render.surface_import.failed").into())),
    };
    let Some(result) = result else {
        ctx.request_repaint_after(std::time::Duration::from_millis(50));
        return;
    };
    app.render_workspace.view.library.imported.pending = None;
    if let Err(error) = finish(app, result) {
        app.set_status(error, true);
    }
}

pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui, view: &mut super::View) {
    let title = app.tr("render.surface_import.title").to_string();
    if std::mem::take(&mut view.imported.reveal) {
        let section = ui.make_persistent_id("surface_import");
        ui.ctx().data_mut(|data| data.insert_persisted(section, true));
        ui.scroll_to_cursor(Some(egui::Align::Min));
    }
    ui_kit::section(ui, "surface_import", &title, false, |ui| {
        if view.imported.pending.is_some() {
            ui_kit::text(ui, app.tr("render.surface_import.busy"), ui_kit::Text::Note("surface_import:busy"));
            if ui_kit::button(ui, app.tr("ui.cancel"), ui_kit::Button::Normal).clicked() {
                view.imported.pending = None;
            }
            return;
        }
        if !current_target(app, view) {
            let previous = view.target.clone();
            if let Err(error) = refresh_targets(app, view) {
                app.set_status(error, true);
            } else {
                view.target = previous.filter(|target| view.targets.contains(target));
            }
        }
        let picked = app.session.selection.iter().find_map(|sel| match sel {
            solidcraft_engine::Sel::Body { name } | solidcraft_engine::Sel::Face { body: name, .. } => Some(name),
            _ => None,
        });
        if view.target.is_none() {
            view.target = view.targets.iter().find(|target| picked.is_some_and(|name| target.name == *name)).cloned();
        }
        ui_kit::row(ui, app.tr("render.stage_panels.target"), |ui| {
            let name = view.target.as_ref().map_or(app.tr("render.material_choose_body"), |target| target.name.as_str()).to_string();
            ui_kit::dropdown_menu(ui, "surface_import_target", &name, |ui| {
                for target in &view.targets {
                    if ui_kit::list_picker(ui, &target.name, &target.name, view.target.as_ref() == Some(target)).clicked() {
                        view.target = Some(target.clone());
                        ui.close();
                    }
                }
            });
        });
        let label = if view.imported.path.is_empty() {
            app.tr("render.appearance_editor.choose_image").to_string()
        } else {
            std::path::Path::new(&view.imported.path).file_name().map(|name| name.to_string_lossy().into_owned()).unwrap_or_default()
        };
        let choose = ui_kit::button(ui, &label, ui_kit::Button::Normal);
        crate::scenario::publish_target("render:surface-import:choose", choose.rect);
        if choose.clicked() {
            pick(app, view.imported.path.clone());
        }
        for (key, value, maximum) in [
            ("render.surface_import.author", &mut view.imported.author, 512),
            ("render.surface_import.source", &mut view.imported.source, 2048),
            ("render.surface_import.license", &mut view.imported.license, 4096),
        ] {
            ui_kit::row(ui, app.tr(key), |ui| {
                ui_kit::bounded_cell_editor(ui, ui.scope_id().with(key), value, "", false, maximum);
            });
        }
        ui_kit::row(ui, app.tr("render.stage_panels.plane"), |ui| {
            ui_kit::segmented(ui, &mut view.mapping_plane, &["xy", "yz", "zx"], ui_kit::Segments { compact: true, ..Default::default() });
        });
        for (key, value) in ["render.surface_import.repeat_u", "render.surface_import.repeat_v"].into_iter().zip(&mut view.imported.repeat_mm) {
            ui_kit::row(ui, app.tr(key), |ui| {
                ui_kit::number_field(ui, value, 0.001..=1e6, 1.0, " mm");
            });
        }
        ui_kit::row(ui, app.tr("render.stage_panels.grain_angle"), |ui| {
            ui_kit::number_field(ui, &mut view.mapping_angle_deg, -180.0..=180.0, 1.0, "°");
        });
        let raytrace = app.render_workspace.view.method != ImageMethod::Raster;
        let ready = raytrace
            && current_target(app, view)
            && !view.imported.path.is_empty()
            && [&view.imported.author, &view.imported.source, &view.imported.license].into_iter().all(|text| !text.trim().is_empty());
        let save = ui_kit::button(ui, app.tr("render.surface_import.save"), ui_kit::Button::Enabled(ready));
        crate::scenario::publish_target("render:surface-import:save", save.rect);
        if save.clicked()
            && let Err(error) = begin(app, view, ui.ctx())
        {
            app.set_status(error, true);
        }
        if !raytrace {
            ui_kit::text(ui, app.tr("render.surface_import.raytrace_required"), ui_kit::Text::Note("surface_import:raytrace"));
        }
    });
}