8691cefbbf
* Render: save wood images with physical grain controls * Render: prepare plain glass before marking the GPU host ready
636 lines
34 KiB
Rust
636 lines
34 KiB
Rust
use super::*;
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
use image::ImageEncoder;
|
|
#[cfg(feature = "bundled-render-library")]
|
|
use solidcraft_render::job::textures::{BaseColorMode, TextureMap};
|
|
|
|
#[test]
|
|
fn authored_library_search_is_bounded_and_concepts_are_not_runtime_presets() {
|
|
let mut s = Session::default();
|
|
for (kind, count) in [
|
|
("materials", 600),
|
|
("lighting", 280),
|
|
("environments", 280),
|
|
("surfaces", 48),
|
|
("selene_appearances", 48),
|
|
("hdr", 24),
|
|
("rigs", 24),
|
|
("scenes", 24),
|
|
("quality", 10),
|
|
] {
|
|
let response = s.execute("render.library.list", &json!({"kind":kind,"limit":1})).unwrap();
|
|
assert_eq!(response["total"], count);
|
|
assert_eq!(response["items"].as_array().unwrap().len(), 1);
|
|
assert_eq!(response["next_offset"], 1);
|
|
}
|
|
let response = s.execute("render.library.describe", &json!({"kind":"materials","id":"MAT-001"})).unwrap();
|
|
assert_eq!(response["projection"]["status"], "specification_only");
|
|
assert_eq!(response["resource"]["status"], "concept");
|
|
for params in [
|
|
json!({"limit":129}),
|
|
json!({"limit":0}),
|
|
json!({"offset":4097}),
|
|
json!({"query":"x".repeat(257)}),
|
|
json!({"kind":"not-a-kind"}),
|
|
json!({"extra":true}),
|
|
] {
|
|
assert!(s.execute("render.library.list", ¶ms).is_err());
|
|
}
|
|
assert_eq!(s.execute("render.library.list", &json!({"kind":"surfaces","query":"SURF-001"})).unwrap()["total"], 1);
|
|
}
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
fn custom_surface_fixture() -> (Session, std::path::PathBuf, Vec<u8>, Value) {
|
|
let mut s = Session::default();
|
|
s.execute("solid.box", &json!({"length":100,"width":40,"height":10,"body_name":"Board"})).unwrap();
|
|
let mut bytes = Vec::new();
|
|
image::codecs::png::PngEncoder::new(&mut bytes)
|
|
.write_image(&[128, 64, 32, 255, 192, 96, 48, 255, 64, 32, 16, 255, 224, 160, 96, 255], 2, 2, image::ExtendedColorType::Rgba8)
|
|
.unwrap();
|
|
let nonce = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
|
|
let path = std::env::temp_dir().join(format!("solidcraft-wood-owned-{}-{nonce}.png", std::process::id()));
|
|
std::fs::write(&path, &bytes).unwrap();
|
|
let input = json!({"name":"Wood","set":{"width":64,"height":64,"job":{"method":"gpu_path","options":{}}},
|
|
"body_index":0,"body_name":"Board","frame":{"origin":[0,0,0],"u":[20,0,0],"v":[0,40,0]},
|
|
"maps":{"base_color_srgb":{"path":path,"expected_sha256":HdrId::of(&bytes)}},
|
|
"provenance":{"author":"Original test","source":"synthetic diagnostic","license":"CC0-1.0"}});
|
|
(s, path, bytes, input)
|
|
}
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
#[test]
|
|
fn imported_wood_maps_reopen_without_source_and_keep_geometry_history_and_resource_users() {
|
|
let (mut s, path, bytes, mut input) = custom_surface_fixture();
|
|
// The exact same source in two explicitly different roles occupies one bank entry.
|
|
input["maps"]["roughness_linear"] = input["maps"]["base_color_srgb"].clone();
|
|
let before = s.doc.to_json();
|
|
let physical = (s.doc.materials.clone(), s.doc.features.clone());
|
|
let undo = s.undo.len();
|
|
let result = s.execute("render.surface.import", &input).unwrap();
|
|
assert_eq!(result["self_contained"], true);
|
|
assert_eq!(s.undo.len(), undo + 1);
|
|
assert_eq!((s.doc.materials.clone(), s.doc.features.clone()), physical);
|
|
assert_eq!(s.doc.render.texture_resources.len(), 1);
|
|
let digest = HdrId::of(&bytes);
|
|
assert_eq!(s.doc.render.texture_resources.required(&digest).unwrap().bytes(), bytes);
|
|
let temporary: super::super::textures::Override = serde_json::from_value(json!({
|
|
"body_index":0,"body_name":"Board","frame":{"origin":[0,0,0],"u":[20,0,0],"v":[0,40,0]},"base_color_srgb":path
|
|
}))
|
|
.unwrap();
|
|
let temporary = super::super::textures::capture(&crate::product_scene::extract(&s).unwrap(), &[temporary], "test").unwrap().unwrap();
|
|
assert!(!temporary.bindings()[0].base_color.as_ref().unwrap().gpu_mip_filtering(), "temporary paths retain legacy GPU sampling");
|
|
std::fs::remove_file(&path).unwrap();
|
|
let saved = s.doc.to_json();
|
|
assert!(!saved.contains(path.to_str().unwrap()));
|
|
let mut reopened = Session::new(solidcraft_doc::Document::from_json(&saved).unwrap());
|
|
reopened.execute("render.scene", &json!({})).unwrap();
|
|
let scene = crate::product_scene::extract(&reopened).unwrap();
|
|
let bindings = &reopened.doc.render.setups["Wood"].surfaces;
|
|
let lowered = super::super::surface_bindings::resolve(&reopened, &scene, bindings, "test").unwrap();
|
|
let captured =
|
|
super::super::textures::capture_with_resources(&scene, &lowered, Some(&reopened.doc.render.texture_resources), "test").unwrap().unwrap();
|
|
let map = captured.bindings()[0].base_color.as_ref().unwrap();
|
|
assert!(map.gpu_mip_filtering(), "reopened imported images retain their new filtering policy");
|
|
assert!(captured.bindings()[0].roughness.as_ref().unwrap().gpu_mip_filtering());
|
|
assert_eq!(map.dimensions(), [2, 2]);
|
|
let pixels = map.decode(&solidcraft_render::job::CancelToken::default()).unwrap();
|
|
let expected = ((128.0_f64 / 255.0 + 0.055) / 1.055).powf(2.4);
|
|
assert!((f64::from(pixels[0]) - expected).abs() < 1e-7);
|
|
assert_eq!(captured.bindings()[0].frame.u, [20.0, 0.0, 0.0]);
|
|
assert_eq!(captured.bindings()[0].frame.v, [0.0, 40.0, 0.0]);
|
|
let list = reopened.execute("render.texture.list", &json!({})).unwrap();
|
|
assert_eq!(list["resources"][0]["sha256"], digest.to_string());
|
|
assert_eq!(list["resources"][0]["users"], json!(["Wood"]));
|
|
assert!(reopened.execute("render.texture.remove", &json!({"sha256":digest})).unwrap_err().to_string().contains("Wood"));
|
|
let target = reopened.doc.render.setups["Wood"].surfaces.iter().next().unwrap().target.clone();
|
|
reopened.execute("render.library.surface.unbind", &json!({"name":"Wood","target":target})).unwrap();
|
|
reopened.execute("render.texture.remove", &json!({"sha256":digest})).unwrap();
|
|
assert!(reopened.doc.render.texture_resources.is_empty());
|
|
reopened.execute("edit.undo", &json!({})).unwrap();
|
|
assert_eq!(reopened.doc.render.texture_resources.required(&digest).unwrap().bytes(), bytes);
|
|
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);
|
|
assert!(Session::default().doc.render.texture_resources.is_empty());
|
|
}
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
#[test]
|
|
fn imported_surface_refusals_are_atomic_and_validate_identity_before_source_access() {
|
|
let (mut s, path, _, input) = custom_surface_fixture();
|
|
let before = s.doc.to_json();
|
|
let history = (s.revision, s.undo.len());
|
|
for patch in [
|
|
json!({"body_name":"Wrong", "maps":{"base_color_srgb":{"path":"missing-file.png"}}}),
|
|
json!({"normal_strength":2.0}),
|
|
json!({"frame":{"origin":[0,0,0],"u":[20,0,0],"v":[20,0,0]}}),
|
|
json!({"maps":{}}),
|
|
json!({"maps":{"base_color_srgb":{"path":path,"expected_sha256":"0".repeat(64)}}}),
|
|
json!({"set":{"job":{"method":"raster"}}}),
|
|
json!({"provenance":{"author":"bad\ntext","source":"synthetic","license":"CC0"}}),
|
|
] {
|
|
let mut request = input.clone();
|
|
for (field, value) in patch.as_object().unwrap() {
|
|
request[field] = value.clone();
|
|
}
|
|
assert!(s.execute("render.surface.import", &request).is_err(), "{request}");
|
|
assert_eq!(s.doc.to_json(), before);
|
|
assert_eq!((s.revision, s.undo.len()), history);
|
|
}
|
|
let mut request = input.clone();
|
|
request["maps"]["normal_opengl"] = json!({"path":"missing-later-map.png"});
|
|
assert!(s.execute("render.surface.import", &request).is_err());
|
|
assert_eq!(s.doc.to_json(), before, "a later failed map cannot leak an earlier imported resource");
|
|
std::fs::remove_file(path).unwrap();
|
|
}
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
#[test]
|
|
fn cpu_surface_import_and_method_switch_reject_unsupported_encoding_without_losing_the_gpu_binding() {
|
|
let (mut s, path, _, mut input) = custom_surface_fixture();
|
|
let mut jpeg = Vec::new();
|
|
image::codecs::jpeg::JpegEncoder::new(&mut jpeg).write_image(&[128_u8; 12], 2, 2, image::ExtendedColorType::Rgb8).unwrap();
|
|
std::fs::write(&path, &jpeg).unwrap();
|
|
input["maps"]["base_color_srgb"]["expected_sha256"] = json!(HdrId::of(&jpeg));
|
|
input["set"]["job"]["method"] = json!("cpu_raytrace");
|
|
let before = s.doc.to_json();
|
|
let history = (s.revision, s.undo.len());
|
|
assert!(s.execute("render.surface.import", &input).unwrap_err().to_string().contains("noninterlaced 8-bit PNG"));
|
|
assert_eq!(s.doc.to_json(), before);
|
|
assert_eq!((s.revision, s.undo.len()), history);
|
|
input["set"]["job"]["method"] = json!("gpu_path");
|
|
s.execute("render.surface.import", &input).unwrap();
|
|
let saved = s.doc.to_json();
|
|
assert!(
|
|
s.execute("render.settings.set", &json!({"name":"Wood","set":{"job":{"method":"cpu_raytrace","options":{}}}}))
|
|
.unwrap_err()
|
|
.to_string()
|
|
.contains("noninterlaced 8-bit PNG")
|
|
);
|
|
assert_eq!(s.doc.to_json(), saved);
|
|
std::fs::remove_file(path).unwrap();
|
|
}
|
|
|
|
#[cfg(feature = "bundled-render-library")]
|
|
#[test]
|
|
fn built_in_maps_keep_exact_published_bytes_and_explicit_channel_roles() {
|
|
let mut count = 0;
|
|
for surface in catalog("surface_manifest", "test").unwrap() {
|
|
let id = surface["id"].as_str().unwrap();
|
|
for (name, role) in [
|
|
("base_color", MapRole::BaseColor),
|
|
("normal_open_gl", MapRole::NormalOpenGl),
|
|
("roughness", MapRole::Roughness),
|
|
("metallic", MapRole::Metallic),
|
|
] {
|
|
let key = format!("{id}/{name}");
|
|
let bytes = texture_bytes(&key, role, 16 * 1024 * 1024, "test").unwrap();
|
|
assert_eq!(HdrId::of(&bytes).to_string(), surface["maps"][name]["sha256"].as_str().unwrap());
|
|
assert_eq!(TextureMap::new(bytes, role).unwrap().dimensions(), [512, 512]);
|
|
count += 1;
|
|
}
|
|
}
|
|
assert_eq!(count, 192);
|
|
for key in ["../SURF-001/base_color", "SURF-001/../base_color", "SURF-001/height", "SURF-999/base_color"] {
|
|
assert!(texture_bytes(key, MapRole::BaseColor, 16 * 1024 * 1024, "test").is_err());
|
|
}
|
|
assert!(texture_bytes("SURF-001/normal_open_gl", MapRole::BaseColor, 16 * 1024 * 1024, "test").is_err());
|
|
assert!(texture_bytes("SURF-001/base_color", MapRole::BaseColor, 1, "test").is_err());
|
|
}
|
|
|
|
#[cfg(feature = "bundled-render-library")]
|
|
#[test]
|
|
fn builtin_hdr_capture_is_atomic_undoable_deduplicated_and_path_independent() {
|
|
let mut s = Session::default();
|
|
let empty = s.doc.to_json();
|
|
let request = json!({"id":"HDR-001","name":"Library CPU","set":{"width":64,"height":32,"job":{"method":"cpu_raytrace","options":{}}}});
|
|
let reply = s.execute("render.library.environment.apply", &request).unwrap();
|
|
assert_eq!(reply["source_sha256"], reply["resource"]);
|
|
assert_eq!(reply["native_rotation_rad"], std::f64::consts::PI);
|
|
assert_eq!(reply["self_contained"], true);
|
|
let Some(RenderJob::CpuRaytrace { options }) = &s.doc.render.setups["Library CPU"].job else {
|
|
panic!("CPU intent");
|
|
};
|
|
let id = options.hdr.unwrap().resource;
|
|
assert_eq!(s.doc.render.resources.required(&id).unwrap().bytes(), super::super::library_data::asset("HDR-001").unwrap().0);
|
|
let saved = s.doc.to_json();
|
|
let reopened = solidcraft_doc::Document::from_json(&saved).unwrap();
|
|
assert_eq!(reopened.render.resources.required(&id).unwrap().id(), id);
|
|
let before = s.undo.len();
|
|
assert!(s.execute("render.library.environment.apply", &request).is_err(), "replacement must be explicit");
|
|
assert_eq!(s.doc.to_json(), saved);
|
|
assert_eq!(s.undo.len(), before);
|
|
let mut identical = request;
|
|
identical["replace_environment"] = json!(true);
|
|
s.execute("render.library.environment.apply", &identical).unwrap();
|
|
assert_eq!(s.undo.len(), before, "identical resource application is a no-op");
|
|
s.execute("edit.undo", &json!({})).unwrap();
|
|
assert_eq!(s.doc.to_json(), empty);
|
|
}
|
|
|
|
#[test]
|
|
fn authored_hdr_orientation_matches_the_documented_longitude_origin() {
|
|
use std::f64::consts::{PI, TAU};
|
|
for u in [0.0, 0.125, 0.25, 0.5, 0.75, 0.999] {
|
|
for rotation in [0.0, 0.3, -1.2] {
|
|
let world_phi = TAU * (u - 0.5) + rotation;
|
|
let native_u = ((world_phi - hdr_rotation(rotation, "test").unwrap()) / TAU).rem_euclid(1.0);
|
|
let distance = (native_u - u).abs();
|
|
assert!(distance.min(1.0 - distance) < 1e-12);
|
|
}
|
|
}
|
|
assert_eq!(hdr_rotation(0.0, "test").unwrap(), PI);
|
|
for v in [f64::NAN, f64::INFINITY, 1e7] {
|
|
assert!(hdr_rotation(v, "test").is_err());
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "bundled-render-library")]
|
|
#[test]
|
|
fn explicit_surface_prepare_has_physical_scale_and_does_not_assign_materials() {
|
|
let mut s = Session::default();
|
|
s.execute("solid.box", &json!({"length":10,"width":20,"height":5,"body_name":"Target"})).unwrap();
|
|
let before = s.doc.to_json();
|
|
let undo = s.undo.len();
|
|
let reply = s.execute("render.library.surface.prepare", &json!({"id":"SURF-001","body_index":0,"body_name":"Target","scale":2.0})).unwrap();
|
|
assert_eq!(reply["texture"]["frame"]["u"], json!([200.0, 0.0, 0.0]));
|
|
assert_eq!(reply["texture"]["flip_v"], true);
|
|
assert_eq!(reply["texture"]["base_color_mode"], "replace");
|
|
assert!(reply["texture"].get("height").is_none());
|
|
let input: super::super::textures::Override = serde_json::from_value(reply["texture"].clone()).unwrap();
|
|
let scene = crate::product_scene::extract(&s).unwrap();
|
|
let textures = super::super::textures::capture(&scene, &[input], "test").unwrap().unwrap();
|
|
let binding = &textures.bindings()[0];
|
|
assert!(binding.flip_v && binding.roughness.is_some() && binding.metallic.is_some());
|
|
for map in [&binding.base_color, &binding.normal, &binding.roughness, &binding.metallic].into_iter().flatten() {
|
|
assert!(!map.gpu_mip_filtering(), "built-in preparation retains legacy GPU sampling");
|
|
}
|
|
assert_eq!(binding.base_color_mode, BaseColorMode::Replace);
|
|
assert_eq!(s.doc.to_json(), before);
|
|
assert_eq!(s.undo.len(), undo);
|
|
assert!(s.execute("render.library.surface.prepare", &json!({"id":"SURF-001","body_index":0,"body_name":"Old name"})).is_err());
|
|
}
|
|
|
|
#[cfg(feature = "bundled-render-library")]
|
|
#[test]
|
|
fn wood_grain_rotation_preserves_non_square_repeats_in_each_plane() {
|
|
use solidcraft_render::job::textures::PlanarFrame;
|
|
let mut s = Session::default();
|
|
s.execute("solid.box", &json!({"length":100,"width":100,"height":20,"body_name":"Board"})).unwrap();
|
|
let before = s.doc.to_json();
|
|
let history = (s.undo.len(), s.redo.len());
|
|
for (plane, expected_u, expected_v) in
|
|
[("xy", [0.0, 60.0, 0.0], [-120.0, 0.0, 0.0]), ("yz", [0.0, 0.0, 60.0], [0.0, -120.0, 0.0]), ("zx", [60.0, 0.0, 0.0], [0.0, 0.0, -120.0])]
|
|
{
|
|
let reply = s
|
|
.execute(
|
|
"render.library.surface.prepare",
|
|
&json!({"id":"SURF-027","body_index":0,"body_name":"Board","plane":plane,"scale":0.25,
|
|
"rotation_rad":std::f64::consts::FRAC_PI_2}),
|
|
)
|
|
.unwrap();
|
|
let frame: PlanarFrame = serde_json::from_value(reply["texture"]["frame"].clone()).unwrap();
|
|
for ((u, expected_u), (v, expected_v)) in frame.u.into_iter().zip(expected_u).zip(frame.v.into_iter().zip(expected_v)) {
|
|
assert!((u - expected_u).abs() < 1e-10);
|
|
assert!((v - expected_v).abs() < 1e-10);
|
|
}
|
|
let reply = s
|
|
.execute(
|
|
"render.library.surface.prepare",
|
|
&json!({"id":"SURF-027","body_index":0,"body_name":"Board","plane":plane,"scale":0.25,
|
|
"rotation_rad":std::f64::consts::FRAC_PI_4}),
|
|
)
|
|
.unwrap();
|
|
let frame: PlanarFrame = serde_json::from_value(reply["texture"]["frame"].clone()).unwrap();
|
|
let len2 = |v: [f64; 3]| v.into_iter().map(|x| x * x).sum::<f64>();
|
|
assert!((len2(frame.u) - 60.0 * 60.0).abs() < 1e-9);
|
|
assert!((len2(frame.v) - 120.0 * 120.0).abs() < 1e-9);
|
|
assert!(frame.u.into_iter().zip(frame.v).map(|(u, v)| u * v).sum::<f64>().abs() < 1e-9);
|
|
}
|
|
for angle in [json!(1_000_001.0), json!(-1_000_001.0), Value::Null, json!("90 deg"), json!([])] {
|
|
assert!(
|
|
s.execute("render.library.surface.prepare", &json!({"id":"SURF-027","body_index":0,"body_name":"Board","rotation_rad":angle})).is_err()
|
|
);
|
|
}
|
|
assert_eq!(s.doc.to_json(), before);
|
|
assert_eq!((s.undo.len(), s.redo.len()), history);
|
|
}
|
|
|
|
#[cfg(feature = "bundled-render-library")]
|
|
#[test]
|
|
fn saved_wood_grain_angle_reopens_and_rotates_with_only_its_occurrence() {
|
|
let mut s = Session::default();
|
|
let component = s.execute("component.create", &json!({"name":"Board part","grounded":false})).unwrap();
|
|
s.execute("solid.box", &json!({"length":100,"width":40,"height":10,"body_name":"Board"})).unwrap();
|
|
s.execute("component.activate", &json!({"component":0})).unwrap();
|
|
s.execute("occurrence.copy", &json!({"component":component["component"],"translate":[150,0,0]})).unwrap();
|
|
let physical = (s.doc.materials.clone(), s.doc.features.clone());
|
|
s.execute(
|
|
"render.library.surface.bind",
|
|
&json!({"name":"Grain","set":{"job":{"method":"gpu_path","options":{}}},
|
|
"surface":{"id":"SURF-027","body_index":0,"body_name":"Board","scale":0.25,
|
|
"rotation_rad":std::f64::consts::FRAC_PI_4}}),
|
|
)
|
|
.unwrap();
|
|
assert_eq!((s.doc.materials.clone(), s.doc.features.clone()), physical);
|
|
let saved = s.doc.to_json();
|
|
let mut reopened = Session::new(solidcraft_doc::Document::from_json(&saved).unwrap());
|
|
reopened.execute("render.scene", &json!({})).unwrap();
|
|
let bindings = reopened.doc.render.setups["Grain"].surfaces.clone();
|
|
let lower = |session: &Session| {
|
|
let scene = crate::product_scene::extract(session).unwrap();
|
|
let lowered = super::super::surface_bindings::resolve(session, &scene, &bindings, "test").unwrap();
|
|
super::super::textures::capture(&scene, &lowered, "test").unwrap().unwrap().bindings().iter().map(|binding| binding.frame).collect::<Vec<_>>()
|
|
};
|
|
let first = lower(&reopened);
|
|
assert_eq!(first.len(), 1);
|
|
let frame = first[0];
|
|
reopened.execute("occurrence.move", &json!({"occurrence":component["occurrence"],"axis":[0,0,1],"angle":std::f64::consts::FRAC_PI_2})).unwrap();
|
|
let rotated = lower(&reopened);
|
|
assert_eq!(rotated.len(), 1);
|
|
for (actual, old) in [(rotated[0].u, frame.u), (rotated[0].v, frame.v)] {
|
|
assert!((actual[0] + old[1]).abs() < 1e-10);
|
|
assert!((actual[1] - old[0]).abs() < 1e-10);
|
|
assert!((actual[2] - old[2]).abs() < 1e-10);
|
|
}
|
|
assert_eq!(reopened.doc.render.setups["Grain"].surfaces, bindings);
|
|
assert_eq!(reopened.doc.materials, physical.0);
|
|
assert_eq!(reopened.doc.features, physical.1);
|
|
reopened.execute("edit.undo", &json!({})).unwrap();
|
|
assert_eq!(lower(&reopened)[0], frame);
|
|
}
|
|
|
|
#[test]
|
|
fn uniform_appearance_requires_acknowledged_projection_and_preserves_physical_data() {
|
|
let mut s = Session::default();
|
|
s.execute("solid.box", &json!({"length":10,"width":20,"height":5,"body_name":"Target"})).unwrap();
|
|
let before = s.doc.to_json();
|
|
let before_value: Value = serde_json::from_str(&before).unwrap();
|
|
let undo = s.undo.len();
|
|
assert!(s.execute("render.library.appearance.apply", &json!({"id":"MAT-001","variant":"uniform_opaque","bodies":["Target"]})).is_err());
|
|
assert_eq!(s.doc.to_json(), before);
|
|
let reply = s.execute("render.library.appearance.apply", &json!({"id":"SURF-001","variant":"uniform_opaque","bodies":["Target"]})).unwrap();
|
|
assert_eq!(reply["engineering_properties_unchanged"], true);
|
|
// The middle of SURF-001's linear range, as sRGB codes.
|
|
assert_eq!(reply["appearance"]["color"], json!([196, 202, 207]));
|
|
let after: Value = serde_json::from_str(&s.doc.to_json()).unwrap();
|
|
assert_eq!(after["user_materials"], before_value["user_materials"]);
|
|
assert_eq!(s.undo.len(), undo + 1);
|
|
s.execute("edit.undo", &json!({})).unwrap();
|
|
assert_eq!(s.doc.to_json(), before);
|
|
}
|
|
|
|
#[test]
|
|
fn studio_adapter_does_not_invent_passive_cards_calibration_or_extra_suns() {
|
|
let mut s = Session::default();
|
|
let request = json!({"id":"RIG-002","variant":"complete","center_mm":[10,20,30],"subject_extent_mm":100.0});
|
|
let reply = s.execute("render.library.studio.prepare", &request).unwrap();
|
|
let lighting: StudioLighting = serde_json::from_value(reply["lighting"].clone()).unwrap();
|
|
assert_eq!(lighting.area_lights.iter().count(), 3);
|
|
assert!(lighting.sun.is_none());
|
|
for id in ["RIG-018", "RIG-019", "RIG-021", "RIG-023", "RIG-024"] {
|
|
let mut p = request.clone();
|
|
p["id"] = json!(id);
|
|
assert!(s.execute("render.library.studio.prepare", &p).is_err());
|
|
}
|
|
let mut with_cards = request.clone();
|
|
with_cards["id"] = json!("RIG-001");
|
|
let complete = s.execute("render.library.studio.prepare", &with_cards).unwrap();
|
|
assert_eq!(complete["stage"].as_array().unwrap().len(), 1);
|
|
assert_eq!(complete["projection"]["passive_cards_omitted"], 0);
|
|
let mut unknown_variant = with_cards.clone();
|
|
unknown_variant["variant"] = json!("silently_drop_cards");
|
|
assert!(s.execute("render.library.studio.prepare", &unknown_variant).is_err());
|
|
with_cards["variant"] = json!("emitters_only");
|
|
assert_eq!(s.execute("render.library.studio.prepare", &with_cards).unwrap()["projection"]["passive_cards_omitted"], 1);
|
|
let mut sun = request;
|
|
sun["id"] = json!("RIG-020");
|
|
let reply = s.execute("render.library.studio.prepare", &sun).unwrap();
|
|
let lighting: StudioLighting = serde_json::from_value(reply["lighting"].clone()).unwrap();
|
|
let actual = lighting.sun.unwrap();
|
|
assert!((actual.angular_radius_rad - 0.00465).abs() < 1e-12);
|
|
assert!(actual.direction[2] > 0.0, "runtime direction points toward the sun, not along incoming photons");
|
|
}
|
|
|
|
#[cfg(feature = "bundled-render-library")]
|
|
#[test]
|
|
fn saved_authored_maps_roundtrip_and_resolve_without_paths_or_captured_ordinals() {
|
|
let mut s = Session::default();
|
|
s.execute("solid.box", &json!({"length":10,"width":20,"height":5,"body_name":"Coupon"})).unwrap();
|
|
let before = s.doc.clone();
|
|
let undo = s.undo.len();
|
|
let input = json!({"name":"Portable","set":{"job":{"method":"gpu_path","options":{}},"width":32,"height":32},
|
|
"surface":{"id":"SURF-001","body_index":0,"body_name":"Coupon"}});
|
|
s.execute("render.library.surface.bind", &input).unwrap();
|
|
assert_eq!(s.undo.len(), undo + 1);
|
|
assert_eq!(s.doc.materials, before.materials);
|
|
assert_eq!(s.doc.appearances, before.appearances);
|
|
assert_eq!(s.doc.features, before.features);
|
|
let saved = s.doc.to_json();
|
|
let mut reopened = Session::new(solidcraft_doc::Document::from_json(&saved).unwrap());
|
|
reopened.execute("render.scene", &json!({})).unwrap();
|
|
let scene = crate::product_scene::extract(&reopened).unwrap();
|
|
let bindings = &reopened.doc.render.setups["Portable"].surfaces;
|
|
let lowered = super::super::surface_bindings::resolve(&reopened, &scene, bindings, "test").unwrap();
|
|
let maps = super::super::textures::capture(&scene, &lowered, "test").unwrap().unwrap();
|
|
assert_eq!(maps.bindings().len(), 1);
|
|
assert_eq!(maps.bindings()[0].body_name, "Coupon");
|
|
assert_eq!(maps.bindings()[0].base_color_mode, BaseColorMode::Replace);
|
|
assert!(maps.bindings()[0].flip_v);
|
|
for map in [&maps.bindings()[0].base_color, &maps.bindings()[0].normal, &maps.bindings()[0].roughness, &maps.bindings()[0].metallic]
|
|
.into_iter()
|
|
.flatten()
|
|
{
|
|
assert!(!map.gpu_mip_filtering(), "existing saved built-in surfaces retain legacy GPU sampling");
|
|
}
|
|
let mut changed = s.doc.render.setups["Portable"].clone();
|
|
let mut binding = changed.surfaces.iter().next().unwrap().clone();
|
|
let solidcraft_doc::render_surface::SurfaceSource::Builtin(source) = &mut binding.source else { panic!("built-in fixture") };
|
|
source.base_color_sha256 = HdrId::of(b"changed");
|
|
changed.surfaces.set(binding, true).unwrap();
|
|
assert!(super::super::surface_bindings::resolve(&s, &crate::product_scene::extract(&s).unwrap(), &changed.surfaces, "test").is_err());
|
|
s.execute("edit.undo", &json!({})).unwrap();
|
|
assert_eq!(s.doc, before);
|
|
}
|
|
|
|
#[cfg(feature = "bundled-render-library")]
|
|
#[test]
|
|
fn saved_surface_follows_its_occurrence_without_rebinding_another_instance() {
|
|
let mut s = Session::default();
|
|
let component = s.execute("component.create", &json!({"name":"Mapped part"})).unwrap();
|
|
s.execute("solid.box", &json!({"length":10,"width":10,"height":2,"body_name":"Panel"})).unwrap();
|
|
s.execute("component.activate", &json!({"component":0})).unwrap();
|
|
s.execute("occurrence.copy", &json!({"component":component["component"],"translate":[30,0,0]})).unwrap();
|
|
s.execute(
|
|
"render.library.surface.bind",
|
|
&json!({"name":"P","set":{"job":{"method":"gpu_path","options":{}}},
|
|
"surface":{"id":"SURF-003","body_index":0,"body_name":"Panel"}}),
|
|
)
|
|
.unwrap();
|
|
let bindings = s.doc.render.setups["P"].surfaces.clone();
|
|
let capture = |session: &Session| {
|
|
let scene = crate::product_scene::extract(session).unwrap();
|
|
let lowered = super::super::surface_bindings::resolve(session, &scene, &bindings, "test").unwrap();
|
|
super::super::textures::capture(&scene, &lowered, "test").unwrap().unwrap()
|
|
};
|
|
let original = capture(&s);
|
|
let frame = original.bindings()[0].frame;
|
|
// Upstream grounds the first occurrence. Keep that refusal explicit before
|
|
// exercising a deliberately movable instance and its stable render binding.
|
|
let grounded_document = s.doc.clone();
|
|
let grounded_history = (s.revision, s.undo.len(), s.redo.len());
|
|
let movement = json!({"occurrence":component["occurrence"],"translate":[12,0,0]});
|
|
let error = s.execute("occurrence.move", &movement).unwrap_err().to_string();
|
|
assert!(error.contains("is grounded"), "{error}");
|
|
assert_eq!(s.doc, grounded_document);
|
|
assert_eq!((s.revision, s.undo.len(), s.redo.len()), grounded_history);
|
|
s.execute("occurrence.ground", &json!({"occurrence":component["occurrence"],"grounded":false})).unwrap();
|
|
s.execute("occurrence.move", &movement).unwrap();
|
|
let moved = capture(&s);
|
|
assert_eq!(moved.bindings().len(), 1);
|
|
assert!((moved.bindings()[0].frame.origin[0] - frame.origin[0] - 12.0).abs() < 1e-8);
|
|
assert_eq!(moved.bindings()[0].frame.u, frame.u);
|
|
assert_eq!(moved.bindings()[0].frame.v, frame.v);
|
|
assert_eq!(s.doc.render.setups["P"].surfaces, bindings);
|
|
}
|
|
|
|
#[cfg(feature = "bundled-render-library")]
|
|
#[test]
|
|
fn saved_surface_rejects_changed_feature_and_hidden_target_and_can_be_removed_offline() {
|
|
let mut s = Session::default();
|
|
s.execute("solid.box", &json!({"length":2,"width":2,"height":2,"body_name":"Panel"})).unwrap();
|
|
s.execute(
|
|
"render.library.surface.bind",
|
|
&json!({"name":"P","set":{"job":{"method":"gpu_path","options":{}}},
|
|
"surface":{"id":"SURF-002","body_index":0,"body_name":"Panel"}}),
|
|
)
|
|
.unwrap();
|
|
let mut setup = s.doc.render.setups["P"].clone();
|
|
let target = setup.surfaces.iter().next().unwrap().target.clone();
|
|
let mut binding = setup.surfaces.iter().next().unwrap().clone();
|
|
binding.target.feature += 100;
|
|
setup.surfaces.remove(&target);
|
|
setup.surfaces.set(binding, false).unwrap();
|
|
let scene = crate::product_scene::extract(&s).unwrap();
|
|
assert!(super::super::surface_bindings::resolve(&s, &scene, &setup.surfaces, "test").is_err());
|
|
s.visibility.hidden_bodies.push("Panel".into());
|
|
assert!(
|
|
super::super::surface_bindings::resolve(&s, &crate::product_scene::extract(&s).unwrap(), &s.doc.render.setups["P"].surfaces, "test").is_err()
|
|
);
|
|
let previous = s.doc.clone();
|
|
s.execute("render.library.surface.unbind", &json!({"name":"P","target":target})).unwrap();
|
|
assert!(s.doc.render.setups["P"].surfaces.is_empty());
|
|
s.execute("edit.undo", &json!({})).unwrap();
|
|
assert_eq!(s.doc, previous);
|
|
let before = s.doc.to_json();
|
|
assert!(s.execute("render.settings.set", &json!({"name":"P","set":{"job":{"method":"raster"}}})).is_err());
|
|
assert_eq!(s.doc.to_json(), before);
|
|
}
|
|
|
|
#[test]
|
|
fn saved_passive_ground_keeps_cad_unchanged_and_is_revalidated_after_product_motion() {
|
|
let mut s = Session::default();
|
|
s.execute("solid.box", &json!({"length":10,"width":20,"height":5,"body_name":"Subject"})).unwrap();
|
|
let before = s.doc.clone();
|
|
let history = s.undo.len();
|
|
let request = json!({"name":"Stage","set":{"job":{"method":"cpu_raytrace","options":{"budget":"studio"}}}});
|
|
s.execute("render.stage.ground", &request).unwrap();
|
|
assert_eq!(s.undo.len(), history + 1);
|
|
assert_eq!(s.doc.features, before.features);
|
|
assert_eq!(s.doc.materials, before.materials);
|
|
let setup = s.doc.render.setups["Stage"].clone();
|
|
assert_eq!(setup.stage.len(), 1);
|
|
let original = crate::product_scene::extract(&s).unwrap();
|
|
assert_eq!(original.meshes.len(), 1);
|
|
let mut staged = original.clone();
|
|
super::super::staging::apply(&mut staged, &setup, "test").unwrap();
|
|
assert_eq!(staged.meshes.len(), 2);
|
|
assert!(Arc::ptr_eq(&staged.meshes[0].mesh, &original.meshes[0].mesh));
|
|
let reopened = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
|
|
assert_eq!(reopened.render.setups["Stage"], setup);
|
|
assert!(s.execute("render.stage.ground", &request).is_err(), "never replace a stage silently");
|
|
s.execute("render.stage.clear", &json!({"name":"Stage"})).unwrap();
|
|
assert!(s.doc.render.setups["Stage"].stage.is_empty());
|
|
s.execute("edit.undo", &json!({})).unwrap();
|
|
assert_eq!(s.doc.render.setups["Stage"], setup);
|
|
let mut intersects = setup;
|
|
let mut panel = intersects.stage.iter().next().unwrap().clone();
|
|
panel.center_mm[2] = 0.0;
|
|
intersects.stage = solidcraft_render::stage::Stage::new(vec![panel]).unwrap();
|
|
assert!(super::super::staging::apply(&mut original.clone(), &intersects, "test").is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn complete_authored_rig_keeps_passive_cards_nonemissive_and_scales_exactly_once() {
|
|
let mut s = Session::default();
|
|
let rig = json!({"id":"RIG-001","variant":"complete","center_mm":[10,20,30],"subject_extent_mm":100});
|
|
let prepared = s.execute("render.library.studio.prepare", &rig).unwrap();
|
|
assert_eq!(prepared["projection"]["passive_cards_omitted"], 0);
|
|
assert_eq!(prepared["projection"]["passive_cards_included"], 1);
|
|
assert_eq!(prepared["stage"][0]["center_mm"], json!([90.0, 10.0, 30.0]));
|
|
let stage: solidcraft_render::stage::Stage = serde_json::from_value(prepared["stage"].clone()).unwrap();
|
|
assert_eq!(stage.iter().next().unwrap().reflectance_linear, [0.75; 3]);
|
|
let input = json!({"name":"Rig","set":{"job":{"method":"gpu_path","options":{}}},"rig":rig,"replace_lighting_and_environment":true});
|
|
s.execute("render.library.studio.apply", &input).unwrap();
|
|
assert_eq!(s.doc.render.setups["Rig"].stage, stage);
|
|
assert!(s.doc.features.is_empty());
|
|
assert!(s.doc.materials.is_empty());
|
|
let mut emitter_only = rig;
|
|
emitter_only["variant"] = json!("emitters_only");
|
|
let projected = s.execute("render.library.studio.prepare", &emitter_only).unwrap();
|
|
assert_eq!(projected["projection"]["passive_cards_omitted"], 1);
|
|
assert_eq!(projected["stage"], json!([]));
|
|
}
|
|
|
|
#[cfg(feature = "bundled-render-library")]
|
|
#[test]
|
|
fn patch_cannot_hide_existing_resources_from_replacement_consent() {
|
|
let mut s = Session::default();
|
|
s.execute("solid.box", &json!({"length":10,"width":10,"height":2,"body_name":"Panel"})).unwrap();
|
|
let base = json!({"job":{"method":"gpu_path","options":{}}});
|
|
s.execute("render.library.surface.bind", &json!({"name":"P","set":base,"surface":{"id":"SURF-001","body_index":0,"body_name":"Panel"}})).unwrap();
|
|
let before = s.doc.to_json();
|
|
assert!(
|
|
s.execute(
|
|
"render.library.surface.bind",
|
|
&json!({"name":"P","set":{"surfaces":[]},"surface":{"id":"SURF-002","body_index":0,"body_name":"Panel"}})
|
|
)
|
|
.is_err()
|
|
);
|
|
assert_eq!(s.doc.to_json(), before);
|
|
s.execute("render.stage.ground", &json!({"name":"P"})).unwrap();
|
|
let before = s.doc.to_json();
|
|
assert!(s.execute("render.stage.ground", &json!({"name":"P","set":{"stage":[]}})).is_err());
|
|
assert!(
|
|
s.execute(
|
|
"render.library.studio.apply",
|
|
&json!({"name":"P","set":{"stage":[]},"replace_lighting_and_environment":true,
|
|
"rig":{"id":"RIG-002","variant":"complete","center_mm":[0,0,0],"subject_extent_mm":1000}})
|
|
)
|
|
.is_err()
|
|
);
|
|
assert_eq!(s.doc.to_json(), before);
|
|
}
|
|
|
|
#[cfg(not(feature = "bundled-render-library"))]
|
|
#[test]
|
|
fn omitted_optional_pack_keeps_discovery_but_refuses_resource_mutation() {
|
|
let mut session = Session::default();
|
|
let before = session.doc.clone();
|
|
let history = (session.revision, session.undo.len());
|
|
let hdr = session.execute("render.library.list", &json!({"kind":"hdr","availability":"usable"})).unwrap();
|
|
assert_eq!(hdr["total"], 0);
|
|
assert!(
|
|
texture_bytes("SURF-001/base_color", MapRole::BaseColor, 16 * 1024 * 1024, "test")
|
|
.unwrap_err()
|
|
.to_string()
|
|
.contains("bundled-render-library")
|
|
);
|
|
let request = json!({"id":"HDR-001","name":"No pack","set":{"job":{"method":"gpu_path","options":{}}}});
|
|
assert!(session.execute("render.library.environment.apply", &request).unwrap_err().to_string().contains("bundled-render-library"));
|
|
assert!(session.execute("render.library.surface.bind", &json!({})).unwrap_err().to_string().contains("bundled-render-library"));
|
|
assert_eq!(session.doc, before);
|
|
assert_eq!((session.revision, session.undo.len()), history);
|
|
}
|