Files
materialcraft/crates/eval/src/node_execution.rs
T
chasse20 1a7225c8c2 Auto: Reuse SBS parsing and fix stale preview cache failures
Integrate main's read limits and preserve the font, evaluator, converter,
and measured preview repairs. Complete the scoped type, comment, and
spacing cleanup.

Reuse one validated XML document for library layout and graph reads.
Associate cache maintenance completion with its submitted revision so
old failures cannot consume new settings or clear requests.
2026-11-14 22:52:26 +00:00

235 lines
11 KiB
Rust

use crate::{Cache, Cooked, NodeOutput, NodeResult, Options, identifier, now_ms};
use crate::{
cache_key::{graph_tree_hash_with_registry, hash_of, image_key, variable_key},
graph_instance::cook_instance,
parameter::resolve_parameters,
prepared_graph::PreparedGraph,
value_execution::evaluate_value,
};
use materialcraft_core::{Node, Package, Value};
use materialcraft_image::{Image, Kind};
use materialcraft_nodes::{CookContext, find};
use std::{
collections::BTreeMap,
sync::{Arc, Mutex},
};
/// The magenta image a failed node shows
pub fn error_image(w: u32, h: u32) -> Image {
Image::filled(w, h, Kind::Color, [1.0, 0.0, 1.0, 1.0])
}
/// Lock the cache, recovering from a poisoned lock (a cache entry is never half-written)
fn lock(cache: &Mutex<Cache>) -> std::sync::MutexGuard<'_, Cache> {
cache.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
}
pub(crate) fn cook_node(
package: &Package,
graph_index: usize,
prepared: &PreparedGraph<'_>,
node: &Node,
cooked: &Cooked,
graph_variables: &BTreeMap<String, Value>,
options: &Options,
cache: &Mutex<Cache>,
) -> NodeResult {
let (input_ports, output_ports) = prepared.ports(node.id);
let definition = find(&node.def);
// Gather inputs by port order, with their keys
let mut inputs = Vec::new();
let mut incoming = Vec::new();
let mut input_keys = Vec::new();
let mut variables = std::borrow::Cow::Borrowed(graph_variables);
let mut input_error = None;
for port in input_ports {
let source = prepared.index.input_of(node.id, &port.id).and_then(|connection| {
let result = cooked.nodes.get(&connection.from)?;
let index = prepared.ports(connection.from).1.iter().position(|output| output.id == connection.from_port)?;
Some((result.outputs.get(index)?, result.key ^ hash_of(&index)))
});
input_keys.push(source.as_ref().map_or(0, |source| source.1));
let output = source.map(|source| source.0);
let expected = node.input_values.get(&port.id).copied().or_else(|| {
node.instance
.as_ref()?
.inputs
.iter()
.find(|input| input.identifier == port.id)
.and_then(|input| materialcraft_core::ValueType::from_code(input.type_code))
});
if let Some(expected) = expected {
let value = match output.as_ref() {
Some(NodeOutput::Value(value)) if materialcraft_core::ValueType::of(value) == Some(expected) => value.clone(),
Some(_) => {
input_error = Some(format!("input `{}` requires {}", port.id, expected.label()));
expected.default_value()
}
None => expected.default_value(),
};
variables.to_mut().insert(port.id.clone(), value);
} else {
if output.as_ref().is_some_and(|output| output.as_value().is_some()) && !matches!(node.def.as_str(), "output" | "dot") {
input_error = Some(format!("input `{}` requires an image", port.id));
}
inputs.push(output.and_then(NodeOutput::as_image).cloned());
}
incoming.push(output);
}
let input_base = prepared.input_base(node.id, cooked);
let (mut base, base_values, base_error) = match crate::resolved_base_parameters::evaluate(&node.base, input_base, prepared.parent_base, &mut variables) {
Ok((base, values)) => (base, values, None),
Err(error) => (crate::ResolvedBaseParameters::resolve(&node.base, input_base, prepared.parent_base), BTreeMap::new(), Some(error)),
};
if node.disabled
&& let Some(input) = input_base
{
base = input;
}
let (w, h) = crate::node_size::limit(base.size, options.max_size);
let fail = |message: String, key: u64| NodeResult {
base,
base_values: base_values.clone(),
parameters: BTreeMap::new(),
outputs: Arc::new(vec![NodeOutput::Image(error_image(w, h)); output_ports.len().max(1)]),
error: Some(message),
ms: 0.0,
key,
cached: false,
};
if let Some(error) = base_error {
return fail(error, 0);
}
if let Some(error) = input_error {
return fail(error, 0);
}
if !node.functions.is_empty() || matches!(node.def.as_str(), "pixel_processor" | "value_processor" | "fx_map" | "transformation") {
base.variables(variables.to_mut());
}
let seed = base.seed;
let mut parameters = match resolve_parameters(package, node, definition, &mut variables, seed, base.size) {
Ok(parameters) => parameters,
Err(error) => return fail(error, 0),
};
let variables = &variables;
let tile = base.tiling[0] && base.tiling[1];
// Input nodes read the caller's image for their identifier
let input_image = node.def.starts_with("input_").then(|| options.inputs.get(&identifier(node))).flatten();
let resource_hash = match parameters.get("resource") {
Some(Value::Text(name)) => package.resource(name).map_or(0, |r| r.bytes.content_hash()),
_ => 0,
};
let registry = options.registry.unwrap_or(package);
let subgraph_hash = if node.def == "graph_instance" {
crate::graph_instance::resolve(registry, package, node).map_or(0, |(source, index, _)| graph_tree_hash_with_registry(registry, source, index))
} else {
0
};
let key = hash_of(&(
&node.def,
serde_json::to_string(&parameters).unwrap_or_default(),
(w, h, seed, tile, node.disabled, base.size, base.format, base.tiling, base.pixel_ratio, base.pixel_size.map(f32::to_bits)),
&input_keys,
resource_hash,
subgraph_hash,
// A cached graph instance includes results evaluated with its host environment
(node.def == "graph_instance").then(|| serde_json::to_string(&options.environment).unwrap_or_default()),
input_image.map(|image| image_key(image, cache)),
variable_key(node, &parameters, variables),
));
if let Some(outputs) = lock(cache).get(key) {
parameters.retain(|_, value| materialcraft_core::ValueType::of(value).is_some());
return NodeResult { base, base_values, parameters, outputs, error: None, ms: 0.0, key, cached: true };
}
let started_ms = now_ms();
let result: Result<Vec<NodeOutput>, String> = if node.disabled {
let input = if let Some(primary) = definition.and_then(|definition| definition.primary_input) {
input_ports.iter().position(|port| port.id == primary).and_then(|index| incoming.get(index)).copied().flatten()
} else {
incoming.iter().find_map(|output| *output)
};
let output = input.cloned().unwrap_or_else(|| NodeOutput::Image(Image::filled(w, h, Kind::Gray, [0.0; 4])));
Ok(vec![output; output_ports.len().max(1)])
} else if node.def == "input_value" {
let value = variables.get(&identifier(node)).or_else(|| parameters.get("default")).cloned().unwrap_or(Value::Float(0.0));
Ok(vec![NodeOutput::Value(value)])
} else if node.def == "value_processor" {
evaluate_value(&parameters, variables, seed, [w, h], &inputs, tile).map(|value| vec![NodeOutput::Value(value)])
} else if matches!(node.def.as_str(), "output" | "dot") && incoming.first().and_then(Option::as_ref).is_some_and(|output| output.as_value().is_some()) {
incoming.first().copied().flatten().cloned().map(|output| vec![output]).ok_or("missing value input".into())
} else if let Some(image) = input_image {
let mut image = if node.def == "input_grayscale" && image.kind == Kind::Color {
// Grayscale bridges use equal RGB weights and preserve fused float order
let weight = 1.0 / 3.0;
image.map(Kind::Gray, |pixel| [pixel[2].mul_add(weight, pixel[1].mul_add(weight, pixel[0] * weight)), 0.0, 0.0, 0.0])
} else if node.def == "input_color" {
image.to_color()
} else {
image.clone()
};
// Bound resources clamp edges through stored factor-two levels
// Preserve resampling and storage conversion for HDR bridges
let resized = image.w != w || image.h != h;
while image.w != w || image.h != h {
let next = |current: u32, target: u32| {
if current < target { current.saturating_mul(2).min(target) } else { current.div_ceil(2).max(target) }
};
image = crate::output_precision::apply(image.resize(next(image.w, w), next(image.h, h), false), base.format);
}
// Resized inputs already store the final level at the declared precision
let image = if resized { image } else { crate::output_precision::apply(image, base.format) };
Ok(vec![NodeOutput::Image(image)])
} else if node.def == materialcraft_core::MISSING_NODE {
let name = if node.label.is_empty() { "this node" } else { node.label.as_str() };
Err(format!("unsupported node `{name}`"))
} else if node.def == "graph_instance" {
cook_instance(package, graph_index, node, input_ports, output_ports, &incoming, &parameters, (w, h), base, options, cache)
} else if let Some(definition) = definition {
let context = CookContext { format: base.format, w, h, seed, tile, inputs: &inputs, params: &parameters, resource: options.resource, vars: variables };
(definition.cook)(&context).map(|images| {
images
.into_iter()
.map(|image| {
// Bridges retain their source pixels; filters store their declared precision
let image = if matches!(node.def.as_str(), "output" | "dot") { image } else { crate::output_precision::apply(image, base.format) };
NodeOutput::Image(image)
})
.collect()
})
} else {
Err(format!("unknown node `{}`", node.def))
};
// Cooked values serve parameter controls; authoring graphs stay in the document
parameters.retain(|_, value| materialcraft_core::ValueType::of(value).is_some());
match result {
Ok(outputs) if outputs.len() == output_ports.len().max(1) || output_ports.is_empty() => {
let outputs = Arc::new(outputs);
lock(cache).put(key, outputs.clone());
NodeResult { base, base_values, parameters, outputs, error: None, ms: (now_ms() - started_ms) as f32, key, cached: false }
}
Ok(outputs) => fail(format!("`{}` made {} images for {} outputs", node.def, outputs.len(), output_ports.len()), key),
Err(error) => fail(error, key),
}
}