Skip to content

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

11.7 KB
Raw Blame
//! Stable, render-only optical assignments. Raw request overrides remain a
//! separate mode; saved optics cannot silently disappear into another target.
use crate::schema::TypedContract;
use crate::schema::render_bindings::{OpticsBindParams, OpticsBindingSaved, OpticsUnbindParams, OpticsUnbound};
use crate::{Result, Session, params::bad};
use serde_json::{Value, json};
use solidcraft_doc::{
    render_optics::{OpticalBindings, OpticalMaterial, SavedOptics},
    render_settings::RenderJob,
};
use solidcraft_render::ProductScene;
use std::{collections::BTreeMap, sync::Arc};

fn resolve_each<T>(
    s: &Session,
    scene: &ProductScene,
    bindings: &OpticalBindings,
    command: &str,
    convert: impl Fn(usize, &str, OpticalMaterial) -> Result<T>,
) -> Result<Vec<T>> {
    bindings.validate().map_err(|e| bad(command, e.to_string()))?;
    let identities = super::surface_bindings::targets(s, command)?;
    let visible: BTreeMap<_, _> = scene.meshes.iter().enumerate().map(|(i, b)| (b.name.as_str(), i)).collect();
    let mut result = Vec::new();
    result.try_reserve_exact(bindings.len()).map_err(|_| bad(command, "optical request allocation failed"))?;
    for binding in bindings.iter() {
        let name = identities.get(&binding.target).ok_or_else(|| bad(command, "saved optical target changed; explicit rebinding required"))?;
        let index = visible.get(name.as_str()).ok_or_else(|| bad(command, "saved optical target is hidden or absent"))?;
        result.push(convert(*index, name, binding.optics)?);
    }
    Ok(result)
}

pub(super) fn resolve(s: &Session, scene: &ProductScene, bindings: &OpticalBindings, command: &str) -> Result<Vec<super::transmission::Override>> {
    resolve_each(s, scene, bindings, command, |index, name, optics| {
        let mut value = serde_json::to_value(optics).map_err(|e| bad(command, e.to_string()))?;
        value["body_index"] = json!(index);
        value["body_name"] = json!(name);
        serde_json::from_value(value).map_err(|e| bad(command, e.to_string()))
    })
}

#[cfg(test)]
pub(super) fn resolve_cpu(
    s: &Session,
    scene: &ProductScene,
    bindings: &OpticalBindings,
    command: &str,
) -> Result<Vec<solidcraft_render::job::DielectricOptions>> {
    resolve_cpu_path(s, scene, bindings, false, command)
}
pub(super) fn resolve_cpu_path(
    s: &Session,
    scene: &ProductScene,
    bindings: &OpticalBindings,
    path: bool,
    command: &str,
) -> Result<Vec<solidcraft_render::job::DielectricOptions>> {
    bindings.validate_for_cpu_path(path).map_err(|e| bad(command, e.to_string()))?;
    resolve_each(s, scene, bindings, command, |index, name, optics| {
        optics.to_cpu_for_path(index, name, path).map_err(|e| bad(command, e.to_string()))
    })
}

pub(super) const BIND_CONTRACT: TypedContract<OpticsBindParams> = TypedContract::new();
pub(super) const UNBIND_CONTRACT: TypedContract<OpticsUnbindParams> = TypedContract::new();

