Recognize Histogram Scan and Auto Levels SBS aliases

This commit is contained in:
Belligerently committed 2026-11-04 20:18:15 -05:00
1 parent 698ea23380
commit f421d10b3f
2 files changed
+133 -3

No files matched your search

+16 -3
View File
@@ -1074,8 +1074,13 @@ impl<'text> Reader<'text, '_> {
if let Some(node) = node {
for param in instance_params() {
let param_name = child_value(param, "name").unwrap_or("");
match def.param(param_name) {
Some(param_def) => self.set_param(node, param_name, &param_def.default, param_def.options.len(), param, &graph_name),
let id = match (def.id, param_name) {
("histogram_scan", "Position") => "position",
("histogram_scan", "Contrast") => "contrast",
_ => param_name,
};
match def.param(id) {
Some(param_def) => self.set_param(node, id, &param_def.default, param_def.options.len(), param, &graph_name),
None => self.warnings.add(format!("`{}`: parameter `{param_name}` has no MaterialCraft equivalent and was ignored", def.id)),
}
}
@@ -1086,7 +1091,15 @@ impl<'text> Reader<'text, '_> {
let port_for = |identifier: &str| if def.output_index(identifier).is_some() { identifier.to_string() } else { first_output.clone() };
let unbridged = output_uids.iter().filter(|(uid, _)| !bridgings.iter().any(|(b, _)| b == uid)).map(|(uid, _)| (uid.clone(), first_output.clone()));
let outputs = bridgings.iter().map(|(uid, identifier)| (uid.clone(), port_for(identifier))).chain(unbridged).collect();
let inputs = def.inputs.iter().map(|p| (p.id.to_string(), p.id.to_string())).collect();
let mut inputs: HashMap<_, _> = def.inputs.iter().map(|p| (p.id.to_string(), p.id.to_string())).collect();
let input_alias = match def.id {
"histogram_scan" => Some("Input_1"),
"auto_levels" => Some("Input"),
_ => None,
};
if let Some(alias) = input_alias {
inputs.insert(alias.to_string(), "input".to_string());
}
ReadNode { id, index, inputs, outputs, open_inputs: false }
}
+117
View File
@@ -0,0 +1,117 @@
//! The reported library-node aliases must preserve imported settings and connections.
use materialcraft_core::{Graph, Package, Value};
use materialcraft_formats::sbs::{read_sbs, write_sbs};
fn plain_xml(bytes: &[u8]) -> String {
let text = String::from_utf8(bytes.to_vec()).unwrap();
// Exercise XML import rather than the writer's embedded exact native-package copy.
format!("{}</package>", text.split("<!--").next().unwrap())
}
fn fixture(def: &str) -> String {
let mut pkg = Package::new("Import check");
let mut graph = Graph::new("G");
let source = graph.add_node("uniform", [0.0, 0.0]);
let filter = graph.add_node(def, [150.0, 0.0]);
graph.connect(source, "output", filter, "input").unwrap();
if def == "histogram_scan" {
let n = graph.node_mut(filter).unwrap();
n.params.insert("position".into(), Value::Float(0.25));
n.params.insert("contrast".into(), Value::Float(0.75));
}
pkg.graphs.push(graph);
plain_xml(&write_sbs(&pkg).unwrap())
}
fn aliased_fixture(def: &str) -> String {
let xml = fixture(def);
if def == "histogram_scan" {
xml.replace("<name v=\"position\"/>", "<name v=\"Position\"/>")
.replace("<name v=\"contrast\"/>", "<name v=\"Contrast\"/>")
.replace("<identifier v=\"input\"/>", "<identifier v=\"Input_1\"/>")
} else {
xml.replace("<identifier v=\"input\"/>", "<identifier v=\"Input\"/>")
}
}
fn assert_wire(pkg: &Package, def: &str) {
let g = &pkg.graphs[0];
let source = g.nodes.iter().find(|n| n.def == "uniform").unwrap();
let filter = g.nodes.iter().find(|n| n.def == def).unwrap();
assert_eq!(g.connections.len(), 1);
let wire = &g.connections[0];
assert_eq!((wire.from, wire.from_port.as_str(), wire.to, wire.to_port.as_str()), (source.id, "output", filter.id, "input"));
}
fn assert_scan_values(pkg: &Package) {
let n = pkg.graphs[0].nodes.iter().find(|n| n.def == "histogram_scan").unwrap();
assert_eq!(n.params.get("position"), Some(&Value::Float(0.25)));
assert_eq!(n.params.get("contrast"), Some(&Value::Float(0.75)));
assert!(!n.params.contains_key("Position") && !n.params.contains_key("Contrast"));
}
#[test]
fn canonical_names_keep_parameters_and_wires() {
for def in ["histogram_scan", "auto_levels"] {
let read = read_sbs(fixture(def).as_bytes(), "check.sbs", &|_| None).unwrap();
assert!(!read.exact);
assert!(read.warnings.is_empty(), "{:?}", read.warnings);
assert_wire(&read.pkg, def);
if def == "histogram_scan" {
assert_scan_values(&read.pkg);
}
}
}
#[test]
fn histogram_scan_keeps_reported_parameter_spellings() {
let xml = fixture("histogram_scan").replace("<name v=\"position\"/>", "<name v=\"Position\"/>").replace("<name v=\"contrast\"/>", "<name v=\"Contrast\"/>");
let read = read_sbs(xml.as_bytes(), "check.sbs", &|_| None).unwrap();
assert!(read.warnings.is_empty(), "{:?}", read.warnings);
assert_scan_values(&read.pkg);
}
#[test]
fn histogram_scan_keeps_reported_input_connection() {
let xml = fixture("histogram_scan").replace("<identifier v=\"input\"/>", "<identifier v=\"Input_1\"/>");
let read = read_sbs(xml.as_bytes(), "check.sbs", &|_| None).unwrap();
assert!(read.warnings.is_empty(), "{:?}", read.warnings);
assert_wire(&read.pkg, "histogram_scan");
}
#[test]
fn auto_levels_keeps_reported_input_connection() {
let xml = fixture("auto_levels").replace("<identifier v=\"input\"/>", "<identifier v=\"Input\"/>");
let read = read_sbs(xml.as_bytes(), "check.sbs", &|_| None).unwrap();
assert!(read.warnings.is_empty(), "{:?}", read.warnings);
assert_wire(&read.pkg, "auto_levels");
}
#[test]
fn aliased_imports_survive_a_structural_save_and_reload() {
for def in ["histogram_scan", "auto_levels"] {
let read = read_sbs(aliased_fixture(def).as_bytes(), "check.sbs", &|_| None).unwrap();
assert!(read.warnings.is_empty(), "{:?}", read.warnings);
let xml = plain_xml(&write_sbs(&read.pkg).unwrap());
let back = read_sbs(xml.as_bytes(), "saved.sbs", &|_| None).unwrap();
assert!(!back.exact);
assert!(back.warnings.is_empty(), "{:?}", back.warnings);
assert_wire(&back.pkg, def);
if def == "histogram_scan" {
assert_scan_values(&back.pkg);
}
}
}
#[test]
fn unknown_parameters_still_warn() {
let xml = fixture("histogram_scan").replace("<name v=\"contrast\"/>", "<name v=\"UnexpectedContrast\"/>");
let read = read_sbs(xml.as_bytes(), "check.sbs", &|_| None).unwrap();
assert_eq!(read.warnings.len(), 1);
assert!(read.warnings[0].contains("UnexpectedContrast"));
let n = read.pkg.graphs[0].nodes.iter().find(|n| n.def == "histogram_scan").unwrap();
assert_eq!(n.params.get("position"), Some(&Value::Float(0.25)));
assert!(!n.params.contains_key("contrast") && !n.params.contains_key("UnexpectedContrast"));
}
#[test]
fn unknown_inputs_still_warn_and_drop_the_wire() {
for def in ["histogram_scan", "auto_levels"] {
let xml = fixture(def).replace("<identifier v=\"input\"/>", "<identifier v=\"UnexpectedInput\"/>");
let read = read_sbs(xml.as_bytes(), "check.sbs", &|_| None).unwrap();
assert_eq!(read.warnings.len(), 1);
assert!(read.warnings[0].contains("UnexpectedInput"));
assert!(read.pkg.graphs[0].connections.is_empty());
assert_eq!(read.pkg.graphs[0].nodes.len(), 2);
}
}