mirror of
https://github.com/storytold/materialcraft.git
synced 2026-11-19 05:50:57 +01:00
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.
235 lines
11 KiB
Rust
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(¶meters).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, ¶meters, 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(¶meters, 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, ¶meters, (w, h), base, options, cache)
|
|
} else if let Some(definition) = definition {
|
|
let context = CookContext { format: base.format, w, h, seed, tile, inputs: &inputs, params: ¶meters, 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),
|
|
}
|
|
}
|