use materialcraft_engine::{ FunctionGraphTarget, Session, core::{FunctionGraph, Graph, NodeId, Package, Value}, execute, file_cmds, nodes::function::{self, EvaluationContext, EvaluationState}, }; use serde_json::json; use std::collections::BTreeMap; fn session() -> Session { let mut package = Package::new("Library integration"); let mut graph = Graph::new("Caller"); graph.function = Some(FunctionGraph::default()); package.graphs.push(graph); Session::new(package) } fn value(function: &FunctionGraph) -> Value { let context = EvaluationContext { scope: Default::default(), position: [0.5; 2], size: [16.0; 2], images: &[], tile: true, variables: &BTreeMap::new() }; function::compile(function, 0).unwrap().evaluate(&context, &mut EvaluationState::default()).unwrap() } #[test] fn library_instances_are_discoverable_undoable_and_portable() { let mut session = session(); let entries = execute(&mut session, "library.functions", &json!({})).unwrap(); assert_eq!(entries.as_array().unwrap().len(), 171); let pi = entries.as_array().unwrap().iter().find(|entry| entry["graph"] == "Functions/Math/Pi").unwrap(); assert_eq!(pi["outputs"][0]["type_code"], 256); let node = execute(&mut session, "library.function.add", &json!({"graph": "Functions/Math/Pi", "at": [64.0, 128.0]})).unwrap()["id"].as_u64().unwrap(); execute(&mut session, "graph.function.edit", &json!({"edit": {"action": "output", "id": node}})).unwrap(); assert_eq!(value(session.graph().unwrap().function.as_ref().unwrap()), Value::Float(std::f32::consts::PI)); execute(&mut session, "edit.undo", &json!({})).unwrap(); execute(&mut session, "edit.undo", &json!({})).unwrap(); assert!(session.graph().unwrap().function.as_ref().unwrap().nodes.is_empty()); execute(&mut session, "edit.redo", &json!({})).unwrap(); execute(&mut session, "edit.redo", &json!({})).unwrap(); let bytes = file_cmds::save_bytes(&session).unwrap(); let xml = std::str::from_utf8(&bytes).unwrap(); assert!(xml.contains("sbs://functions.sbs")); assert!(!xml.contains("assets/sbs")); assert!(!xml.contains(" = entries.iter().filter(|entry| entry["missing"] != false).map(|entry| &entry["graph"]).collect(); assert_eq!(entries.len(), 171); assert!(missing.is_empty(), "missing bundled functions: {missing:?}"); for entry in entries { session.graph_mut().unwrap().function = Some(FunctionGraph::default()); session.reset_history(); let identifier = execute(&mut session, "library.function.add", &json!({"graph": entry["graph"]})).unwrap()["id"].as_u64().unwrap(); execute(&mut session, "graph.function.edit", &json!({"edit": {"action": "output", "id": identifier}})).unwrap(); let function = session.graph().unwrap().function.as_ref().unwrap(); assert!(matches!(function.nodes[0].source, Some(Ok(_))), "{}", entry["graph"]); function::compile(function, 0).unwrap_or_else(|error| panic!("{}: {error}", entry["graph"])); } } #[test] fn parity_library_instances_evaluate_connected_inputs_after_reopen() { for (name, expected, default) in [ ("EvenCount", Value::Float(3.0), Value::Float(0.0)), ("OddCount", Value::Float(2.0), Value::Float(0.0)), ("ParityTest", Value::Bool(true), Value::Bool(true)), ] { let mut session = session(); let entries = execute(&mut session, "library.functions", &json!({"filter": name})).unwrap(); assert_eq!(entries[0]["missing"], false, "{name} must be usable from the Library"); let instance = execute(&mut session, "library.function.add", &json!({"graph": format!("Functions/Math/Parity/{name}")})).unwrap()["id"].as_u64().unwrap(); execute(&mut session, "graph.function.edit", &json!({"edit": {"action": "output", "id": instance}})).unwrap(); assert_eq!(value(session.graph().unwrap().function.as_ref().unwrap()), default); let constant = execute(&mut session, "graph.function.edit", &json!({"edit": {"action": "add", "operation": "const_float1", "at": [-200.0, 0.0]}})) .unwrap()["id"] .as_u64() .unwrap(); execute(&mut session, "graph.function.edit", &json!({"edit": {"action": "value", "id": constant, "value": Value::Float(5.75)}})).unwrap(); execute(&mut session, "graph.function.edit", &json!({"edit": {"action": "connect", "from": constant, "to": instance, "input": 0}})).unwrap(); let bytes = file_cmds::save_bytes(&session).unwrap(); let mut reopened = self::session(); file_cmds::open_bytes(&mut reopened, &bytes, Some("parity-caller.sbs".into())).unwrap(); assert_eq!(value(session.graph().unwrap().function.as_ref().unwrap()), expected, "{name}"); assert_eq!(value(reopened.graph().unwrap().function.as_ref().unwrap()), expected, "reopened {name}"); } } #[test] fn missing_library_implementations_remain_instances_with_typed_ports() { let mut session = session(); let mut missing = session.pkg.dependencies["sbs://functions.sbs"].graph_by_name("Functions/Random/GlobalRandom").unwrap().1.clone(); missing.name = "MissingFunction".into(); missing.folder = "Functions/Test".into(); missing.function = Some(FunctionGraph::default()); let mut package = Package::new("Missing library"); package.graphs.push(missing); session.pkg.dependencies.insert("sbs://missing-functions.sbs".into(), std::sync::Arc::new(package)); let entries = execute(&mut session, "library.functions", &json!({"filter": "MissingFunction"})).unwrap(); assert_eq!(entries[0]["missing"], true); assert_eq!(entries[0]["inputs"].as_array().unwrap().len(), 2); let id = execute(&mut session, "library.function.add", &json!({"package": "sbs://missing-functions.sbs", "graph": "Functions/Test/MissingFunction"})) .unwrap()["id"] .as_u64() .unwrap(); let node = session.graph().unwrap().function.as_ref().unwrap().node(id as u32).unwrap(); assert!(matches!(node.source, Some(Err(_)))); assert_eq!(node.instance.as_ref().unwrap().inputs.len(), 2); let saved = file_cmds::save_bytes(&session).unwrap(); let mut reopened = self::session(); file_cmds::open_bytes(&mut reopened, &saved, None).unwrap(); assert!(matches!(reopened.graph().unwrap().function.as_ref().unwrap().nodes[0].source, Some(Err(_)))); } #[test] fn function_library_accepts_processor_canvases_and_rejects_material_canvases() { let mut package = Package::new("Processors"); package.graphs.push(Graph::new("Material")); let mut session = Session::new(package); assert!(execute(&mut session, "library.function.add", &json!({"graph": "Functions/Math/Pi"})).is_err()); for kind in ["pixel_processor", "value_processor"] { let owner = execute(&mut session, "graph.node.add", &json!({"def": kind})).unwrap()["id"].as_u64().unwrap(); if kind == "pixel_processor" { execute(&mut session, "graph.node.param", &json!({"id": owner, "param": "color_mode", "value": false})).unwrap(); } let target = FunctionGraphTarget::Parameter { node: NodeId(owner), parameter: "function".into() }; let node = execute(&mut session, "library.function.add", &json!({"graph": "Functions/Math/Pi", "function": target})).unwrap()["id"].as_u64().unwrap(); execute(&mut session, "graph.function.edit", &json!({"target": target, "edit": {"action": "output", "id": node}})).unwrap(); assert_eq!(value(target.current(&session).unwrap()), Value::Float(std::f32::consts::PI)); } } #[test] fn library_aliases_open_as_references_and_require_a_local_save_path() { let mut session = session(); file_cmds::open_file(&mut session, "sbs://functions.sbs").unwrap(); assert_eq!(session.pkg.graphs.len(), 171); let error = execute(&mut session, "file.save", &json!({})).unwrap_err().to_string(); assert!(error.contains("local .sbs"), "{error}"); } #[test] fn renaming_a_nested_source_updates_its_local_reference() { let mut session = session(); session.pkg.graphs[0].folder = "Functions/Local".into(); session.pkg.graphs[0].function = Some(FunctionGraph::constant(Value::Float(0.75))); execute(&mut session, "file.new", &json!({"kind": "function", "name": "Consumer"})).unwrap(); execute(&mut session, "graph.instance.add", &json!({"document": 0, "graph": "Functions/Local/Caller"})).unwrap(); execute(&mut session, "graph.rename", &json!({"graph": 0, "name": "Renamed"})).unwrap(); let node = &session.graph().unwrap().function.as_ref().unwrap().nodes[0]; assert_eq!(node.instance.as_ref().unwrap().graph, "Functions/Local/Renamed"); assert!(matches!(node.source, Some(Ok(_)))); } #[test] #[ignore = "local interoperability input; set MC_FUNCTIONS_SBS to an external package"] fn supplied_functions_evaluate_before_and_after_save() { let path = std::env::var("MC_FUNCTIONS_SBS").unwrap(); let read = materialcraft_engine::formats::sbs::read_sbs(&std::fs::read(&path).unwrap(), &path, &|_| None).unwrap(); let before = Session::new(read.pkg); let bytes = materialcraft_engine::formats::sbs::write_sbs(&before.pkg).unwrap(); let after = Session::new(materialcraft_engine::formats::sbs::read_sbs(&bytes, "saved.sbs", &|_| None).unwrap().pkg); let bundled = Session::new( materialcraft_engine::formats::sbs::read_sbs(include_bytes!("../../../../assets/sbs/functions.sbs"), "functions.sbs", &|_| None).unwrap().pkg, ); let mut failures = Vec::new(); let mut defaults = 0; for graph in &before.pkg.graphs { let function = graph.function.as_ref().unwrap(); for node in function.nodes.iter().filter(|node| node.instance.is_some()) { assert!(matches!(node.source, Some(Ok(_))), "{}: unresolved instance {}", graph.sbs_path(), node.id); } let source = function::compile(function, 0).unwrap(); let saved = after.pkg.graph_by_name(&graph.sbs_path()).unwrap().1; let saved = function::compile(saved.function.as_ref().unwrap(), 0).unwrap(); let converted = bundled.pkg.graph_by_name(&graph.sbs_path()).unwrap().1; let converted = function::compile(converted.function.as_ref().unwrap(), 0).unwrap(); let mut errors = Vec::new(); for profile in 0..4 { let mut variables: BTreeMap<_, _> = graph .exposed .iter() .enumerate() .map(|(index, parameter)| { let scalar = (profile as f32 + index as f32) * 0.25; let value = if profile == 0 { parameter.default.clone() } else { match parameter.default { Value::Float(_) => Value::Float(scalar), Value::Float2(_) => Value::Float2([scalar, scalar * 2.0]), Value::Float3(_) => Value::Float3([scalar, scalar * 2.0, scalar * 3.0]), Value::Float4(_) => Value::Float4([scalar, scalar * 2.0, scalar * 3.0, scalar * 4.0]), Value::Int(_) => Value::Int(profile), Value::Int2(_) => Value::Int2([profile, profile + 1]), Value::Int3(_) => Value::Int3([profile, profile + 1, profile + 2]), Value::Int4(_) => Value::Int4([profile, profile + 1, profile + 2, profile + 3]), Value::Bool(_) => Value::Bool(profile % 2 != 0), _ => parameter.default.clone(), } }; (parameter.id.clone(), value) }) .collect(); // This hidden helper requires a render region supplied by its caller if graph.name == "compute_total_number" { variables.insert("render_region".into(), Value::Float4([-0.5, 0.5, -0.5, 0.5])); } let context = EvaluationContext { scope: Default::default(), position: [0.5; 2], size: [256.0, 128.0], images: &[], tile: true, variables: &variables }; match source.evaluate(&context, &mut EvaluationState::default()) { Ok(expected) => { assert_eq!(saved.evaluate(&context, &mut EvaluationState::default()).unwrap(), expected, "{}", graph.sbs_path()); assert_eq!(converted.evaluate(&context, &mut EvaluationState::default()).unwrap(), expected, "converted {}", graph.sbs_path()); defaults += usize::from(profile == 0); errors.clear(); break; } Err(error) => errors.push(error), } } if !errors.is_empty() { failures.push(format!("{}: {}", graph.sbs_path(), errors.join("; "))); } } eprintln!( "Evaluated {} of {} supplied functions before/after save and in the converted library; {defaults} used their declared defaults", before.pkg.graphs.len() - failures.len(), before.pkg.graphs.len() ); assert!(failures.is_empty(), "{}", failures.join("\n")); }