SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! HDR selection is local until the engine captures its verified bytes into the design.
use serde::Deserialize;
use serde_json::{Value, json};
use solidcraft_engine::doc::render_resources::HdrId;
use super::{ImageMethod, cpu, studio};
use crate::{SolveApp, ui_kit};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Target {
Cpu,
Gpu,
}
#[derive(Clone, Copy, Debug, PartialEq, Deserialize)]
pub(super) struct Metadata {
pub sha256: HdrId,
pub width: u32,
pub height: u32,
pub encoded_bytes: u64,
pub primaries: Option<[f64; 8]>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub(super) enum Input {
#[default]
Empty,
FilePending {
path: String,
},
FileCaptured {
path: String,
metadata: Metadata,
},
EmbeddedResource {
resource: HdrId,
},
}
impl Input {
pub fn resource(&self) -> Option<HdrId> {
match self {
Self::FileCaptured { metadata, .. } => Some(metadata.sha256),
Self::EmbeddedResource { resource } => Some(*resource),
Self::Empty | Self::FilePending { .. } => None,
}
}
pub fn embedded(&self) -> bool {
matches!(self, Self::EmbeddedResource { .. })
}
fn path(&self) -> &str {
match self {
Self::FilePending { path } | Self::FileCaptured { path, .. } => path,
Self::Empty | Self::EmbeddedResource { .. } => "",
}
}
}
pub(super) fn input(app: &SolveApp, target: Target) -> &Input {
match target {
Target::Cpu => &app.render_workspace.view.cpu.hdr,
Target::Gpu => &app.render_workspace.view.studio.hdr,
}
}
fn set_input(app: &mut SolveApp, target: Target, input: Input) {
match target {
Target::Cpu => {
app.render_workspace.view.cpu.hdr = input;
app.render_workspace.view.cpu.checked = None;
}
Target::Gpu => app.render_workspace.view.studio.hdr = input,
}
app.render_workspace.view.dirty = true;
}
pub(super) fn active(app: &SolveApp) -> Option<Target> {
let view = &app.render_workspace.view;
match view.method {
ImageMethod::CpuRaytrace if view.cpu.environment == cpu::Environment::Hdr => Some(Target::Cpu),
ImageMethod::GpuRaytrace if view.studio.environment == studio::Environment::Hdr => Some(Target::Gpu),
_ => None,
}
}
fn valid_path(path: &str) -> bool {
!path.trim().is_empty() && path.len() <= 4096 && !path.chars().any(char::is_control)
}
/// No host is consulted and no document mutation occurs. A failed inspection keeps the input.
pub(super) fn inspect(app: &mut SolveApp, target: Target, path: String) -> Result<(), String> {
if !valid_path(&path) {
return Err(app.tr("render.studio_hdr_required").to_string());
}
let reply = app.run("render.hdr.inspect", json!({"path":path}))?;
let metadata: Metadata = serde_json::from_value(reply).map_err(|error| error.to_string())?;
set_input(app, target, Input::FileCaptured { path, metadata });
Ok(())
}
/// The picker belongs to this document revision, setup, method and input selection.
/// Cancelling or answering after any of those changed cannot replace a newer selection.
pub(super) fn pick(app: &mut SolveApp, target: Target) {
let document = std::sync::Arc::downgrade(&app.session.doc);
let revision = app.session.revision;
let method = app.render_workspace.view.method;
let name = app.render_workspace.view.name.clone();
let before = input(app, target).clone();
let selected = active(app);
app.pick_open_for(&["hdr"], move |app, path| {
let Some(path) = path else { return };
if app.session.revision != revision
|| !std::sync::Weak::ptr_eq(&document, &std::sync::Arc::downgrade(&app.session.doc))
|| app.render_workspace.view.method != method
|| app.render_workspace.view.name != name
|| active(app) != selected
|| input(app, target) != &before
{
return;
}
if let Err(error) = inspect(app, target, path) {
app.set_status(error, true);
} else if app.render_workspace.view.selection == super::RenderSelection::Environment {
super::environment::persist(app);
}
});
}
/// Runtime requests use the same expected digest in Check and Start. Embedded resources
/// remain usable with temporary body bindings without ever reconstructing an external path.
pub(super) fn request(app: &SolveApp, target: Target) -> Result<Value, String> {
match input(app, target) {
Input::FileCaptured { path, metadata } if valid_path(path) => {
let mut value = json!({"path":path,"expected_sha256":metadata.sha256});
if target == Target::Gpu {
value["kind"] = json!("hdr");
}
Ok(value)
}
Input::EmbeddedResource { resource } => {
if app.session.doc.render.resources.get(resource).is_none() {
return Err(app.tr("render.hdr_resource_missing").to_string());
}
let mut value = json!({"resource":resource});
if target == Target::Gpu {
value["kind"] = json!("embedded_hdr");
}
Ok(value)
}
Input::Empty | Input::FilePending { .. } | Input::FileCaptured { .. } => Err(app.tr("render.hdr_inspect_required").to_string()),
}
}
pub(super) fn metadata(app: &SolveApp, target: Target) -> Option<Metadata> {
match input(app, target) {
Input::FileCaptured { metadata, .. } => Some(*metadata),
Input::EmbeddedResource { resource } => {
let entry = app.session.doc.render.resources.get(resource)?;
let info = entry.info();
Some(Metadata { sha256: *resource, width: info.width, height: info.height, encoded_bytes: info.encoded_bytes, primaries: info.primaries })
}
Input::Empty | Input::FilePending { .. } => None,
}
}
pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui, target: Target) {
if input(app, target).embedded() {
ui_kit::text(ui, app.tr("render.hdr_embedded_help"), ui_kit::Text::Note("render.hdr_embedded_help"));
if ui_kit::button(ui, app.tr("render.environment.choose"), ui_kit::Button::Normal).clicked() {
pick(app, target);
}
} else {
let mut path = input(app, target).path().to_string();
let hint = app.tr("render.studio_hdr_required").to_string();
let field = ui_kit::row(ui, app.tr("render.environment.file"), |ui| {
ui_kit::bounded_cell_editor(ui, ui.scope_id().with("hdr_source_path"), &mut path, &hint, false, 4096)
});
if field.changed() {
set_input(app, target, Input::FilePending { path });
}
ui.horizontal(|ui| {
if ui_kit::button(ui, app.tr("render.environment.choose"), ui_kit::Button::Normal).clicked() {
pick(app, target);
}
if ui
.add_enabled_ui(valid_path(input(app, target).path()), |ui| {
ui_kit::button(ui, app.tr("render.environment.check"), ui_kit::Button::Primary)
})
.inner
.clicked()
{
let path = input(app, target).path().to_string();
if let Err(error) = inspect(app, target, path) {
app.set_status(error, true);
}
}
});
if matches!(input(app, target), Input::FileCaptured { .. }) {
ui_kit::banner(ui, ui_kit::AssistantTone::Working, |ui| {
ui_kit::text(ui, app.tr("render.environment.checked"), ui_kit::Text::Note("render.environment.checked"));
});
} else {
ui_kit::text(ui, app.tr("render.hdr_inspect_required"), ui_kit::Text::Note("render.hdr_inspect_required"));
}
}
if let Some(metadata) = metadata(app, target) {
ui_kit::text(
ui,
&format!("{} × {} px · {:.2} MiB", metadata.width, metadata.height, metadata.encoded_bytes as f64 / 1_048_576.0),
ui_kit::Text::Inline,
);
let primaries = if metadata.primaries == Some(solidcraft_engine::doc::render_resources::SRGB_D65_PRIMARIES) {
"render.hdr_primaries_srgb"
} else if metadata.primaries.is_some() {
"render.hdr_primaries_declared"
} else {
"render.hdr_primaries_undeclared"
};
ui_kit::text(ui, app.tr(primaries), ui_kit::Text::Note(primaries));
let title = app.tr("render.hdr_details").to_string();
ui_kit::section(ui, "hdr_source_details", &title, false, |ui| {
ui_kit::text(ui, &format!("SHA-256: {}", metadata.sha256), ui_kit::Text::Inline);
if let Some([rx, ry, gx, gy, bx, by, wx, wy]) = metadata.primaries {
ui_kit::text(ui, &format!("CIE xy · R ({rx:.6}, {ry:.6}) · G ({gx:.6}, {gy:.6})"), ui_kit::Text::Inline);
ui_kit::text(ui, &format!("CIE xy · B ({bx:.6}, {by:.6}) · W ({wx:.6}, {wy:.6})"), ui_kit::Text::Inline);
}
});
}
}