pub(super) fn bind(s: &mut Session, params: &Value) -> Result<Value> {
    let command = "render.optics.bind";
    let input: OpticsBindParams = serde_json::from_value(params.clone()).map_err(|e| bad(command, e.to_string()))?;
    input.optics.validate().map_err(|e| bad(command, e.to_string()))?;
    if input.expected_revision != s.revision {
        return Err(bad(command, "optical binding review is stale"));
    }
    let mut setup = super::patched_settings(s, &input.name, &input.set, command)?;
    if s.doc.render.setups.get(&input.name).is_some_and(|old| old.optics != setup.optics) {
        return Err(bad(command, "setup patch cannot erase or replace saved optics; use explicit bind/unbind"));
    }
    if !matches!(setup.job, Some(RenderJob::CpuRaytrace { .. } | RenderJob::GpuPath { .. })) {
        return Err(bad(command, "portable optics require an explicit CPU or GPU raytrace setup"));
    }
    let mut scene = crate::product_scene::extract(s)?;
    let name = &scene
        .meshes
        .get(input.body_index)
        .filter(|b| b.name == input.body_name)
        .ok_or_else(|| bad(command, "optical target ordinal and exact name do not match"))?
        .name;
    let identities = super::surface_bindings::targets(s, command)?;
    let mut matches = identities.iter().filter(|(_, world)| *world == name);
    let target = matches.next().map(|(t, _)| t.clone()).ok_or_else(|| bad(command, "optical target has no stable source identity"))?;
    if matches.next().is_some() {
        return Err(bad(command, "ambiguous optical target"));
    }
    setup.optics.set(SavedOptics { target, optics: input.optics }, input.replace).map_err(|e| bad(command, e.to_string()))?;
    setup.validate().map_err(|e| bad(command, e.to_string()))?;
    if matches!(setup.job, Some(RenderJob::CpuRaytrace { .. })) {
        // Offline saving resolves identity and numerical compatibility. The selected
        // CPU image producer still certifies actual geometry before any transport.
        let path = matches!(&setup.job,Some(RenderJob::CpuRaytrace{options,..}) if options.path.is_some());
        resolve_cpu_path(s, &scene, &setup.optics, path, command)?;
    } else {
        let resolved = resolve(s, &scene, &setup.optics, command)?;
        super::transmission::apply(&mut scene, &resolved, command)?;
    }
    let mut settings = (*s.doc.render).clone();
    settings.setups.insert(input.name.clone(), setup.clone());
    settings.validate().map_err(|e| bad(command, e.to_string()))?;
    // Serialized before the document changes, so a setup that can't be written leaves it as it was.
    let setup = serde_json::to_value(&setup).map_err(|e| bad(command, e.to_string()))?;
    if settings != *s.doc.render {
        s.doc_mut().render = Arc::new(settings);
    }
    let reply = OpticsBindingSaved {
        name: input.name,
        setup,
        geometry_and_engineering_unchanged: true,
        certification: "closed topology and nested containment are checked by the selected image producer before transport".into(),
        param_warnings: Vec::new(),
    };
    serde_json::to_value(reply).map_err(|e| bad(command, e.to_string()))
}
pub(super) fn unbind(s: &mut Session, params: &Value) -> Result<Value> {
    let command = "render.optics.unbind";
    let input: OpticsUnbindParams = serde_json::from_value(params.clone()).map_err(|e| bad(command, e.to_string()))?;
    input.target.validate().map_err(|e| bad(command, e.to_string()))?;
    if input.expected_revision != s.revision {
        return Err(bad(command, "optical removal review is stale"));
    }
    let mut settings = (*s.doc.render).clone();
    let setup = settings.setups.get_mut(&input.name).ok_or_else(|| bad(command, "unknown optical setup"))?;
    let removed = setup.optics.remove(&input.target);
    settings.validate().map_err(|e| bad(command, e.to_string()))?;
    if settings != *s.doc.render {
        s.doc_mut().render = Arc::new(settings);
    }
    let reply = OpticsUnbound { name: input.name, removed, param_warnings: Vec::new() };
    serde_json::to_value(reply).map_err(|e| bad(command, e.to_string()))
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn optics_are_stable_undoable_offline_and_never_guess_a_replaced_body() {
        let mut s = Session::default();
        s.execute("solid.box", &json!({"length":10,"width":10,"height":4,"body_name":"Diffuser"})).unwrap();
        s.execute("render.settings.set", &json!({"name":"Studio","set":{"job":{"method":"gpu_path"}}})).unwrap();
        let before = s.doc.to_json();
        let geometry = s.doc.features.clone();
        let physical = s.doc.materials.clone();
        let body = json!({"name":"Studio","body_index":0,"body_name":"Diffuser","expected_revision":s.revision,
            "optics":{"ior":1.4,"subsurface":{"scattering_per_mm":0.4,"anisotropy":0.2}}});
        s.execute("render.optics.bind", &body).unwrap();
        let saved = s.doc.to_json();
        assert_eq!(s.doc.features, geometry);
        assert_eq!(s.doc.materials, physical);
        let reopened = solidcraft_doc::Document::from_json(&saved).unwrap();
        assert_eq!(reopened.render, s.doc.render);
        let scene = crate::product_scene::extract(&s).unwrap();
        assert_eq!(resolve(&s, &scene, &s.doc.render.setups["Studio"].optics, "check").unwrap().len(), 1);
        assert!(s.execute("render.optics.bind", &body).is_err(), "review revision is stale");
        assert_eq!(s.doc.to_json(), saved);
        s.execute("edit.undo", &json!({})).unwrap();
        assert_eq!(s.doc.to_json(), before);
        s.execute("edit.redo", &json!({})).unwrap();
        assert_eq!(s.doc.to_json(), saved);
        let mut changed = body;
        changed["expected_revision"] = json!(s.revision);
        changed["optics"]["ior"] = json!(1.6);
        assert!(s.execute("render.optics.bind", &changed).is_err());
        assert_eq!(s.doc.to_json(), saved);
        changed["replace"] = json!(true);
        s.execute("render.optics.bind", &changed).unwrap();
        let target = s.doc.render.setups["Studio"].optics.iter().next().unwrap().target.clone();
        s.execute("render.optics.unbind", &json!({"name":"Studio","target":target,"expected_revision":s.revision})).unwrap();
        assert!(s.doc.render.setups["Studio"].optics.is_empty());
    }

    #[test]
    fn cpu_saved_optics_are_offline_undoable_and_keep_stable_identity_and_mass() {
        let mut s = Session::default();
        s.execute("solid.box", &json!({"length":10,"width":10,"height":3,"body_name":"Optics"})).unwrap();
        s.execute("material.assign", &json!({"bodies":["Optics"],"material":"Steel"})).unwrap();
        s.execute("render.settings.set",&json!({"name":"CPU glass","set":{"width":8,"height":8,"job":{"method":"cpu_raytrace","options":{"progressive":{"samples_per_pixel":3,"seed":81}}}}})).unwrap();
        assert!(s.render_job_host().is_none());
        let physical = s.execute("component.properties", &json!({"component":"root"})).unwrap();
        assert!(physical["total"]["mass_g"].as_f64().unwrap() > 0.0);
        let before = s.doc.clone();
        let undo = s.undo.len();
        let evaluations = s.evaluations;
        s.execute(
            "render.optics.bind",
            &json!({"name":"CPU glass","body_index":0,"body_name":"Optics","expected_revision":s.revision,
            "optics":{"ior":1.51,"absorption_per_mm":[0.1,0.02,0.0],"boundary":"closed_mesh"}}),
        )
        .unwrap();
        assert_eq!(s.undo.len(), undo + 1);
        assert_eq!(s.evaluations, evaluations);
        assert_eq!(s.doc.features, before.features);
        assert_eq!(s.doc.materials, before.materials);
        assert_eq!(s.execute("component.properties", &json!({"component":"root"})).unwrap(), physical);
        let saved = s.doc.clone();
        let scene = crate::product_scene::extract(&s).unwrap();
        let cpu = resolve_cpu(&s, &scene, &s.doc.render.setups["CPU glass"].optics, "check").unwrap();
        assert_eq!(cpu[0].body_name, "Optics");
        assert_eq!(cpu[0].ior, 1.51);
        assert_eq!(cpu[0].boundary, solidcraft_render::job::DielectricBoundary::ClosedBox);
        assert_eq!(
            s.doc.render.setups["CPU glass"].optics.iter().next().unwrap().optics.boundary,
            solidcraft_doc::render_optics::OpticalBoundary::ClosedMesh
        );
        let reopened = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
        assert_eq!(reopened.render, s.doc.render);
        s.execute("edit.undo", &json!({})).unwrap();
        assert_eq!(*s.doc, *before);
        s.execute("edit.redo", &json!({})).unwrap();
        assert_eq!(*s.doc, *saved);
        s.execute("browser.visibility", &json!({"items":["Optics"],"visible":false})).unwrap();
        let hidden = crate::product_scene::extract(&s).unwrap();
        assert!(resolve_cpu(&s, &hidden, &s.doc.render.setups["CPU glass"].optics, "check").unwrap_err().to_string().contains("hidden or absent"));
        s.execute("edit.undo", &json!({})).unwrap();
    }
}