mirror of
https://github.com/storytold/materialcraft.git
synced 2026-11-22 07:20:57 +01:00
Give each document an exclusive recovery history, skip occupied version names, and stream native archive saves. Publish pending linked edits before Save All selects packages, and preserve each document's result on partial failure. Commit destructive preference changes on Apply or OK. Respect the 3D preview preference on open and reload, discard cancelled cooks, and validate graph destinations before switching documents. Reuse the Library catalog and borrow its keys on cache hits. Keep template textures with their app, correct shortcut handling and help links, and omit personal document details from exported diagnostics.
324 lines
16 KiB
Rust
324 lines
16 KiB
Rust
use materialcraft_engine::{
|
|
MaterialPreview, MaterialSource, Session,
|
|
core::{Graph, MaterialChannel, NodeId, OutputFormat, Package, Value},
|
|
execute, new_session,
|
|
};
|
|
use serde_json::json;
|
|
|
|
fn add(session: &mut Session, definition: &str, params: serde_json::Value) -> NodeId {
|
|
NodeId(execute(session, "graph.node.add", &json!({"def": definition, "params": params})).unwrap()["id"].as_u64().unwrap())
|
|
}
|
|
|
|
fn source(session: &mut Session, color: [f32; 4]) -> NodeId {
|
|
session.graph_mut().unwrap().format = OutputFormat::F32;
|
|
add(session, "uniform", json!({"color_mode": true, "color": color}))
|
|
}
|
|
|
|
fn output(session: &mut Session, source: NodeId, usage: u32) -> NodeId {
|
|
let output = add(session, "output", json!({"usage": usage}));
|
|
execute(session, "graph.connect", &json!({"from": source, "to": output})).unwrap();
|
|
output
|
|
}
|
|
|
|
fn instance(session: &mut Session, graph: &str) -> NodeId {
|
|
let node = session.graph_mut().unwrap().add_node("graph_instance", [0.0; 2]);
|
|
session.graph_mut().unwrap().node_mut(node).unwrap().params.insert("graph".into(), Value::Text(graph.into()));
|
|
node
|
|
}
|
|
|
|
fn color(session: &mut Session, channel: &str) -> [f32; 4] {
|
|
session.cook();
|
|
session.material_maps().into_iter().find(|(usage, _)| *usage == channel).unwrap().1.get(0, 0, false)
|
|
}
|
|
|
|
#[test]
|
|
fn explicit_assignment_shows_unclassified_output_and_tracks_edits() {
|
|
let mut session = new_session();
|
|
session.preview_size = Some(16);
|
|
let red = source(&mut session, [0.8, 0.1, 0.1, 1.0]);
|
|
let output = output(&mut session, red, 9);
|
|
session.cook();
|
|
assert!(session.material_maps().is_empty());
|
|
let history = session.history();
|
|
let package = session.pkg.clone();
|
|
execute(&mut session, "view.3d.assign", &json!({"node": output, "channel": "baseColor"})).unwrap();
|
|
assert_eq!(session.history(), history);
|
|
assert_eq!(session.pkg, package);
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
let key = session.material_key();
|
|
execute(&mut session, "graph.node.param", &json!({"id": red, "param": "color", "value": [0.1, 0.8, 0.2, 1.0]})).unwrap();
|
|
assert_eq!(color(&mut session, "baseColor"), [0.1, 0.8, 0.2, 1.0]);
|
|
assert_ne!(session.material_key(), key);
|
|
let inspection = execute(&mut session, "session.inspect", &json!({})).unwrap();
|
|
assert_eq!(inspection["material3d"]["channels"][0]["size"], json!([16, 16]));
|
|
}
|
|
|
|
#[test]
|
|
fn automatic_outputs_follow_usage_and_do_not_follow_selection() {
|
|
let mut session = new_session();
|
|
session.preview_size = Some(16);
|
|
let red = source(&mut session, [0.8, 0.1, 0.1, 1.0]);
|
|
let blue = source(&mut session, [0.1, 0.1, 0.8, 1.0]);
|
|
let output = output(&mut session, red, 0);
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
execute(&mut session, "graph.select", &json!({"ids": [blue]})).unwrap();
|
|
execute(&mut session, "view.2d", &json!({"node": blue})).unwrap();
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
execute(&mut session, "graph.node.param", &json!({"id": output, "param": "usage", "value": 4})).unwrap();
|
|
assert_eq!(color(&mut session, "height"), [0.8, 0.1, 0.1, 1.0]);
|
|
assert!(session.material_maps().iter().all(|(channel, _)| *channel != "baseColor"));
|
|
}
|
|
|
|
#[test]
|
|
fn graph_application_and_material_reset_preserve_camera_and_scene() {
|
|
let mut session = new_session();
|
|
session.preview_size = Some(16);
|
|
let red = source(&mut session, [0.8, 0.1, 0.1, 1.0]);
|
|
output(&mut session, red, 0);
|
|
let blue = source(&mut session, [0.1, 0.1, 0.8, 1.0]);
|
|
execute(&mut session, "view.3d.assign", &json!({"node": blue, "channel": "baseColor"})).unwrap();
|
|
execute(&mut session, "view.3d.assign", &json!({"node": blue, "channel": "roughness"})).unwrap();
|
|
execute(&mut session, "view.3d", &json!({"scene": "sphere", "yaw": 70, "distance": 4, "environment": "sunset"})).unwrap();
|
|
let view = session.view3d.clone();
|
|
execute(&mut session, "view.3d.outputs", &json!({})).unwrap();
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
assert!(session.material_maps().iter().any(|(channel, _)| *channel == "roughness"));
|
|
execute(&mut session, "view.3d.outputs", &json!({"reset": true})).unwrap();
|
|
session.cook();
|
|
assert_eq!(session.material_maps().len(), 1);
|
|
assert_eq!(session.view3d, view);
|
|
execute(&mut session, "view.3d.clear", &json!({})).unwrap();
|
|
assert!(session.material_maps().is_empty());
|
|
assert_eq!(session.view3d, view);
|
|
}
|
|
|
|
#[test]
|
|
fn assignments_survive_function_editing_and_undo_without_retargeting_node_ids() {
|
|
let mut session = new_session();
|
|
session.preview_size = Some(16);
|
|
let red = source(&mut session, [0.8, 0.1, 0.1, 1.0]);
|
|
execute(&mut session, "view.3d.assign", &json!({"node": red, "channel": "baseColor"})).unwrap();
|
|
session.cook();
|
|
execute(&mut session, "file.new", &json!({"kind": "function", "name": "Function"})).unwrap();
|
|
assert_eq!(session.material_maps()[0].1.get(0, 0, false), [0.8, 0.1, 0.1, 1.0], "keep the previous material while the worker cooks");
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
execute(&mut session, "edit.undo", &json!({})).unwrap();
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
execute(&mut session, "file.new", &json!({"template": "empty", "name": "Blue"})).unwrap();
|
|
let blue = source(&mut session, [0.1, 0.1, 0.8, 1.0]);
|
|
assert_eq!(red, blue);
|
|
execute(&mut session, "view.3d.assign", &json!({"graph": 0, "node": red, "channel": "baseColor"})).unwrap();
|
|
execute(&mut session, "graph.node.param", &json!({"id": blue, "param": "color", "value": [0.2, 0.2, 0.9, 1.0]})).unwrap();
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
execute(&mut session, "graph.rename", &json!({"graph": 0, "name": "Renamed"})).unwrap();
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
execute(&mut session, "graph.delete", &json!({"graph": 0})).unwrap();
|
|
session.cook();
|
|
assert!(session.material_maps().is_empty());
|
|
execute(&mut session, "edit.undo", &json!({})).unwrap();
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
execute(&mut session, "file.newPackage", &json!({})).unwrap();
|
|
assert!(session.material_preview.channels.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn opening_material_graph_automatically_applies_its_outputs() {
|
|
let mut session = new_session();
|
|
session.preview_size = Some(16);
|
|
let red = source(&mut session, [0.8, 0.1, 0.1, 1.0]);
|
|
output(&mut session, red, 0);
|
|
execute(&mut session, "file.new", &json!({"template": "empty", "name": "Blue"})).unwrap();
|
|
let blue = source(&mut session, [0.1, 0.1, 0.8, 1.0]);
|
|
output(&mut session, blue, 0);
|
|
assert_eq!(color(&mut session, "baseColor"), [0.1, 0.1, 0.8, 1.0]);
|
|
execute(&mut session, "graph.open", &json!({"graph": 0})).unwrap();
|
|
assert!(session.material_maps().is_empty(), "stale results must not cross graph IDs");
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_assignments_are_atomic_including_scalar_instance_outputs() {
|
|
let mut session = new_session();
|
|
session.preview_size = Some(16);
|
|
let image = source(&mut session, [0.8, 0.1, 0.1, 1.0]);
|
|
execute(&mut session, "view.3d.assign", &json!({"node": image, "channel": "baseColor"})).unwrap();
|
|
let value = add(&mut session, "input_value", json!({}));
|
|
let value_output = output(&mut session, value, 0);
|
|
let mut graph = Graph::new("Values");
|
|
let input = graph.add_node("input_value", [0.0; 2]);
|
|
let out = graph.add_node("output", [100.0, 0.0]);
|
|
graph.node_mut(out).unwrap().params.insert("identifier".into(), Value::Text("value".into()));
|
|
graph.connect(input, "output", out, "input").unwrap();
|
|
session.pkg.graphs.push(graph);
|
|
let instance = instance(&mut session, "Values");
|
|
let before = session.material_preview.clone();
|
|
let history = session.history();
|
|
let package = session.pkg.clone();
|
|
for parameters in [
|
|
json!({"node": image, "channel": "unknown", "reset": true}),
|
|
json!({"node": image, "channel": "baseColor", "port": 999, "reset": true}),
|
|
json!({"node": image, "channel": "baseColor", "graph": 999, "reset": true}),
|
|
json!({"node": value, "channel": "baseColor", "reset": true}),
|
|
json!({"node": value_output, "channel": "baseColor", "reset": true}),
|
|
json!({"node": instance, "port": "value", "channel": "baseColor", "reset": true}),
|
|
] {
|
|
assert!(execute(&mut session, "view.3d.assign", ¶meters).is_err(), "{parameters}");
|
|
assert_eq!(session.material_preview, before);
|
|
assert_eq!(session.history(), history);
|
|
assert_eq!(session.pkg, package);
|
|
}
|
|
assert!(execute(&mut session, "view.3d.outputs", &json!({"graph": "Values", "reset": true})).is_err());
|
|
assert_eq!(session.material_preview, before);
|
|
}
|
|
|
|
#[test]
|
|
fn multiple_graph_channels_and_multi_output_instances_use_the_correct_ports() {
|
|
let mut package = Package::new("Test");
|
|
let mut graph = Graph::new("Colors");
|
|
graph.size = [4, 4];
|
|
graph.format = OutputFormat::F32;
|
|
for (name, color) in [("red", [0.8, 0.1, 0.1, 1.0]), ("blue", [0.1, 0.1, 0.8, 1.0])] {
|
|
let image = graph.add_node("uniform", [0.0; 2]);
|
|
graph.node_mut(image).unwrap().params.insert("color".into(), Value::Color(color));
|
|
let output = graph.add_node("output", [100.0, 0.0]);
|
|
graph.node_mut(output).unwrap().params.insert("identifier".into(), Value::Text(name.into()));
|
|
graph.connect(image, "output", output, "input").unwrap();
|
|
}
|
|
package.graphs.push(graph);
|
|
let mut instance_graph = Graph::new("Instances");
|
|
instance_graph.format = OutputFormat::F32;
|
|
package.graphs.push(instance_graph);
|
|
let mut session = Session::new(package);
|
|
execute(&mut session, "graph.open", &json!({"graph": 1})).unwrap();
|
|
let instance = instance(&mut session, "Colors");
|
|
execute(&mut session, "view.3d.assign", &json!({"node": instance, "port": "blue", "channel": "baseColor"})).unwrap();
|
|
|
|
assert_eq!(color(&mut session, "baseColor"), [0.1, 0.1, 0.8, 1.0]);
|
|
|
|
let key = session.material_key();
|
|
execute(&mut session, "view.3d.assign", &json!({"node": instance, "port": 0, "channel": "baseColor"})).unwrap();
|
|
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
assert_ne!(session.material_key(), key);
|
|
|
|
execute(&mut session, "view.3d.assign", &json!({"graph": "Colors", "node": 1, "channel": "emissive"})).unwrap();
|
|
|
|
assert_eq!(color(&mut session, "emissive"), [0.8, 0.1, 0.1, 1.0]);
|
|
assert_eq!(session.graph, 1);
|
|
}
|
|
|
|
#[test]
|
|
fn removing_an_earlier_graph_adjusts_sources_and_undo_restores_them() {
|
|
let mut session = new_session();
|
|
execute(&mut session, "file.new", &json!({"template": "empty"})).unwrap();
|
|
let red = source(&mut session, [0.8, 0.1, 0.1, 1.0]);
|
|
execute(&mut session, "view.3d.assign", &json!({"node": red, "channel": "baseColor"})).unwrap();
|
|
execute(&mut session, "graph.delete", &json!({"graph": 0})).unwrap();
|
|
assert_eq!(session.material_preview.channels[&MaterialChannel::BaseColor].graph, 0);
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
execute(&mut session, "edit.undo", &json!({})).unwrap();
|
|
assert_eq!(session.material_preview.channels[&MaterialChannel::BaseColor].graph, 1);
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
let before = session.material_key();
|
|
execute(&mut session, "graph.select", &json!({"ids": [red]})).unwrap();
|
|
execute(&mut session, "edit.delete", &json!({})).unwrap();
|
|
session.cook();
|
|
assert!(session.material_maps().is_empty());
|
|
assert_ne!(session.material_key(), before);
|
|
execute(&mut session, "edit.undo", &json!({})).unwrap();
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
}
|
|
|
|
#[test]
|
|
fn source_cycles_are_rejected_without_recursion() {
|
|
let mut package = Package::new("Cycle");
|
|
let mut graph = Graph::new("Cycle");
|
|
let instance = graph.add_node("graph_instance", [0.0; 2]);
|
|
graph.node_mut(instance).unwrap().params.insert("graph".into(), Value::Text("Cycle".into()));
|
|
let output = graph.add_node("output", [100.0, 0.0]);
|
|
graph.node_mut(output).unwrap().params.insert("identifier".into(), Value::Text("loop".into()));
|
|
graph.connect(instance, "loop", output, "input").unwrap();
|
|
package.graphs.push(graph);
|
|
let source = MaterialSource { graph: 0, node: instance, port: "loop".into() };
|
|
assert!(!source.is_image(&package));
|
|
assert!(MaterialPreview::for_graph(&package, 0).sources(&package).is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn diffuse_usage_previews_as_base_color_and_unknown_usages_stay_unassigned() {
|
|
use materialcraft_engine::core::ComponentUsage;
|
|
|
|
let mut session = new_session();
|
|
session.preview_size = Some(16);
|
|
let red = source(&mut session, [0.8, 0.1, 0.1, 1.0]);
|
|
let output = output(&mut session, red, ComponentUsage::index("diffuse"));
|
|
assert_eq!(color(&mut session, "baseColor"), [0.8, 0.1, 0.1, 1.0]);
|
|
for usage in [ComponentUsage::ANY_INDEX, u32::MAX, ComponentUsage::index("coatRoughness")] {
|
|
session.graph_mut().unwrap().node_mut(output).unwrap().params.insert("usage".into(), Value::Enum(usage));
|
|
assert!(session.material_maps().is_empty(), "usage {usage} must not become a different channel");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn extracted_graph_outputs_remain_unclassified() {
|
|
let mut session = new_session();
|
|
let uniform = source(&mut session, [0.8, 0.1, 0.1, 1.0]);
|
|
output(&mut session, uniform, 0);
|
|
execute(&mut session, "graph.select", &json!({"ids": [uniform]})).unwrap();
|
|
execute(&mut session, "graph.createFromSelection", &json!({"name": "Extracted"})).unwrap();
|
|
let (_, graph) = session.pkg.graph_by_name("Extracted").unwrap();
|
|
let output = graph.nodes.iter().find(|node| node.def == "output").unwrap();
|
|
assert_eq!(materialcraft_engine::eval::output_usage(output), "any");
|
|
}
|
|
|
|
#[test]
|
|
fn opening_a_graph_shows_its_outputs_only_while_the_preference_is_on() {
|
|
let mut session = new_session();
|
|
let shown = session.material_preview.clone();
|
|
session.view_outputs_on_open = false;
|
|
execute(&mut session, "file.new", &json!({"template": "pbr", "name": "Quiet"})).unwrap();
|
|
assert_eq!(session.material_preview, shown, "the 3D view keeps what it showed");
|
|
|
|
session.view_outputs_on_open = true;
|
|
execute(&mut session, "file.new", &json!({"template": "pbr", "name": "Shown"})).unwrap();
|
|
assert_eq!(session.material_preview.graph, Some(session.graph));
|
|
}
|
|
|
|
#[test]
|
|
fn opening_a_package_respects_the_output_preview_preference() {
|
|
let mut source = new_session();
|
|
execute(&mut source, "file.new", &json!({"template": "pbr"})).unwrap();
|
|
execute(&mut source, "graph.delete", &json!({"graph": 0})).unwrap();
|
|
let bytes = materialcraft_engine::file_cmds::save_bytes(&source).unwrap();
|
|
let mut destination = new_session();
|
|
destination.view_outputs_on_open = false;
|
|
|
|
materialcraft_engine::file_cmds::open_bytes(&mut destination, &bytes, None).unwrap();
|
|
|
|
assert_eq!(destination.material_preview.graph, None);
|
|
|
|
destination.view_outputs_on_open = true;
|
|
materialcraft_engine::file_cmds::open_bytes(&mut destination, &bytes, None).unwrap();
|
|
|
|
assert_eq!(destination.material_preview.graph, Some(0));
|
|
}
|
|
|
|
#[test]
|
|
fn reloading_a_package_respects_the_output_preview_preference() {
|
|
let directory = std::env::temp_dir().join(format!("materialcraft-reload-preview-{}", std::process::id()));
|
|
std::fs::create_dir(&directory).unwrap();
|
|
let mut session = new_session();
|
|
let path = directory.join("preview.sbs");
|
|
execute(&mut session, "file.saveAs", &json!({"path": path})).unwrap();
|
|
|
|
session.view_outputs_on_open = false;
|
|
execute(&mut session, "file.reload", &json!({})).unwrap();
|
|
let disabled = session.material_preview.clone();
|
|
session.view_outputs_on_open = true;
|
|
execute(&mut session, "file.reload", &json!({})).unwrap();
|
|
std::fs::remove_dir_all(directory).unwrap();
|
|
|
|
assert_eq!(disabled, MaterialPreview::default());
|
|
assert_eq!(session.material_preview.graph, Some(0));
|
|
}
|