Files
materialcraft/crates/engine/src/node_library.test.rs
T
dotCooCoo bee8c3feb8 Merge main into feat/image-craft-texture
main's per-axis wrapping, stored sampling and integer-sampling flag now
come from craft-texture (storytold/craft-libs#1709). Every craft-libs
dependency is pinned to that pull request's head, 92fb3fa8.
2026-11-15 10:48:09 -08:00

390 lines
21 KiB
Rust

use super::*;
use materialcraft_core::Graph;
#[path = "../tests/support/node_library.rs"]
mod fixture;
#[test]
fn loaded_packages_share_equal_resource_buffers_without_merging_resources() {
let files = ["sbs://rt_ao.sbs".to_string(), "sbs://rt_ao_v2.sbs".to_string()];
let library = NodeLibrary::load(&files);
let resources: Vec<_> =
files.iter().map(|file| library.packages[file].resources.iter().find(|resource| resource.source.ends_with("bluenoise_256.png")).unwrap()).collect();
assert!(!resources[0].bytes.is_empty());
assert_eq!(resources[0].bytes, resources[1].bytes);
assert!(resources[0].bytes.ptr_eq(&resources[1].bytes), "equal resource bytes should use one immutable buffer");
assert!(library.packages[&files[0]].graph_by_name("rt_ao").is_some());
assert!(library.packages[&files[1]].graph_by_name("rt_ao").is_some());
}
/// Installing a library must not compile and clone graphs that no open document references.
#[test]
fn unused_library_packages_remain_shared_without_interface_refresh() {
let mut package = Package::new("Unused library");
package.graphs.push(Graph::new("Source"));
let mut caller = Graph::new("Caller");
let id = caller.add_node("graph_instance", [0.0; 2]);
caller.nodes.iter_mut().find(|node| node.id == id).unwrap().params.insert("graph".into(), materialcraft_core::Value::Text("Source".into()));
package.graphs.push(caller);
let source = Arc::new(package);
let mut library = NodeLibrary::default();
library.packages.insert("sbs://unused.sbs".into(), source.clone());
let session = crate::Session::with_library(Package::new("Empty"), Arc::new(library));
assert!(Arc::ptr_eq(&source, &session.pkg.dependencies["sbs://unused.sbs"]));
}
/// Category aliases and frame kinds resolve only to recognized categories.
#[test]
fn frame_titles_map_to_library_categories() {
assert_eq!(frame_category("Texture Generators - Noises", false, false).as_deref(), Some("Texture generators/Noises"));
assert_eq!(frame_category("Spline & Path tools - Path tools", false, false).as_deref(), Some("Spline & Path tools/Path tools"));
assert_eq!(frame_category("Material Filters - 1 click", false, false).as_deref(), Some("Material filters/1-click"));
assert_eq!(frame_category("Mesh-based generators - Weathering", false, false).as_deref(), Some("Mesh-based generators/Weathering"));
assert_eq!(frame_category("PBR Materials", false, false).as_deref(), Some("PBR materials"));
assert_eq!(frame_category("Atomic Nodes", false, false).as_deref(), Some("Atomic nodes"));
// The category MaterialCraft renamed still reads from older layouts
assert_eq!(frame_category("SDF functions - Primitives", false, false).as_deref(), Some("MCF functions/Primitives"));
assert_eq!(frame_category("Functions Inside", false, false), None);
assert_eq!(frame_category("Filters - Nowhere", false, false), None);
assert_eq!(frame_category("Comparison", true, true).as_deref(), Some("Function nodes/Comparison"));
assert_eq!(frame_category("Comparison", true, false).as_deref(), Some("Functions/Comparison"));
assert_eq!(frame_category("Unknown", true, true), None);
}
/// A graph with these attributes, for category tests
fn attributed(name: &str, category: &str, tags: &str) -> Graph {
let mut graph = Graph::new(name);
graph.attributes.category = category.into();
graph.attributes.tags = tags.into();
graph
}
/// Package categories and tags resolve to the tree's categories and sub-categories.
#[test]
fn package_attributes_map_to_library_categories() {
for (category, tags, expected) in [
("Generator", "Noise, Perlin", "Texture generators/Noises"),
("Generator", "Pattern", "Texture generators/Patterns"),
("Filter", "Blur", "Filters/Blurs"),
("Filter", "Effect, light, bloom", "Filters/Effects"),
("Filter", "Normal Map", "Filters/Normal map"),
("Filter", "Transformation, Crop", "Filters/Transforms"),
("Filter", "", "Filters"),
("Material Filter", "1-Click", "Material filters/1-click"),
("Material Filter", "Scan Processing", "Material filters/Scan processing"),
("Material Filters", "Mesh Adaptive", "Mesh-based generators/Utilities"),
("Scan", "", "Material filters/Scan processing"),
("Mesh Adaptive", "Mask Generators", "Mesh-based generators/Mask generators"),
("Splines & Paths", "Splines, Paths", "Spline & Path tools/Spline tools"),
("Splines & Paths", "Paths", "Spline & Path tools/Path tools"),
("3D View", "HDRI Tools", "3D view/HDRI tools"),
("Values", "Constant", "Values/Constant"),
("PBR Materials/Paper ", "", "PBR materials/Paper"),
("SDF function", "Primitive", "MCF functions/Primitives"),
("3D Functions", "Material", "MCF functions"),
] {
assert_eq!(library_category(&attributed("graph", category, tags)).as_deref(), Some(expected), "{category} / {tags}");
}
assert_eq!(library_category(&attributed("gravel", "Material", "")).as_deref(), Some("PBR materials/Ground"), "a material's name picks its sub-category");
assert_eq!(
library_category(&attributed("spot_emboss", "", "Effect")).as_deref(),
Some("Filters/Effects"),
"a graph without a category uses its listed one"
);
assert_eq!(library_category(&attributed("graph", "", "Effect")), None);
assert_eq!(library_category(&attributed("graph", "Template", "")), None);
}
/// Hidden graphs and helper functions stay out; categorized functions are listed.
#[test]
fn hidden_graphs_and_helper_functions_are_not_listed() {
let function = |name: &str, category: &str, tags: &str| {
let mut graph = attributed(name, category, tags);
graph.function = Some(materialcraft_core::FunctionGraph::default());
graph
};
let mut package = Package::new("Tools");
let mut shown = attributed("shown", "Filter", "Blur");
shown.add_node("output", [0.0; 2]);
let mut hidden = shown.clone();
hidden.name = "hidden".into();
hidden.attributes.hide_in_library = true;
package.graphs.extend([shown, hidden, function("helper", "", ""), function("cube", "SDF function", "Primitive"), function("hash", "", "Random")]);
let mut functions = Package::new("Functions only");
functions.graphs.push(function("loose", "", ""));
let packages = BTreeMap::from([("sbs://tools.sbs".to_string(), Arc::new(package)), ("sbs://user.sbs".to_string(), Arc::new(functions))]);
let entries = NodeLibrary::default().entries(&packages);
let listed: BTreeMap<_, _> =
entries.iter().filter(|entry| entry.id.starts_with("sbs://")).map(|entry| (entry.id.as_str(), entry.category.as_str())).collect();
let expected = [
("sbs://tools.sbs#cube", "MCF functions/Primitives"),
("sbs://tools.sbs#hash", "Functions/Random"),
("sbs://tools.sbs#shown", "Filters/Blurs"),
("sbs://user.sbs#loose", "Functions"),
];
assert_eq!(listed, BTreeMap::from(expected), "a package of functions alone lists its loose ones");
}
/// Every graph the bundled packages list sits in a category of the tree.
#[test]
fn the_whole_bundled_library_is_categorized() {
let library = NodeLibrary::load(&library::files());
let entries = library.entries(&library.packages);
let packaged: Vec<_> = entries.iter().filter(|entry| entry.id.starts_with("sbs://")).collect();
let known = |category: &str| {
let mut parts = category.split('/');
let top = parts.next().unwrap_or_default();
CATEGORIES.iter().any(|(name, subs)| *name == top && parts.next().is_none_or(|sub| subs.contains(&sub)))
};
let unknown: Vec<_> = packaged.iter().filter(|entry| !known(&entry.category)).map(|entry| (&entry.id, &entry.category)).collect();
assert!(unknown.is_empty(), "{unknown:?}");
let category = |id: &str| packaged.iter().find(|entry| entry.id == id).map(|entry| entry.category.as_str());
for (id, expected) in [
("sbs://noise_perlin_noise_v2.sbs#perlin_noise", "Texture generators/Noises"),
("sbs://pattern_tile_sampler.sbs#tile_sampler", "Texture generators/Patterns"),
("sbs://blur_hq.sbs#blur_hq", "Filters/Blurs"),
("sbs://mg_mask_builder.sbs#mg_mask_builder_2", "Mesh-based generators/Mask generators"),
("sbs://materials/pbr/gravel.sbs#gravel", "PBR materials/Ground"),
("sbs://functions.sbs#Functions/Math/Pi", "Functions/Constant"),
] {
assert_eq!(category(id), Some(expected), "{id}");
}
}
#[test]
fn bundled_material_functions_have_compatible_inputs() {
let library = NodeLibrary::load(&library::files());
for (package_name, graph_names) in [
("sbs://3d_functions.sbs", &["3d_sdf_primitives/3d_sdf_plane"][..]),
(
"sbs://pbr_render2.sbs",
&["ibl_specular_contrib_anisotropic/IBLSpecularContribution", "ibl_specular_contrib_anisotropic/IBLSpecularContribution_iteration"],
),
] {
let package = &library.packages[package_name];
for graph_name in graph_names {
let (_, graph) = package.graph_by_name(graph_name).unwrap();
let mut function = graph.function.as_ref().unwrap().clone();
materialcraft_nodes::function::resolve_instances(&mut function, package, &library.packages);
if let Err(error) = materialcraft_nodes::function::compile(&function, 0) {
panic!("{package_name}#{graph_name}: {error}");
}
}
}
}
/// Identifier labels preserve recognized acronyms and omit empty words.
#[test]
fn identifiers_read_as_labels() {
assert_eq!(humanize("3D_perlin_noise"), "3D Perlin Noise");
assert_eq!(humanize("bnw_spots_1"), "BnW Spots 1");
assert_eq!(humanize("rgb-a_merge"), "RGB-A Merge");
assert_eq!(humanize("Functions/Math/acescg_to_srgb"), "ACEScg To sRGB");
assert_eq!(humanize("__"), "");
}
/// Function categories use exact path segments and known name overrides.
#[test]
fn functions_sort_into_sub_categories_by_folder_and_name() {
assert_eq!(function_category("Functions/Math/Pi"), "Functions/Constant");
assert_eq!(function_category("Functions/Math/Equality_Float2"), "Functions/Comparison");
assert_eq!(function_category("Functions/Math/Parity/EvenCount"), "Functions/Parity");
assert_eq!(function_category("Functions/Math/Trigo/acos"), "Functions/Maths");
assert_eq!(function_category("Functions/Math/Trigo/deg_to_rad"), "Functions/Conversion");
assert_eq!(function_category("Functions/easings/sine/ease_in_sine"), "Functions/Easings");
assert_eq!(function_category("Functions/switch/Float2/switch_float2_4_inputs"), "Functions/Various");
assert_eq!(function_category("Functions/Tonemappers/tonemap_ACES"), "Functions/Color");
assert_eq!(function_category("Functions/Mathematics/x"), "Functions", "a folder name must match whole");
assert_eq!(function_category("Loose"), "Functions");
}
/// The isolated bundled catalog has unique entries in recognized categories.
#[test]
fn the_bundled_library_fills_the_tree_with_what_materialcraft_has() {
let library = fixture::library();
assert!(library.layouts.is_empty());
assert!(library.packages.contains_key("sbs://functions.sbs"));
let entries = library.entries(&library.packages);
let ids: BTreeSet<_> = entries.iter().map(|entry| entry.id.as_str()).collect();
assert_eq!(ids.len(), entries.len(), "ids are unique");
assert!(entries.iter().all(|entry| entry.missing.is_none()), "everything listed can be added");
let known = |category: &str| {
let mut parts = category.split('/');
let top = parts.next().unwrap_or("");
CATEGORIES.iter().any(|(name, subs)| *name == top && parts.next().is_none_or(|sub| subs.contains(&sub)))
};
for entry in &entries {
assert!(known(&entry.category), "{} sits in unknown category {}", entry.id, entry.category);
}
let count = |category: &str| entries.iter().filter(|entry| entry.category == category).count();
let find = |id: &str| entries.iter().find(|entry| entry.id == id).unwrap_or_else(|| panic!("no entry {id}"));
for top in ["Function nodes", "Functions"] {
let (_, subs) = CATEGORIES.iter().find(|(name, _)| *name == top).unwrap();
for sub in *subs {
assert!(count(&format!("{top}/{sub}")) > 0, "{top}/{sub} is empty");
}
}
// Every bundled function has a sub-category
let functions = library.packages["sbs://functions.sbs"].graphs.iter().filter(|graph| graph.function.is_some()).count();
assert_eq!(entries.iter().filter(|entry| entry.category.starts_with("Functions/")).count(), functions);
assert_eq!(count("Functions"), 0);
assert_eq!(find("sbs://functions.sbs#Functions/Tonemappers/tonemap_ACES").category, "Functions/Color");
assert_eq!(
entries.iter().filter(|entry| entry.category == "Graph items").map(|entry| entry.label.as_str()).collect::<Vec<_>>(),
["Comment", "Frame", "Pin", "Dot node"]
);
for id in ["node:blur", "node:bitmap", "node:output", "node:input_color", "node:input_value"] {
assert_eq!(find(id).category, "Atomic nodes", "{id}");
}
assert_eq!(find("function:add").category, "Function nodes/Operator");
assert_eq!(find("pattern:paramset").category, "FxMap nodes");
let pi = find("sbs://functions.sbs#Functions/Math/Pi");
assert_eq!((pi.label.as_str(), pi.category.as_str()), ("Pi", "Functions/Constant"));
assert_eq!(find("sbs://functions.sbs#Functions/Math/Equality_Float2").category, "Functions/Comparison");
}
/// A layout that places a library node MaterialCraft doesn't have yet, a function and a sub-category
/// the PBR keywords decide
const LAYOUT: &str = r#"<package><dependencies>
<dependency><filename v="sbs://3d_perlin_noise.sbs"/><uid v="2"/></dependency>
<dependency><filename v="sbs://materials/bricks_001.sbs"/><uid v="3"/></dependency></dependencies>
<content><graph><identifier v="Layout"/><compNodes>
<compNode><uid v="10"/><GUILayout><gpos v="20 40 0"/></GUILayout><compImplementation><compInstance><path v="pkg:///3D_perlin_noise?dependency=2"/></compInstance></compImplementation></compNode>
<compNode><uid v="11"/><GUILayout><gpos v="220 40 0"/></GUILayout><compImplementation><compInstance><path v="pkg:///bricks_001?dependency=3"/></compInstance></compImplementation></compNode>
</compNodes><GUIObjects>
<GUIObject><type v="COMMENT"/><GUILayout><gpos v="0 0 0"/><size v="160 200"/></GUILayout><title v="Texture Generators - Noises"/></GUIObject>
<GUIObject><type v="COMMENT"/><GUILayout><gpos v="200 0 0"/><size v="160 200"/></GUILayout><title v="PBR Materials"/></GUIObject>
</GUIObjects></graph></content></package>"#;
/// A missing layout entry becomes available when its package is supplied.
#[test]
fn a_layout_lists_what_it_places_and_a_library_package_makes_it_available() {
let frames = materialcraft_formats::sbs::read_layout(LAYOUT.as_bytes(), "sbs://layout.sbs").unwrap();
let library = NodeLibrary { placements: placements(&frames), ..Default::default() };
let entries = library.entries(&BTreeMap::new());
let perlin = entries.iter().find(|entry| entry.id == "sbs://3d_perlin_noise.sbs#3D_perlin_noise").unwrap();
assert_eq!((perlin.label.as_str(), perlin.category.as_str()), ("3D Perlin Noise", "Texture generators/Noises"));
assert!(perlin.missing.is_some(), "a placed node whose package is absent is listed but not addable");
let bricks = entries.iter().find(|entry| entry.id == "sbs://materials/bricks_001.sbs#bricks_001").unwrap();
assert_eq!(bricks.category, "PBR materials/Bricks");
let mut graph = Graph::new("3D_perlin_noise");
graph.add_node("uniform", [0.0; 2]);
graph.add_node("output", [200.0, 0.0]);
let mut package = Package::new("3d_perlin_noise");
package.graphs.push(graph.clone());
graph.name = "Loose".into();
graph.attributes.category = "Filters/Blurs".into();
package.graphs.push(graph);
let dependencies = BTreeMap::from([("sbs://3d_perlin_noise.sbs".to_string(), Arc::new(package))]);
let entries = library.entries(&dependencies);
let perlin = entries.iter().find(|entry| entry.id == "sbs://3d_perlin_noise.sbs#3D_perlin_noise").unwrap();
assert!(perlin.missing.is_none());
assert_eq!(perlin.category, "Texture generators/Noises");
let loose = entries.iter().find(|entry| entry.id == "sbs://3d_perlin_noise.sbs#Loose").unwrap();
assert_eq!((loose.category.as_str(), loose.canvas), ("Filters/Blurs", LibraryCanvas::Material));
}
/// Invalid library files produce warnings while native entries remain usable.
#[test]
fn unreadable_library_files_warn_instead_of_failing() {
let library = NodeLibrary::load(&["sbs://does_not_exist.sbs".into(), "sbs://../escape.sbs".into()]);
assert!(library.packages.is_empty() && library.layouts.is_empty());
assert_eq!(library.warnings.len(), 2);
let entries = library.entries(&BTreeMap::new());
assert!(entries.iter().any(|entry| entry.id == "node:blur" && entry.category == "Atomic nodes"));
assert!(entries.iter().any(|entry| entry.id == "function:add" && entry.category == "Function nodes/Operator"));
}
/// Classification tags take precedence over package folders and support multiple placements.
#[test]
fn function_tags_choose_library_filters_before_path_fallbacks() {
let mut package = Package::new("Functions");
for (name, category, tags) in [("Pi", "Function", "Maths"), ("Tagged", "", "Comparison; Easing"), ("Fallback", "", "Unknown")] {
let mut graph = Graph::new(name);
graph.folder = "Functions/Math".into();
graph.function = Some(Default::default());
graph.attributes.category = category.into();
graph.attributes.tags = tags.into();
package.graphs.push(graph);
}
let dependencies = BTreeMap::from([("sbs://classification.sbs".to_string(), Arc::new(package))]);
let entries = NodeLibrary::default().entries(&dependencies);
let categories = |name: &str| entries.iter().filter(|entry| entry.label == name).map(|entry| entry.category.as_str()).collect::<Vec<_>>();
assert_eq!(categories("Pi"), ["Functions/Maths"]);
assert_eq!(categories("Tagged"), ["Functions/Comparison", "Functions/Easings"]);
assert_eq!(categories("Fallback"), ["Functions/Maths"]);
}
/// Library graphs render a preview from sample inputs; graphs that make no image give none.
#[test]
fn library_graphs_cook_previews_from_sample_inputs() {
let library = Arc::new(NodeLibrary::load(&library::files()));
let preview = |package: &str, graph: &str| NodeLibrary::preview(&library, package, graph, 32);
let filter = preview("sbs://blur_hq.sbs", "blur_hq").unwrap();
assert_eq!((filter.width(), filter.height()), (32, 32));
assert!(preview("sbs://materials/pbr/bricks_001.sbs", "bricks_001").is_some());
assert!(preview("sbs://noise_bnw_spots_1.sbs", "bnw_spots_1").is_some(), "an FX-Map noise reads the variables its size function sets");
assert!(preview("sbs://blur_hq.sbs", "no_such_graph").is_none());
assert!(preview("sbs://functions.sbs", "Functions/Math/Pi").is_none(), "a function has no image");
}
#[test]
#[ignore = "repeated bundled preview cooks; run explicitly for memory profiling"]
fn repeated_library_previews_release_images_and_source_references() {
let library = Arc::new(NodeLibrary::load(&library::files()));
let references: Vec<_> = library.packages.values().map(Arc::strong_count).collect();
for cycle in 0..12 {
for (package, graph) in
[("sbs://blur_hq.sbs", "blur_hq"), ("sbs://noise_clouds_3_v2.sbs", "clouds_3"), ("sbs://materials/pbr/bricks_001.sbs", "bricks_001")]
{
let image = NodeLibrary::preview(&library, package, graph, 72).unwrap_or_else(|| panic!("missing preview {package}#{graph}"));
let buffer = Arc::downgrade(image.shared_data());
drop(image);
assert!(buffer.upgrade().is_none(), "a completed thumbnail must release its image after upload");
assert_eq!(Arc::strong_count(&library), 1);
assert_eq!(library.packages.values().map(Arc::strong_count).collect::<Vec<_>>(), references);
}
println!("completed preview cycle {cycle}");
#[cfg(target_os = "linux")]
if let Ok(status) = std::fs::read_to_string("/proc/self/status") {
let memory: Vec<_> = status.lines().filter(|line| line.starts_with("VmRSS:") || line.starts_with("VmHWM:")).collect();
println!("{}", memory.join(", "));
}
}
}
#[test]
fn cancelled_library_previews_stop_before_preparing_the_package() {
let library = Arc::new(NodeLibrary::default());
let cancelled = std::sync::atomic::AtomicBool::new(true);
assert!(NodeLibrary::preview_cancellable(&library, "unused", "unused", 72, &cancelled).is_none());
assert_eq!(Arc::strong_count(&library), 1);
}