mirror of
https://github.com/storytold/materialcraft.git
synced 2026-11-19 14:01:02 +01:00
273 lines
14 KiB
Rust
273 lines
14 KiB
Rust
use materialcraft_engine::{
|
|
FunctionGraphTarget, Session,
|
|
core::{FunctionGraph, NodeId, Value},
|
|
execute,
|
|
formats::sbs::{read_sbs, write_sbs},
|
|
new_session,
|
|
};
|
|
use serde_json::json;
|
|
|
|
fn add(session: &mut Session, definition: &str) -> NodeId {
|
|
NodeId(execute(session, "graph.node.add", &json!({"def": definition})).unwrap()["id"].as_u64().unwrap())
|
|
}
|
|
|
|
#[test]
|
|
fn value_inputs_feed_authored_processors_and_round_trip() {
|
|
let mut session = new_session();
|
|
let input = add(&mut session, "input_value");
|
|
execute(&mut session, "graph.node.param", &json!({"id": input.0, "param": "default", "value": 0.35})).unwrap();
|
|
let first =
|
|
NodeId(execute(&mut session, "graph.node.add", &json!({"def": "value_processor", "connectFrom": {"node": input.0}})).unwrap()["id"].as_u64().unwrap());
|
|
let second = add(&mut session, "value_processor");
|
|
execute(&mut session, "graph.connect", &json!({"from": input.0, "to": second.0, "toPort": "value1"})).unwrap();
|
|
|
|
assert_eq!(session.graph().unwrap().connections.len(), 2);
|
|
|
|
assert!(session.undo().is_some());
|
|
assert_eq!(session.graph().unwrap().connections.len(), 1);
|
|
assert_eq!(session.graph().unwrap().connections[0].to, first);
|
|
assert!(session.redo().is_some());
|
|
|
|
for node in [first, second] {
|
|
let target = FunctionGraphTarget::Parameter { node, parameter: "function".into() };
|
|
assert_eq!(target.current(&session).unwrap(), &FunctionGraph::default());
|
|
let mut function = FunctionGraph::default();
|
|
function.output = Some(function.add("get_float1", &[], Some(Value::Text("value1".into()))));
|
|
execute(&mut session, "graph.function.set", &json!({"target": target, "function": function})).unwrap();
|
|
}
|
|
|
|
session.cook();
|
|
for node in [first, second] {
|
|
assert_eq!(session.cooked.value(node, 0), Some(&Value::Float(0.35)));
|
|
}
|
|
|
|
let bytes = write_sbs(&session.pkg).unwrap();
|
|
let loaded = read_sbs(&bytes, "fan_out.sbs", &|_| None).unwrap();
|
|
assert!(loaded.warnings.is_empty(), "{:?}", loaded.warnings);
|
|
let mut loaded = Session::new(loaded.pkg);
|
|
loaded.cook();
|
|
assert_eq!(loaded.graph().unwrap().connections.len(), 2);
|
|
for node in loaded.graph().unwrap().nodes.iter().filter(|node| node.def == "value_processor") {
|
|
assert_eq!(loaded.cooked.value(node.id, 0), Some(&Value::Float(0.35)));
|
|
assert!(loaded.cooked.nodes[&node.id].error.is_none());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn reconnection_is_atomic_and_preserves_other_branches() {
|
|
let mut session = new_session();
|
|
let input = add(&mut session, "input_value");
|
|
let first = add(&mut session, "value_processor");
|
|
let second = add(&mut session, "value_processor");
|
|
let third = add(&mut session, "value_processor");
|
|
for target in [first, second] {
|
|
execute(&mut session, "graph.connect", &json!({"from": input.0, "to": target.0})).unwrap();
|
|
}
|
|
let original = session.pkg.clone();
|
|
|
|
let invalid = json!({"from": input.0, "to": third.0, "toPort": "input0", "detach": {"to": first.0, "toPort": "value1"}});
|
|
assert!(execute(&mut session, "graph.connect", &invalid).is_err());
|
|
assert_eq!(session.pkg, original);
|
|
|
|
execute(&mut session, "graph.connect", &json!({"from": input.0, "to": third.0, "detach": {"to": first.0, "toPort": "value1"}})).unwrap();
|
|
let graph = session.graph().unwrap();
|
|
assert!(graph.input_of(first, "value1").is_none());
|
|
assert_eq!(graph.input_of(second, "value1").unwrap().from, input);
|
|
assert_eq!(graph.input_of(third, "value1").unwrap().from, input);
|
|
assert!(session.undo().is_some());
|
|
assert_eq!(session.pkg, original);
|
|
|
|
execute(&mut session, "graph.connect", &json!({"from": first.0, "to": third.0})).unwrap();
|
|
let original = session.pkg.clone();
|
|
let cycle = json!({"from": first.0, "to": first.0, "detach": {"to": third.0, "toPort": "value1"}});
|
|
assert!(execute(&mut session, "graph.connect", &cycle).is_err());
|
|
assert_eq!(session.pkg, original);
|
|
}
|
|
|
|
#[test]
|
|
fn clipboard_variants_keep_internal_wires_and_optionally_keep_incoming_links() {
|
|
let mut session = new_session();
|
|
let input = add(&mut session, "input_value");
|
|
let first = add(&mut session, "value_processor");
|
|
let second = add(&mut session, "value_processor");
|
|
execute(&mut session, "graph.connect", &json!({"from": input.0, "to": first.0})).unwrap();
|
|
execute(&mut session, "graph.connect", &json!({"from": first.0, "to": second.0})).unwrap();
|
|
execute(&mut session, "edit.copy", &json!({"ids": [first.0, second.0]})).unwrap();
|
|
|
|
for (command, incoming) in [("edit.paste", true), ("edit.pasteWithoutLinks", false), ("edit.duplicate", true), ("edit.duplicateWithoutLinks", false)] {
|
|
session.selection = vec![first, second];
|
|
execute(&mut session, command, &json!({"snapToGrid": true})).unwrap();
|
|
let selected = &session.selection;
|
|
let graph = session.graph().unwrap();
|
|
assert_eq!(graph.connections.iter().filter(|wire| selected.contains(&wire.from) && selected.contains(&wire.to)).count(), 1);
|
|
assert_eq!(graph.connections.iter().filter(|wire| wire.from == input && selected.contains(&wire.to)).count(), usize::from(incoming));
|
|
assert!(graph.nodes.iter().filter(|node| selected.contains(&node.id)).all(|node| node.pos.iter().all(|coordinate| coordinate % 32.0 == 0.0)));
|
|
}
|
|
|
|
execute(&mut session, "file.new", &json!({"template": "empty"})).unwrap();
|
|
execute(&mut session, "edit.paste", &json!({})).unwrap();
|
|
assert_eq!(session.graph().unwrap().connections.len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn snapping_is_explicit_in_engine_commands_and_preserves_saved_positions() {
|
|
let mut session = new_session();
|
|
let result = execute(&mut session, "graph.node.add", &json!({"def": "uniform", "at": [19, -19], "snapToGrid": true})).unwrap();
|
|
let node = NodeId(result["id"].as_u64().unwrap());
|
|
assert_eq!(session.graph().unwrap().node(node).unwrap().pos, [32.0, -32.0]);
|
|
execute(&mut session, "graph.node.move", &json!({"by": [20, 20], "snapToGrid": true})).unwrap();
|
|
assert_eq!(session.graph().unwrap().node(node).unwrap().pos, [64.0, 0.0]);
|
|
execute(&mut session, "graph.node.move", &json!({"to": [19, -19], "snapToGrid": false})).unwrap();
|
|
assert_eq!(session.graph().unwrap().node(node).unwrap().pos, [19.0, -19.0]);
|
|
|
|
let loaded = read_sbs(&write_sbs(&session.pkg).unwrap(), "positions.sbs", &|_| None).unwrap();
|
|
assert_eq!(loaded.pkg.graphs[0].nodes[0].pos, [19.0, -19.0]);
|
|
}
|
|
|
|
#[test]
|
|
fn fx_map_starts_with_a_quadrant_and_grows_image_inputs_as_connected() {
|
|
use materialcraft_engine::core::PatternNodeKind;
|
|
|
|
let mut session = new_session();
|
|
session.preview_size = Some(16);
|
|
let source = add(&mut session, "uniform");
|
|
execute(&mut session, "graph.node.param", &json!({"id": source.0, "param": "color_mode", "value": false})).unwrap();
|
|
let owner = add(&mut session, "fx_map");
|
|
let Value::PatternGraph(pattern) = &session.graph().unwrap().node(owner).unwrap().params["pattern"] else { panic!("missing default pattern") };
|
|
assert_eq!(pattern.nodes.len(), 1);
|
|
assert_eq!(pattern.nodes[0].kind, PatternNodeKind::Quadrant);
|
|
assert_eq!(pattern.nodes[0].position, [0.0, 0.0]);
|
|
assert_eq!(pattern.root, Some(pattern.nodes[0].id));
|
|
assert_eq!(session.input_ports(owner), vec!["background", "pattern0"]);
|
|
|
|
let fresh = read_sbs(&write_sbs(&session.pkg).unwrap(), "fresh_pattern.sbs", &|_| None).unwrap();
|
|
assert!(fresh.warnings.is_empty(), "{:?}", fresh.warnings);
|
|
let loaded_pattern = fresh.pkg.graphs[0].nodes.iter().find(|node| node.def == "fx_map").unwrap();
|
|
let Value::PatternGraph(loaded_pattern) = &loaded_pattern.params["pattern"] else { panic!("missing saved root") };
|
|
assert_eq!(loaded_pattern.nodes.len(), 1);
|
|
assert_eq!(loaded_pattern.nodes[0].kind, PatternNodeKind::Quadrant);
|
|
assert_eq!(loaded_pattern.root, Some(loaded_pattern.nodes[0].id));
|
|
|
|
for index in 0..6 {
|
|
execute(&mut session, "graph.connect", &json!({"from": source.0, "to": owner.0, "toPort": format!("pattern{index}")})).unwrap();
|
|
assert_eq!(session.input_ports(owner).last(), Some(&format!("pattern{}", index + 1)));
|
|
}
|
|
let Value::PatternGraph(pattern) = &session.graph().unwrap().node(owner).unwrap().params["pattern"] else { panic!("missing pattern") };
|
|
|
|
let mut pattern = (**pattern).clone();
|
|
pattern.nodes[0].parameters.insert("patterntype".into(), Value::Int(1));
|
|
pattern.nodes[0].parameters.insert("imageindex".into(), Value::Int(6));
|
|
execute(&mut session, "graph.pattern.set", &json!({"id": owner.0, "pattern": pattern})).unwrap();
|
|
session.cook();
|
|
assert!(session.cooked.nodes[&owner].error.is_none(), "{:?}", session.cooked.nodes[&owner].error);
|
|
assert!((session.cooked.image(owner, 0).unwrap().mean()[0] - 0.5).abs() < 1e-5);
|
|
|
|
let bytes = write_sbs(&session.pkg).unwrap();
|
|
assert!(std::str::from_utf8(&bytes).unwrap().contains("<identifier v=\"input:5\"/>"));
|
|
let read = read_sbs(&bytes, "image_inputs.sbs", &|_| None).unwrap();
|
|
assert!(read.warnings.is_empty(), "{:?}", read.warnings);
|
|
let mut loaded = Session::new(read.pkg);
|
|
loaded.preview_size = Some(16);
|
|
let loaded_owner = loaded.graph().unwrap().nodes.iter().find(|node| node.def == "fx_map").unwrap().id;
|
|
assert_eq!(loaded.input_ports(loaded_owner), session.input_ports(owner));
|
|
loaded.cook();
|
|
assert!((loaded.cooked.image(loaded_owner, 0).unwrap().mean()[0] - 0.5).abs() < 1e-5);
|
|
|
|
execute(&mut session, "graph.disconnect", &json!({"to": owner.0, "toPort": "pattern5"})).unwrap();
|
|
assert_eq!(session.input_ports(owner).last().map(String::as_str), Some("pattern5"));
|
|
assert!(session.undo().is_some());
|
|
assert_eq!(session.input_ports(owner).last().map(String::as_str), Some("pattern6"));
|
|
let before = session.pkg.clone();
|
|
assert!(execute(&mut session, "graph.connect", &json!({"from": source.0, "to": owner.0, "toPort": "pattern999999999"})).is_err());
|
|
assert_eq!(session.pkg, before);
|
|
}
|
|
|
|
#[test]
|
|
fn terminal_outputs_cook_and_round_trip_without_source_pins() {
|
|
let mut session = new_session();
|
|
session.preview_size = Some(16);
|
|
let source = add(&mut session, "uniform");
|
|
let output = add(&mut session, "output");
|
|
execute(&mut session, "graph.connect", &json!({"from": source.0, "to": output.0})).unwrap();
|
|
assert_eq!(session.input_ports(output), vec!["input"]);
|
|
assert!(session.output_ports(output).is_empty());
|
|
let before = session.pkg.clone();
|
|
assert!(execute(&mut session, "graph.connect", &json!({"from": output.0, "to": source.0})).is_err());
|
|
assert_eq!(session.pkg, before);
|
|
|
|
let read = read_sbs(&write_sbs(&session.pkg).unwrap(), "terminal_output.sbs", &|_| None).unwrap();
|
|
assert!(read.warnings.is_empty(), "{:?}", read.warnings);
|
|
let mut loaded = Session::new(read.pkg);
|
|
loaded.preview_size = Some(16);
|
|
loaded.cook();
|
|
let output = loaded.graph().unwrap().nodes.iter().find(|node| node.def == "output").unwrap().id;
|
|
assert!(loaded.output_ports(output).is_empty());
|
|
assert!(loaded.cooked.nodes[&output].error.is_none());
|
|
assert!((loaded.cooked.image(output, 0).unwrap().mean()[0] - 0.5).abs() < 1e-5);
|
|
execute(&mut loaded, "view.2d", &json!({"node": output.0})).unwrap();
|
|
assert_eq!(loaded.view2d_image().unwrap().0, output);
|
|
}
|
|
|
|
#[test]
|
|
fn processors_sample_dynamic_image_inputs_after_sbs_round_trip() {
|
|
use materialcraft_engine::core::FunctionGraph;
|
|
|
|
for definition in ["pixel_processor", "value_processor"] {
|
|
let mut session = new_session();
|
|
session.preview_size = Some(16);
|
|
let source = add(&mut session, "uniform");
|
|
let processor = add(&mut session, definition);
|
|
for index in 0..6 {
|
|
execute(&mut session, "graph.connect", &json!({"from": source.0, "to": processor.0, "toPort": format!("input{index}")})).unwrap();
|
|
assert_eq!(session.input_ports(processor).last(), Some(&format!("input{}", index + 1)));
|
|
}
|
|
|
|
let mut function = FunctionGraph::default();
|
|
let position = function.add_constant(Value::Float2([0.5, 0.5]));
|
|
function.output = Some(function.add("samplelum", &[position], Some(Value::Int2([5, 1]))));
|
|
execute(&mut session, "graph.node.param", &json!({"id": processor.0, "param": "function", "value": Value::Function(Box::new(function))})).unwrap();
|
|
let bytes = write_sbs(&session.pkg).unwrap();
|
|
assert!(std::str::from_utf8(&bytes).unwrap().contains("<identifier v=\"input:5\"/>"));
|
|
let read = read_sbs(&bytes, "processor_images.sbs", &|_| None).unwrap();
|
|
assert!(read.warnings.is_empty(), "{:?}", read.warnings);
|
|
let mut loaded = Session::new(read.pkg);
|
|
loaded.preview_size = Some(16);
|
|
loaded.cook();
|
|
let processor = loaded.graph().unwrap().nodes.iter().find(|node| node.def == definition).unwrap().id;
|
|
assert_eq!(loaded.input_ports(processor).last().map(String::as_str), Some("input6"));
|
|
assert!(loaded.cooked.nodes[&processor].error.is_none(), "{:?}", loaded.cooked.nodes[&processor].error);
|
|
if definition == "value_processor" {
|
|
assert_eq!(loaded.cooked.value(processor, 0), Some(&Value::Float(0.5)));
|
|
} else {
|
|
assert!((loaded.cooked.image(processor, 0).unwrap().mean()[0] - 0.5).abs() < 1e-5);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn background_pins_preserve_connected_images_through_sbs() {
|
|
let mut session = new_session();
|
|
session.preview_size = Some(16);
|
|
let source = add(&mut session, "uniform");
|
|
for definition in ["text", "svg"] {
|
|
let target = add(&mut session, definition);
|
|
if definition == "text" {
|
|
execute(&mut session, "graph.node.param", &json!({"id": target.0, "param": "text", "value": ""})).unwrap();
|
|
}
|
|
execute(&mut session, "graph.connect", &json!({"from": source.0, "to": target.0, "toPort": "background"})).unwrap();
|
|
}
|
|
|
|
let read = read_sbs(&write_sbs(&session.pkg).unwrap(), "backgrounds.sbs", &|_| None).unwrap();
|
|
assert!(read.warnings.is_empty(), "{:?}", read.warnings);
|
|
let mut loaded = Session::new(read.pkg);
|
|
loaded.preview_size = Some(16);
|
|
loaded.cook();
|
|
for node in loaded.graph().unwrap().nodes.iter().filter(|node| matches!(node.def.as_str(), "text" | "svg")) {
|
|
assert_eq!(loaded.input_ports(node.id), vec!["background"]);
|
|
let image = loaded.cooked.image(node.id, 0).unwrap();
|
|
assert_eq!(image.is_gray(), node.def == "text");
|
|
assert!((image.mean()[0] - 0.5).abs() < 1e-5);
|
|
assert!(loaded.cooked.nodes[&node.id].error.is_none());
|
|
}
|
|
}
|