Files

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());
}
}