use materialcraft_engine::{ Session, atomic_sample, core::{FunctionGraph, Graph, Package, Resource, ResourceBytes, Value, ValueType}, execute, formats::sbs::{read_sbs, write_sbs}, }; use serde_json::json; #[test] fn new_processors_start_with_empty_functions_and_preserve_them_in_sbs() { use materialcraft_engine::{FunctionGraphTarget, core::NodeId}; for definition in ["pixel_processor", "value_processor"] { let mut session = materialcraft_engine::new_session(); let node = NodeId(execute(&mut session, "graph.node.add", &json!({"def": definition})).unwrap()["id"].as_u64().unwrap()); let target = FunctionGraphTarget::Parameter { node, parameter: "function".into() }; assert_eq!(target.current(&session).unwrap(), &FunctionGraph::default(), "{definition}"); session.preview_size = Some(16); session.cook(); assert_eq!(session.cooked.nodes[&node].error.as_deref(), Some("function has no result node"), "{definition}"); let loaded = read_sbs(&write_sbs(&session.pkg).unwrap(), "empty_processors.sbs", &|_| None).unwrap(); assert!(loaded.warnings.is_empty(), "{:?}", loaded.warnings); let session = Session::new(loaded.pkg); let node = session.graph().unwrap().nodes[0].id; let target = FunctionGraphTarget::Parameter { node, parameter: "function".into() }; assert_eq!(target.current(&session).unwrap(), &FunctionGraph::default(), "{definition}"); } } #[test] fn new_fx_map_starts_with_a_quadrant_output() { use materialcraft_engine::core::{NodeId, PatternGraph, PatternNodeKind}; let mut session = materialcraft_engine::new_session(); let node = NodeId(execute(&mut session, "graph.node.add", &json!({"def": "fx_map"})).unwrap()["id"].as_u64().unwrap()); assert_eq!( session.graph().unwrap().node(node).unwrap().params.get("pattern"), Some(&Value::PatternGraph(Box::new(PatternGraph::with_root(PatternNodeKind::Quadrant)))) ); } #[test] fn atomic_sample_round_trips_through_native_fields_and_cooks_identically() { let mut original = Session::new(atomic_sample().unwrap()); original.preview_size = Some(64); original.cook(); for result in original.cooked.nodes.values() { assert!(result.error.is_none(), "{:?}", result.error); } let bytes = write_sbs(&original.pkg).unwrap(); let text = std::str::from_utf8(&bytes).unwrap(); for required in ["", "", "", "", ""] { assert!(text.contains(required), "missing {required}"); } for forbidden in ["materialcraft-package", "materialcraft://", ""] { assert!(!text.contains(forbidden)); } let read = read_sbs(&bytes, "atomic_sample.sbs", &|_| None).unwrap(); assert!(read.warnings.is_empty(), "{:?}", read.warnings); let mut loaded = Session::new(read.pkg); loaded.preview_size = Some(64); loaded.cook(); assert_eq!(original.graph().unwrap().connections.len(), loaded.graph().unwrap().connections.len()); for (before, after) in original.graph().unwrap().nodes.iter().zip(&loaded.graph().unwrap().nodes) { assert_eq!(before.def, after.def); let result = &loaded.cooked.nodes[&after.id]; assert!(result.error.is_none(), "{}: {:?}", after.def, result.error); match (original.cooked.image(before.id, 0), loaded.cooked.image(after.id, 0)) { (Some(before), Some(after)) => { assert_eq!((before.w, before.h, before.kind), (after.w, after.h, after.kind)); let error = before.data.iter().zip(after.data.iter()).map(|(a, b)| (a - b).abs()).fold(0.0_f32, f32::max); assert!(error < 1e-5, "pixel error {error}"); } (None, None) => assert_eq!(original.cooked.value(before.id, 0), loaded.cooked.value(after.id, 0)), _ => panic!("output kind changed for {}", before.def), } } } #[test] fn every_catalog_entry_has_a_native_sbs_representation() { let mut package = Package::new("Primitives"); let mut graph = Graph::new("Primitives"); for definition in materialcraft_engine::nodes::catalog() { graph.add_node(definition.id, [0.0, graph.nodes.len() as f32 * 180.0]); } package.graphs.push(graph); let bytes = write_sbs(&package).unwrap(); let loaded = read_sbs(&bytes, "primitives.sbs", &|_| None).unwrap(); assert!(loaded.warnings.is_empty(), "{:?}", loaded.warnings); assert_eq!(loaded.pkg.graphs[0].nodes.len(), 29); for (before, after) in package.graphs[0].nodes.iter().zip(&loaded.pkg.graphs[0].nodes) { assert_eq!(before.def, after.def); } } #[test] fn native_value_types_survive_processors_and_sbs() { let mut package = Package::new("Values"); let mut graph = Graph::new("Values"); let values = [ Value::Int(16_777_217), Value::Int2([i32::MIN, i32::MAX]), Value::Int3([1, 2, 3]), Value::Int4([4, 3, 2, 1]), Value::Float(0.25), Value::Float2([0.25; 2]), Value::Float3([0.25; 3]), Value::Float4([0.25; 4]), Value::Bool(true), Value::Text("sample & ".into()), ]; for value in &values { let node = graph.add_node("value_processor", [0.0; 2]); graph.node_mut(node).unwrap().params.insert("function".into(), Value::Function(Box::new(FunctionGraph::constant(value.clone())))); } package.graphs.push(graph); let read = read_sbs(&write_sbs(&package).unwrap(), "values.sbs", &|_| None).unwrap(); assert!(read.warnings.is_empty(), "{:?}", read.warnings); let mut session = Session::new(read.pkg); session.preview_size = Some(16); session.cook(); for (node, expected) in session.graph().unwrap().nodes.iter().zip(values) { assert_eq!(session.cooked.value(node.id, 0), Some(&expected), "{:?}", session.cooked.nodes[&node.id].error); } } #[test] fn value_wiring_checks_types_and_edits_undo() { let mut session = Session::new(atomic_sample().unwrap()); let graph = session.graph().unwrap(); let input = graph.nodes.iter().find(|node| node.def == "input_value").unwrap().id; let processor = graph.nodes.iter().find(|node| node.def == "value_processor").unwrap().id; let blur = graph.nodes.iter().find(|node| node.def == "blur").unwrap().id; assert!(execute(&mut session, "graph.connect", &json!({"from": input.0, "to": blur.0})).is_err()); execute(&mut session, "graph.node.value_input", &json!({"id": processor.0, "name": "integer", "type": "Integer"})).unwrap(); assert!(execute(&mut session, "graph.connect", &json!({"from": input.0, "to": processor.0, "toPort": "integer"})).is_err()); assert_eq!(session.graph().unwrap().node(processor).unwrap().input_values.get("integer"), Some(&ValueType::Integer)); execute(&mut session, "edit.undo", &json!({})).unwrap(); assert!(!session.graph().unwrap().node(processor).unwrap().input_values.contains_key("integer")); } #[test] fn svg_resource_is_embedded_and_rendered_after_reopening() { let svg = br#""#; let mut package = Package::new("Vector"); package.resources.push(Resource::new("circle", "circle.svg", ResourceBytes::new(svg.to_vec()))); let mut graph = Graph::new("Vector"); graph.size = [5, 5]; let node = graph.add_node("svg", [0.0; 2]); graph.node_mut(node).unwrap().params.insert("resource".into(), Value::Text("circle".into())); package.graphs.push(graph); let read = read_sbs(&write_sbs(&package).unwrap(), "vector.sbs", &|_| None).unwrap(); assert!(read.warnings.is_empty(), "{:?}", read.warnings); assert_eq!(read.pkg.resources[0].bytes.as_slice(), svg); let mut session = Session::new(read.pkg); session.cook(); let node = session.graph().unwrap().nodes[0].id; assert!(session.cooked.nodes[&node].error.is_none()); let image = session.cooked.image(node, 0).unwrap(); assert!(image.get(16, 16, false)[0] > 0.99); assert_eq!(image.get(0, 0, false)[3], 0.0); } #[test] fn exposed_parameter_binding_remains_live_after_saving() { let mut session = Session::new(atomic_sample().unwrap()); let blur = session.graph().unwrap().nodes.iter().find(|node| node.def == "blur").unwrap().id; execute(&mut session, "graph.exposed.add", &json!({"id": "radius", "bind": {"node": blur.0, "param": "intensity"}})).unwrap(); execute(&mut session, "graph.exposed.set", &json!({"id": "radius", "value": 4.0})).unwrap(); let bytes = write_sbs(&session.pkg).unwrap(); let loaded = read_sbs(&bytes, "exposed.sbs", &|_| None).unwrap(); assert!(loaded.warnings.is_empty(), "{:?}", loaded.warnings); let mut loaded = Session::new(loaded.pkg); loaded.preview_size = Some(32); loaded.cook(); let before = loaded.cooked.image(blur, 0).unwrap().data.clone(); execute(&mut loaded, "graph.exposed.set", &json!({"id": "radius", "value": 0.0})).unwrap(); loaded.cook(); assert_ne!(before, loaded.cooked.image(blur, 0).unwrap().data); } #[test] fn levels_preserve_independent_rgba_parameters_in_sbs() { let mut session = Session::new(atomic_sample().unwrap()); let input = execute(&mut session, "graph.node.add", &json!({"def": "uniform", "params": {"color": {"t": "color", "v": [0.5, 0.5, 0.5, 0.5]}}})).unwrap()["id"] .as_u64() .unwrap(); let levels = execute(&mut session, "graph.node.add", &json!({"def": "levels", "connectFrom": {"node": input}, "params": {"out_high": [1.0, 0.8, 0.6, 0.4]}})) .unwrap()["id"] .as_u64() .unwrap(); let loaded = read_sbs(&write_sbs(&session.pkg).unwrap(), "levels.sbs", &|_| None).unwrap(); assert!(loaded.warnings.is_empty(), "{:?}", loaded.warnings); let mut session = Session::new(loaded.pkg); session.preview_size = Some(16); session.cook(); let pixel = session.cooked.image(materialcraft_engine::core::NodeId(levels), 0).unwrap().get(0, 0, false); for (actual, expected) in pixel.into_iter().zip([0.5, 0.4, 0.3, 0.2]) { assert!((actual - expected).abs() < 1e-5, "{pixel:?}"); } } #[test] fn selected_node_graph_is_resolved_without_changing_the_document() { let mut session = materialcraft_engine::new_session(); assert!(execute(&mut session, "graph.node.edit", &json!({})).is_err()); for (definition, kind, parameter) in [("fx_map", "pattern", "pattern"), ("pixel_processor", "function", "function"), ("value_processor", "function", "function")] { let node = execute(&mut session, "graph.node.add", &json!({"def": definition})).unwrap()["id"].as_u64().unwrap(); let original = session.pkg.clone(); let history = session.history(); assert_eq!(execute(&mut session, "graph.node.edit", &json!({})).unwrap(), json!({"kind": kind, "node": node, "parameter": parameter})); assert_eq!(session.pkg, original); assert_eq!(session.history(), history); } execute(&mut session, "graph.node.add", &json!({"def": "uniform"})).unwrap(); assert!(execute(&mut session, "graph.node.edit", &json!({})).is_err()); 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("Child".into())); session.selection = vec![node]; assert!(execute(&mut session, "graph.node.edit", &json!({})).is_err()); session.pkg.graphs.push(materialcraft_engine::core::Graph::new("Child")); let original = session.pkg.clone(); let history = session.history(); assert_eq!(execute(&mut session, "graph.node.edit", &json!({})).unwrap(), json!({"kind": "graph", "node": node, "graph": 1, "document": 0, "path": null})); assert_eq!(session.pkg, original); assert_eq!(session.history(), history); }