use materialcraft_engine::{ Session, core::{FunctionGraph, NodeId, Value}, execute, formats, new_session, }; use serde_json::{Value as Json, json}; fn command(session: &mut Session, name: &str, parameters: Json) -> Json { execute(session, name, ¶meters).unwrap() } fn node(session: &mut Session, definition: &str) -> NodeId { NodeId(command(session, "graph.node.add", json!({"def": definition}))["id"].as_u64().unwrap()) } #[test] fn output_size_function_controls_resolution_and_survives_sbs() { let mut session = new_session(); session.preview_size = None; command(&mut session, "graph.size", json!({"width": 64, "height": 64})); let owner = node(&mut session, "uniform"); let function = FunctionGraph::constant(Value::Int2([1, -1])); command(&mut session, "graph.node.function", json!({"id": owner, "base": true, "param": "outputsize", "function": function})); let cooked = session.cook(); let image = cooked.image(owner, 0).unwrap(); assert_eq!((image.w, image.h), (128, 32)); assert!(cooked.nodes[&owner].error.is_none()); let bytes = formats::sbs::write_sbs(&session.pkg).unwrap(); let loaded = formats::sbs::read_sbs(&bytes, "parameter-functions.sbs", &|_| None).unwrap(); assert!(loaded.warnings.is_empty(), "{:?}", loaded.warnings); let mut reopened = Session::new(loaded.pkg); reopened.preview_size = None; let owner = reopened.graph().unwrap().nodes.iter().find(|node| node.def == "uniform").unwrap().id; let cooked = reopened.cook(); let image = cooked.image(owner, 0).unwrap(); assert_eq!((image.w, image.h), (128, 32)); } #[test] fn empty_creation_has_no_output_and_constant_creation_uses_the_current_value() { let mut session = new_session(); let owner = node(&mut session, "blur"); command(&mut session, "graph.node.param", json!({"id": owner, "param": "intensity", "value": 7.0})); command(&mut session, "graph.node.function", json!({"id": owner, "param": "intensity", "mode": "empty"})); let function = &session.graph().unwrap().node(owner).unwrap().functions["intensity"]; assert!(function.nodes.is_empty()); assert_eq!(function.output, None); command(&mut session, "edit.undo", json!({})); command(&mut session, "graph.node.function", json!({"id": owner, "param": "intensity", "mode": "constant"})); let function = &session.graph().unwrap().node(owner).unwrap().functions["intensity"]; assert_eq!(function.nodes.len(), 1); assert_eq!(function.nodes[0].value, Some(Value::Float(7.0))); assert_eq!(function.output, Some(function.nodes[0].id)); } #[test] fn exposed_parameters_are_editable_get_functions() { let mut session = new_session(); let owner = node(&mut session, "blend"); command(&mut session, "graph.exposed.add", json!({"id": "amount", "bind": {"node": owner, "param": "opacity"}})); let function = &session.graph().unwrap().node(owner).unwrap().functions["opacity"]; let output = function.node(function.output.unwrap()).unwrap(); assert_eq!(output.op, "get_float1"); assert_eq!(output.value, Some(Value::Text("amount".into()))); } #[test] fn native_dynamic_output_size_is_not_discarded_on_load() { let xml = br#" "#; let loaded = formats::sbs::read_sbs(xml, "original.sbs", &|_| None).unwrap(); let mut session = Session::new(loaded.pkg); session.preview_size = None; let owner = session.graph().unwrap().nodes[0].id; let cooked = session.cook(); let image = cooked.image(owner, 0).unwrap(); assert_eq!((image.w, image.h), (64, 32)); } #[test] fn inherited_size_functions_use_nominal_input_size_before_preview_capping() { use materialcraft_engine::core::{BaseParameter, ValueType}; let mut session = new_session(); session.preview_size = Some(16); command(&mut session, "graph.size", json!({"width": 64, "height": 64})); let source = node(&mut session, "uniform"); command( &mut session, "graph.node.function", json!({"id": source, "base": true, "param": "outputsize", "function": FunctionGraph::constant(Value::Int2([1, 0]))}), ); let owner = NodeId(command(&mut session, "graph.node.add", json!({"def": "blur", "connectFrom": {"node": source}}))["id"].as_u64().unwrap()); let unrelated = node(&mut session, "uniform"); let mut function = FunctionGraph::input("$sizelog2", ValueType::Float2); let size = function.output.unwrap(); let parent = function.add_constant(Value::Float2([6.0, 6.0])); let difference = function.add("sub", &[size, parent], None); function.output = Some(function.add("toint2", &[difference], None)); command(&mut session, "graph.node.function", json!({"id": owner, "base": true, "param": "outputsize", "function": function})); let cooked = session.cook(); assert_eq!(cooked.nodes[&owner].error, None); assert_eq!(cooked.nodes[&owner].base.size, [256, 64]); assert_eq!(cooked.nodes[&owner].base_values[&BaseParameter::OutputSize], Value::Int2([1, 0])); assert_eq!((cooked.image(owner, 0).unwrap().w, cooked.image(owner, 0).unwrap().h), (16, 4)); command( &mut session, "graph.node.function", json!({"id": source, "base": true, "param": "outputsize", "function": FunctionGraph::constant(Value::Int2([0, 0]))}), ); let cooked = session.cook(); assert_eq!(cooked.nodes[&owner].base.size, [64, 64]); assert!(!cooked.nodes[&owner].cached); assert!(cooked.nodes[&unrelated].cached); } #[test] fn every_base_function_preserves_its_type_inheritance_and_value_in_sbs() { use materialcraft_engine::core::{BaseParameter, ParameterInheritance}; let mut session = new_session(); session.preview_size = Some(16); let owner = node(&mut session, "uniform"); let cases = [ (BaseParameter::OutputSize, Value::Int2([6, 5])), (BaseParameter::Format, Value::Int(3)), (BaseParameter::PixelSize, Value::Float2([0.25, 0.5])), (BaseParameter::PixelRatio, Value::Int(1)), (BaseParameter::Tiling, Value::Int(2)), (BaseParameter::RandomSeed, Value::Int(23)), ]; for (parameter, value) in &cases { command(&mut session, "graph.node.base", json!({"id": owner, "param": parameter.identifier(), "inheritance": "absolute"})); command( &mut session, "graph.node.function", json!({"id": owner, "base": true, "param": parameter.identifier(), "function": FunctionGraph::constant(value.clone())}), ); } let saved = formats::sbs::write_sbs(&session.pkg).unwrap(); let loaded = formats::sbs::read_sbs(&saved, "base-functions.sbs", &|_| None).unwrap(); assert!(loaded.warnings.is_empty(), "{:?}", loaded.warnings); let mut reopened = Session::new(loaded.pkg); reopened.preview_size = Some(16); let owner = reopened.graph().unwrap().nodes[0].id; for (parameter, _) in &cases { assert_eq!(parameter.inheritance(&reopened.graph().unwrap().node(owner).unwrap().base), ParameterInheritance::Absolute); } let result = &reopened.cook().nodes[&owner]; assert_eq!(result.error, None); for (parameter, value) in cases { assert_eq!(result.base_values[¶meter], value); } assert_eq!(result.base.size, [64, 32]); assert_eq!(result.base.seed, 23); assert_eq!(result.base.pixel_size, [0.25, 0.5]); assert_eq!(result.base.tiling, [false, true]); assert_eq!(result.base.pixel_ratio, 1); assert_eq!(result.base.format, materialcraft_engine::core::OutputFormat::F32); } #[test] fn constant_replacement_freezes_the_driven_value_and_reset_is_undoable() { let mut session = new_session(); session.preview_size = Some(16); let owner = node(&mut session, "blur"); command(&mut session, "graph.exposed.add", json!({"id": "amount", "bind": {"node": owner, "param": "intensity"}})); command(&mut session, "graph.exposed.set", json!({"id": "amount", "value": 3.0})); command(&mut session, "graph.node.function", json!({"id": owner, "param": "intensity", "mode": "constant"})); command(&mut session, "graph.exposed.set", json!({"id": "amount", "value": 8.0})); assert_eq!(session.cook().nodes[&owner].parameters["intensity"], Value::Float(3.0)); let before = session.pkg.clone(); command(&mut session, "graph.node.reset", json!({"id": owner, "param": "intensity"})); assert!(!session.graph().unwrap().node(owner).unwrap().functions.contains_key("intensity")); command(&mut session, "edit.undo", json!({})); assert_eq!(session.pkg, before); command(&mut session, "graph.node.param", json!({"id": owner, "param": "intensity", "value": 2.0})); assert!(!session.graph().unwrap().node(owner).unwrap().functions.contains_key("intensity")); assert_eq!(session.cook().nodes[&owner].parameters["intensity"], Value::Float(2.0)); } #[test] fn empty_and_wrong_type_functions_remain_editable_but_report_cook_errors() { let mut session = new_session(); session.preview_size = Some(16); let owner = node(&mut session, "uniform"); for function in [FunctionGraph::default(), FunctionGraph::constant(Value::Float(2.0))] { command(&mut session, "graph.node.function", json!({"id": owner, "base": true, "param": "outputsize", "function": function})); assert!(session.cook().nodes[&owner].error.is_some()); let info = command(&mut session, "graph.node.parameterInfo", json!({"id": owner, "base": true, "param": "outputsize"})); assert_eq!(info["expectedType"], "Integer2"); assert!(!info["warnings"].as_array().unwrap().is_empty()); command(&mut session, "graph.node.function.edit", json!({"id": owner, "base": true, "param": "outputsize"})); let bytes = formats::sbs::write_sbs(&session.pkg).unwrap(); let loaded = formats::sbs::read_sbs(&bytes, "incomplete.sbs", &|_| None).unwrap(); assert_eq!(loaded.pkg.graphs[0].nodes[0].base.functions.values().next().unwrap().nodes.len(), function.nodes.len()); } } #[test] fn instance_parameter_functions_work_without_stored_literals_and_use_instance_size() { use materialcraft_engine::core::{Graph, OutputFormat, Package, ValueType}; let mut source = Graph::new("Source"); source.format = OutputFormat::F32; let color = source.add_node("uniform", [0.0; 2]); source.node_mut(color).unwrap().params.insert("color_mode".into(), Value::Bool(false)); source.node_mut(color).unwrap().functions.insert("color".into(), FunctionGraph::input("amount", ValueType::Float4)); source.exposed.push(materialcraft_engine::core::ExposedParameter { description: String::new(), editor: None, clamp: false, step: None, id: "amount".into(), label: "Amount".into(), group: String::new(), default: Value::Float4([0.2; 4]), min: 0.0, max: 1.0, options: Vec::new(), }); let output = source.add_node("output", [200.0, 0.0]); source.connect(color, "output", output, "input").unwrap(); let dimensions = source.add_node("value_processor", [0.0; 2]); source.node_mut(dimensions).unwrap().params.insert("function".into(), Value::Function(Box::new(FunctionGraph::input("$size", ValueType::Float2)))); let size_output = source.add_node("output", [200.0, 200.0]); source.node_mut(size_output).unwrap().params.insert("identifier".into(), Value::Text("dimensions".into())); source.connect(dimensions, "output", size_output, "input").unwrap(); let mut parent = Graph::new("Parent"); parent.size = [6, 5]; parent.format = OutputFormat::F32; let owner = parent.add_node("graph_instance", [0.0; 2]); parent.node_mut(owner).unwrap().params.insert("graph".into(), Value::Text("Source".into())); let mut package = Package::new("Instances"); package.graphs = vec![parent, source]; let mut session = Session::new(package); session.preview_size = None; command(&mut session, "graph.node.function", json!({"id": owner, "param": "amount", "function": FunctionGraph::constant(Value::Float4([0.75; 4]))})); let result = session.cook(); assert_eq!(result.nodes[&owner].error, None); assert!(result.nodes[&owner].outputs.iter().any(|output| output.as_value() == Some(&Value::Float2([64.0, 32.0])))); assert!((result.image(owner, 0).unwrap().get_gray(0, 0, false) - 0.75).abs() < 1e-6); assert_eq!((result.image(owner, 0).unwrap().w, result.image(owner, 0).unwrap().h), (64, 32)); assert!(!session.graph().unwrap().node(owner).unwrap().params.contains_key("amount")); let bytes = formats::sbs::write_sbs(&session.pkg).unwrap(); let loaded = formats::sbs::read_sbs(&bytes, "instance.sbs", &|_| None).unwrap(); let mut reopened = Session::new(loaded.pkg); let owner = reopened.graph().unwrap().nodes[0].id; assert!((reopened.cook().image(owner, 0).unwrap().get_gray(0, 0, false) - 0.75).abs() < 1e-6); } #[test] fn color_boolean_enum_and_text_parameters_use_typed_function_outputs() { let mut session = new_session(); session.preview_size = Some(16); for (definition, parameter, value) in [ ("uniform", "color", Value::Float4([0.2, 0.4, 0.6, 1.0])), ("uniform", "color_mode", Value::Bool(false)), ("blend", "mode", Value::Int(2)), ("text", "text", Value::Text("Original".into())), ] { let owner = node(&mut session, definition); command(&mut session, "graph.node.function", json!({"id": owner, "param": parameter, "function": FunctionGraph::constant(value.clone())})); let result = &session.cook().nodes[&owner]; assert_eq!(result.error, None, "{parameter}"); let expected = materialcraft_engine::nodes::find(definition).unwrap().param(parameter).unwrap().default.coerce_json(&json!(value)).unwrap(); assert_eq!(result.parameters[parameter], expected); } let owner = node(&mut session, "uniform"); command(&mut session, "graph.node.function", json!({"id": owner, "param": "color", "function": FunctionGraph::constant(Value::Float(0.5))})); // A gray level fills the color channels, as the library's uniform colors rely on let result = &session.cook().nodes[&owner]; assert_eq!(result.error, None); assert_eq!(result.parameters["color"].as_vec4(), Some([0.5, 0.5, 0.5, 1.0])); let owner = node(&mut session, "uniform"); command(&mut session, "graph.node.function", json!({"id": owner, "param": "color", "function": FunctionGraph::constant(Value::Int(1))})); assert!(session.cook().nodes[&owner].error.as_ref().unwrap().contains("Float4")); let bitmap = node(&mut session, "bitmap"); assert!(execute(&mut session, "graph.node.function", &json!({"id": bitmap, "param": "resource"})).is_err()); } #[test] fn native_channel_parameters_accept_scalar_functions_without_changing_their_bodies() { let mut session = new_session(); session.preview_size = Some(16); for (definition, parameters) in [("levels", &["in_low", "in_mid", "in_high", "out_low", "out_high"][..]), ("fx_map", &["background"][..])] { for parameter in parameters { let owner = node(&mut session, definition); let function = FunctionGraph::constant(Value::Float(0.25)); command(&mut session, "graph.node.function", json!({"id": owner, "param": parameter, "function": function})); let target = materialcraft_engine::FunctionGraphTarget::Dynamic { node: owner, parameter: (*parameter).into() }; assert!(materialcraft_engine::function_inspection::warnings_for(session.graph().unwrap(), &target, &function).is_empty()); let result = &session.cook().nodes[&owner]; assert_eq!(result.error, None, "{definition}.{parameter}"); let expected = if definition == "fx_map" { Value::Color([0.25, 0.25, 0.25, 1.0]) } else { Value::Float4([0.25; 4]) }; assert_eq!(result.parameters[*parameter], expected); let bytes = formats::sbs::write_sbs(&session.pkg).unwrap(); let loaded = formats::sbs::read_sbs(&bytes, "scalar-channel.sbs", &|_| None).unwrap(); assert!(loaded.warnings.is_empty(), "{:?}", loaded.warnings); let reopened_node = loaded.pkg.graphs[0].nodes.last().unwrap(); let reopened_id = reopened_node.id; let saved_function = &reopened_node.functions[*parameter]; assert_eq!(saved_function.nodes.len(), 1); assert_eq!(saved_function.nodes[0].value, Some(Value::Float(0.25))); let mut reopened = Session::new(loaded.pkg); reopened.preview_size = Some(16); assert_eq!(reopened.cook().nodes[&reopened_id].parameters[*parameter], expected); } } } #[test] fn base_functions_inherit_from_the_primary_input_and_bypasses_keep_input_dimensions() { let mut session = new_session(); session.preview_size = Some(16); let foreground = node(&mut session, "uniform"); command(&mut session, "graph.node.base", json!({"id": foreground, "sizeMode": "absolute", "size": [7, 6]})); let background = node(&mut session, "uniform"); command(&mut session, "graph.node.base", json!({"id": background, "sizeMode": "absolute", "size": [5, 5]})); let blend = node(&mut session, "blend"); session.graph_mut().unwrap().connect(foreground, "output", blend, "foreground").unwrap(); session.graph_mut().unwrap().connect(background, "output", blend, "background").unwrap(); command( &mut session, "graph.node.function", json!({"id": blend, "param": "outputsize", "base": true, "function": FunctionGraph::constant(Value::Int2([1, 0]))}), ); assert_eq!(session.cook().nodes[&blend].base.size, [64, 32]); let blur = NodeId(command(&mut session, "graph.node.add", json!({"def": "blur", "connectFrom": {"node": blend}}))["id"].as_u64().unwrap()); command( &mut session, "graph.node.function", json!({"id": blur, "param": "outputsize", "base": true, "function": FunctionGraph::constant(Value::Int2([-1, 0]))}), ); command(&mut session, "graph.node.disable", json!({"ids": [blur], "disabled": true})); let output = NodeId(command(&mut session, "graph.node.add", json!({"def": "output", "connectFrom": {"node": blur}}))["id"].as_u64().unwrap()); assert_eq!(session.cook().nodes[&output].base.size, [64, 32]); command(&mut session, "graph.node.disable", json!({"ids": [blend], "disabled": true})); let cooked = session.cook(); let image = cooked.image(blend, 0).unwrap(); assert_eq!((image.w, image.h), (16, 16)); assert_eq!(cooked.nodes[&blend].base.size, [32, 32]); assert_eq!(cooked.nodes[&output].base.size, [32, 32]); } #[test] fn setting_a_base_literal_keeps_inheritance_and_removes_only_its_driver() { use materialcraft_engine::core::{BaseParameter, ParameterInheritance}; let mut session = new_session(); let owner = node(&mut session, "uniform"); command(&mut session, "graph.node.function", json!({"id": owner, "base": true, "param": "format", "mode": "constant"})); command(&mut session, "graph.node.function", json!({"id": owner, "base": true, "param": "outputsize", "mode": "constant"})); session.selection.clear(); command(&mut session, "graph.node.base", json!({"id": owner, "param": "format", "value": 3})); let base = &session.graph().unwrap().node(owner).unwrap().base; assert_eq!(BaseParameter::Format.inheritance(base), ParameterInheritance::RelativeToInput); assert!(!base.functions.contains_key(&BaseParameter::Format)); assert!(base.functions.contains_key(&BaseParameter::OutputSize)); } #[test] fn malformed_literals_do_not_change_a_native_parameter_functions_expected_type() { let mut session = new_session(); session.preview_size = Some(16); let owner = node(&mut session, "blur"); session.graph_mut().unwrap().node_mut(owner).unwrap().params.insert("intensity".into(), Value::Text("invalid".into())); command(&mut session, "graph.node.function", json!({"id": owner, "param": "intensity", "function": FunctionGraph::constant(Value::Float(2.0))})); let result = &session.cook().nodes[&owner]; assert_eq!(result.error, None); assert_eq!(result.parameters["intensity"], Value::Float(2.0)); } #[test] fn input_value_default_functions_follow_the_selected_value_type() { let mut session = new_session(); session.preview_size = Some(16); let owner = node(&mut session, "input_value"); session.selection.clear(); command(&mut session, "graph.node.param", json!({"id": owner, "param": "default", "value": Value::Int2([3, 5])})); command(&mut session, "graph.node.function", json!({"id": owner, "param": "default", "mode": "constant"})); let info = command(&mut session, "graph.node.parameterInfo", json!({"id": owner, "param": "default"})); assert_eq!(info["expectedType"], "Integer2"); assert!(info["warnings"].as_array().unwrap().is_empty()); let result = &session.cook().nodes[&owner]; assert_eq!(result.error, None); assert_eq!(result.outputs[0].as_value(), Some(&Value::Int2([3, 5]))); }