mirror of
https://github.com/storytold/materialcraft.git
synced 2026-11-19 05:50:57 +01:00
Remove comparison tooling and simplify node docs
This commit is contained in:
1 parent
04d1b3889f
commit
2adfed268f
37 files changed
+130
-18054
No files matched your search
Generated
-2
@@ -1507,7 +1507,6 @@ dependencies = [
|
||||
"miniz_oxide 0.8.9",
|
||||
"num-complex",
|
||||
"pulp",
|
||||
"rayon-core",
|
||||
"smallvec",
|
||||
"zune-inflate",
|
||||
]
|
||||
@@ -2704,7 +2703,6 @@ dependencies = [
|
||||
name = "materialcraft-engine"
|
||||
version = "0.4.1"
|
||||
dependencies = [
|
||||
"exr",
|
||||
"materialcraft-core",
|
||||
"materialcraft-eval",
|
||||
"materialcraft-formats",
|
||||
|
||||
@@ -178,13 +178,13 @@ The details are in [`docs/control-protocol.md`](docs/control-protocol.md).
|
||||
MaterialCraft is under active development. [**ROADMAP.md**](ROADMAP.md) has the parity estimate by
|
||||
area, the remaining work and what's next.
|
||||
|
||||
**Current focus (2026-11-15):** measured native catalog behavior and native SBS save/load. The old Rust
|
||||
**Current focus (2026-11-16):** node behavior, regression coverage and SBS save/load. The old Rust
|
||||
procedural library has been removed. The replacement includes 29 main-graph entries, 85 function
|
||||
operations and four pattern node kinds. Start with **File → New → Atomic sample**.
|
||||
|
||||
See [the primitive workflow](docs/atomic-workflow.md) for usage, validation scope and limitations.
|
||||
The [catalog audit](docs/node-catalog-parity.md) records measured cases and untested behavior.
|
||||
Broad reference-app rendering parity and arbitrary SBS interoperability remain unestablished.
|
||||
The [catalog status](docs/node-catalog-parity.md) records implemented behavior and remaining work.
|
||||
Full numerical compatibility and arbitrary SBS interoperability remain unestablished.
|
||||
|
||||
**Workspace:** `crates/{core, image, geom, nodes, eval, formats, engine, render, automation, ui-egui}`
|
||||
and `apps/{materialcraft, materialcraft-cli, materialcraft-web}`. The egui frontend is its own
|
||||
|
||||
+10
-11
@@ -1,30 +1,29 @@
|
||||
# MaterialCraft roadmap
|
||||
|
||||
**Current focus (2026-11-16):** measured native catalog behavior and interoperable save/load.
|
||||
**Current focus (2026-11-16):** node behavior, regression coverage and interoperable save/load.
|
||||
|
||||
The old Rust procedural library has been removed. The main catalog has 29 entries: 25 native
|
||||
primitives and four graph input/output items. Functions have 85 operations; pattern graphs have
|
||||
Quadrant, Switch, Iterate and Dot. See [the primitive workflow](docs/atomic-workflow.md) for usage and limits.
|
||||
|
||||
Earlier percentage estimates and node counts are superseded by this change. Reference-app
|
||||
rendering parity and arbitrary SBS round trips have not been established. The
|
||||
[catalog audit](docs/node-catalog-parity.md) inventories every native entry and loaded function,
|
||||
records original probe measurements, and lists behavior that remains untested.
|
||||
Earlier percentage estimates and node counts are superseded by this change. Full numerical
|
||||
compatibility and arbitrary SBS round trips have not been established. The
|
||||
[catalog status](docs/node-catalog-parity.md) records available nodes, implemented corrections
|
||||
and behavior that remains untested.
|
||||
|
||||
## Next steps
|
||||
|
||||
1. Verify the original atomic sample in the reference application
|
||||
2. Resolve the measured primitive, processor and map differences in the catalog audit
|
||||
3. Validate the converted standard library in the reference application and establish redistribution rights
|
||||
1. Extend atomic sample and SBS interoperability coverage
|
||||
2. Resolve the primitive, processor and map gaps in the catalog status
|
||||
3. Validate the converted standard library and establish redistribution rights
|
||||
4. Extend the SBS library beyond reusable functions to processing graphs
|
||||
|
||||
## Progress log
|
||||
|
||||
| Date | What landed |
|
||||
|---|---|
|
||||
| 2026-11-16 | Corrected Sharpen Float32 arithmetic and Shuffle selector/save-load behavior; measured reference backend and thread differences. [Exact cases and remaining limits](docs/atomic-exact-parity.md) |
|
||||
| 2026-11-16 | Corrected six atomic nodes: blur/sharpen kernels, radius and rectangular scaling, independent filter tiling, gray channel alpha, and empty Text/SVG backgrounds. [Measured cases and remaining differences](docs/atomic-parity-improvements.md) |
|
||||
| 2026-11-15 | Native catalog audit: 29 main entries, 85 functions, four map kinds, 954 inventoried package functions; 1,615 original probes with per-case numerical/error results, narrow default/input/serialization corrections and explicit remaining differences |
|
||||
| 2026-11-16 | Corrected six atomic nodes: filter kernels and Float32 arithmetic, rectangular scaling, independent tiling, channel selection and save/load, and empty Text/SVG backgrounds. [Behavior and validation](docs/atomic-parity-improvements.md) |
|
||||
| 2026-11-15 | Corrected node defaults, typed unconnected inputs, missing-texture output and SBS serialization; updated catalog counts and remaining validation scope |
|
||||
| 2026-11-08 | Explorer folder hierarchy and package/folder/graph context menus, native SBS empty folders and resource paths, undoable copy/move/rename/remove, and package reload/save-copy actions |
|
||||
| 2026-11-08 | Portable `sbs://` function instances in the Library, preserved package folders and missing references, and a converted library retaining all 171 supplied function bodies (2,334 nodes); external runtime equivalence and redistribution rights remain unverified |
|
||||
| 2026-11-02 | Cross-app materials: `.mcmat` portable materials, Send to TextureCraft, input-node preview images (mesh maps from TextureCraft), live re-cooks from TextureCraft through the CLI |
|
||||
|
||||
@@ -19,7 +19,3 @@ serde = { workspace = true }
|
||||
serde_json = { workspace = true }
|
||||
sha2 = { workspace = true }
|
||||
thiserror = { workspace = true }
|
||||
|
||||
[dev-dependencies]
|
||||
# BSD-3-Clause; read raw scalar as well as RGBA EXR channels in numerical probes
|
||||
exr = "1.74"
|
||||
@@ -1,125 +0,0 @@
|
||||
#![forbid(unsafe_code)]
|
||||
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
|
||||
|
||||
//! Original clean-room probes. No installed library graphs or assets are used.
|
||||
|
||||
#[path = "catalog_parity/atomic_cases.rs"]
|
||||
mod atomic_cases;
|
||||
#[path = "catalog_parity/cases.rs"]
|
||||
mod cases;
|
||||
#[path = "catalog_parity/comparison.rs"]
|
||||
mod comparison;
|
||||
#[path = "catalog_parity/control_cases.rs"]
|
||||
mod control_cases;
|
||||
#[path = "catalog_parity/function_cases.rs"]
|
||||
mod function_cases;
|
||||
#[path = "catalog_parity/kernel_cases.rs"]
|
||||
mod kernel_cases;
|
||||
#[path = "catalog_parity/measurement.rs"]
|
||||
mod measurement;
|
||||
#[path = "catalog_parity/pattern_cases.rs"]
|
||||
mod pattern_cases;
|
||||
#[path = "catalog_parity/processor_cases.rs"]
|
||||
mod processor_cases;
|
||||
#[path = "catalog_parity/recipe_cases.rs"]
|
||||
mod recipe_cases;
|
||||
#[path = "catalog_parity/reference_run.rs"]
|
||||
mod reference_run;
|
||||
#[path = "catalog_parity/supplemental_cases.rs"]
|
||||
mod supplemental_cases;
|
||||
|
||||
#[path = "catalog_parity/probe_case.rs"]
|
||||
mod probe_case;
|
||||
use probe_case::ProbeCase;
|
||||
use serde_json::json;
|
||||
use std::{collections::BTreeSet, path::Path, sync::Mutex};
|
||||
|
||||
type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
|
||||
|
||||
// Bound native renderer processes and their per-process memory
|
||||
const PROBE_WORKERS: usize = 4;
|
||||
const PROGRESS_INTERVAL_CASES: usize = 25;
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let args: Vec<_> = std::env::args().collect();
|
||||
let directory = args.get(1).ok_or("usage: catalog_parity <results-directory> [reference-tool-directory] [case-filter]")?;
|
||||
let directory = Path::new(directory);
|
||||
std::fs::create_dir_all(directory)?;
|
||||
let inventory = json!({
|
||||
"atomic": materialcraft_nodes::catalog().iter().map(|definition| json!({
|
||||
"id": definition.id,
|
||||
"inputs": definition.inputs.iter().map(|p| json!({"id": p.id, "kind": format!("{:?}", p.kind)})).collect::<Vec<_>>(),
|
||||
"outputs": definition.outputs.iter().map(|p| json!({"id": p.id, "kind": format!("{:?}", p.kind)})).collect::<Vec<_>>(),
|
||||
"parameters": definition.params.iter().map(|p| json!({"id": p.id, "default": p.default, "min": p.min, "max": p.max})).collect::<Vec<_>>(),
|
||||
})).collect::<Vec<_>>(),
|
||||
"function": materialcraft_nodes::function::FUNCTIONS.iter().map(|definition| json!({
|
||||
"id": definition.id, "inputs": definition.inputs, "default": materialcraft_nodes::function::default_value(definition.id),
|
||||
})).collect::<Vec<_>>(),
|
||||
"pattern": materialcraft_nodes::pattern::definitions().iter().map(|definition| json!({
|
||||
"id": definition.id,
|
||||
"parameters": definition.params.iter().map(|p| json!({"id": p.id, "default": p.default})).collect::<Vec<_>>(),
|
||||
})).collect::<Vec<_>>(),
|
||||
});
|
||||
std::fs::write(directory.join("inventory.json"), serde_json::to_vec_pretty(&inventory)?)?;
|
||||
let library = materialcraft_engine::NodeLibrary::shared();
|
||||
let library_inventory: Vec<_> = library
|
||||
.packages
|
||||
.iter()
|
||||
.flat_map(|(uri, package)| {
|
||||
package.graphs.iter().filter(|graph| graph.function.is_some()).map(move |graph| {
|
||||
json!({
|
||||
"package": uri, "path": graph.sbs_path(), "nodes": graph.function.as_ref().map_or(0, |f| f.nodes.len()),
|
||||
"status": "untested_library_graph", "hidden": graph.attributes.hide_in_library,
|
||||
})
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
std::fs::write(directory.join("library-inventory.json"), serde_json::to_vec_pretty(&library_inventory)?)?;
|
||||
let tools = args.get(2).map(Path::new);
|
||||
let filter = args.get(3).map(String::as_str).unwrap_or("");
|
||||
let available = if let Some(path) = std::env::var_os("MC_PARITY_CASE_FILE") { recipe_cases::read(Path::new(&path))? } else { cases::cases()? };
|
||||
let cases: Vec<_> = available.into_iter().filter(|case| case.name.contains(filter)).collect();
|
||||
let mut names = BTreeSet::new();
|
||||
for case in &cases {
|
||||
if !names.insert(&case.name) {
|
||||
return Err(format!("duplicate probe name: {}", case.name).into());
|
||||
}
|
||||
}
|
||||
if cases.is_empty() {
|
||||
return Err("no probes match the filter".into());
|
||||
}
|
||||
|
||||
let report = Mutex::new(Vec::<serde_json::Value>::new());
|
||||
std::thread::scope(|scope| -> Result<()> {
|
||||
let mut workers = Vec::new();
|
||||
for group in cases.chunks(cases.len().div_ceil(PROBE_WORKERS)) {
|
||||
let report = &report;
|
||||
let total = cases.len();
|
||||
workers.push(scope.spawn(move || -> std::result::Result<(), String> {
|
||||
for case in group {
|
||||
let result = match measurement::measure(case, directory, tools) {
|
||||
Ok(result) => result,
|
||||
Err(error) => json!({"case": case.name, "status": "harness_error", "error": error.to_string()}),
|
||||
};
|
||||
let mut report = report.lock().map_err(|_| "probe report lock is poisoned")?;
|
||||
report.push(result);
|
||||
let bytes = serde_json::to_vec_pretty(&*report).map_err(|error| error.to_string())?;
|
||||
std::fs::write(directory.join("report.json"), bytes).map_err(|error| error.to_string())?;
|
||||
if report.len() % PROGRESS_INTERVAL_CASES == 0 || report.len() == total {
|
||||
println!("measured {} / {total}", report.len());
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}));
|
||||
}
|
||||
for worker in workers {
|
||||
worker.join().map_err(|_| "probe worker panicked")??;
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
let mut report = report.into_inner().map_err(|_| "probe report lock is poisoned")?;
|
||||
report.sort_by(|a, b| a["case"].as_str().cmp(&b["case"].as_str()));
|
||||
std::fs::write(directory.join("report.json"), serde_json::to_vec_pretty(&report)?)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@@ -1,79 +0,0 @@
|
||||
use super::{ProbeCase, Result};
|
||||
use materialcraft_core::Value;
|
||||
use materialcraft_nodes::PortKind;
|
||||
|
||||
fn connected(id: &str, suffix: &str, size: [u32; 2], gray: bool, tile: [bool; 2]) -> Result<(ProbeCase, materialcraft_core::NodeId)> {
|
||||
let mut case = ProbeCase::new(&format!("atomic_{id}_{suffix}"));
|
||||
case.graph.size = size;
|
||||
case.graph.tiling = tile;
|
||||
let source = case.graph.add_node(id, [0.0, 0.0]);
|
||||
if id == "text" {
|
||||
case.graph.node_mut(source)?.params.insert("text".into(), Value::Text(String::new()));
|
||||
}
|
||||
let definition = materialcraft_nodes::find(id).ok_or("missing definition")?;
|
||||
for port in &definition.inputs {
|
||||
if port.kind != PortKind::Value {
|
||||
case.image_input(source, port.id, port.kind == PortKind::Gray || (gray && port.kind != PortKind::Color))?;
|
||||
}
|
||||
}
|
||||
case.finish(source)?;
|
||||
Ok((case, source))
|
||||
}
|
||||
|
||||
pub(super) fn cases() -> Result<Vec<ProbeCase>> {
|
||||
let mut result = Vec::new();
|
||||
for definition in materialcraft_nodes::catalog() {
|
||||
if matches!(definition.id, "input_color" | "input_grayscale" | "input_value" | "output" | "value_processor" | "pixel_processor" | "fx_map") {
|
||||
continue;
|
||||
}
|
||||
for size in [[4, 4], [5, 4], [6, 6]] {
|
||||
for gray in [false, true] {
|
||||
for tile in [[false, false], [true, true], [true, false], [false, true]] {
|
||||
let suffix =
|
||||
format!("connected_{}x{}_{}_tile{}{}", size[0], size[1], if gray { "gray" } else { "color" }, u8::from(tile[0]), u8::from(tile[1]));
|
||||
result.push(connected(definition.id, &suffix, size, gray, tile)?.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
for parameter in &definition.params {
|
||||
let values: Vec<Value> = match ¶meter.default {
|
||||
Value::Float(_) => vec![Value::Float(parameter.min), Value::Float(parameter.max)],
|
||||
Value::Int(_) => vec![Value::Int(parameter.min as i32), Value::Int(parameter.max as i32)],
|
||||
Value::Float2(_) => vec![Value::Float2([parameter.min; 2]), Value::Float2([parameter.max; 2])],
|
||||
Value::Float4(_) => vec![Value::Float4([parameter.min; 4]), Value::Float4([parameter.max; 4])],
|
||||
Value::Color(_) => vec![Value::Color([0.0; 4]), Value::Color([1.0; 4])],
|
||||
Value::Bool(_) => vec![Value::Bool(false), Value::Bool(true)],
|
||||
Value::Enum(_) => {
|
||||
// Retain the original selector-9 probe after removing unsupported catalog choices
|
||||
let upper = if definition.id == "channels_shuffle" { 9 } else { parameter.options.len().saturating_sub(1) as u32 };
|
||||
vec![Value::Enum(0), Value::Enum(upper)]
|
||||
}
|
||||
_ => Vec::new(),
|
||||
};
|
||||
for (index, value) in values.into_iter().enumerate() {
|
||||
let (mut case, source) = connected(definition.id, &format!("param_{}_boundary{index}", parameter.id), [5, 4], false, [true, true])?;
|
||||
case.graph.node_mut(source)?.params.insert(parameter.id.into(), value);
|
||||
result.push(case);
|
||||
}
|
||||
}
|
||||
if definition.id == "blend" {
|
||||
let modes = definition.param("mode").ok_or("missing blending modes")?;
|
||||
for index in 0..modes.options.len() {
|
||||
let (mut case, source) = connected("blend", &format!("mode{index}"), [5, 4], false, [true, true])?;
|
||||
case.graph.node_mut(source)?.params.insert("mode".into(), Value::Enum(index as u32));
|
||||
result.push(case);
|
||||
}
|
||||
}
|
||||
if definition.id == "normal" {
|
||||
for opengl in [false, true] {
|
||||
let (mut case, source) = connected("normal", &format!("vertical_opengl{opengl}"), [4, 4], true, [false, false])?;
|
||||
for image in case.inputs.values_mut() {
|
||||
*image = materialcraft_image::Image::gray(16, 16, |_, y| y as f32 / 15.0);
|
||||
}
|
||||
case.graph.node_mut(source)?.params.insert("opengl".into(), Value::Bool(opengl));
|
||||
result.push(case);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(result)
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
use super::{ProbeCase, Result};
|
||||
use materialcraft_core::{FunctionGraph, Value};
|
||||
|
||||
pub(super) fn cases() -> Result<Vec<ProbeCase>> {
|
||||
let mut result = Vec::new();
|
||||
for definition in materialcraft_nodes::catalog() {
|
||||
let mut case = ProbeCase::new(&format!("atomic_{}_unconnected", definition.id));
|
||||
let source = case.graph.add_node(definition.id, [0.0, 0.0]);
|
||||
// Empty text exercises compositing without depending on an installed font
|
||||
if definition.id == "text" {
|
||||
case.graph.node_mut(source)?.params.insert("text".into(), Value::Text(String::new()));
|
||||
}
|
||||
if definition.id == "output" {
|
||||
case.output = source;
|
||||
case.graph.node_mut(source)?.params.insert("identifier".into(), Value::Text("result".into()));
|
||||
} else {
|
||||
case.finish(source)?;
|
||||
}
|
||||
result.push(case);
|
||||
}
|
||||
let mut case = ProbeCase::new("value_constant");
|
||||
let source = case.graph.add_node("value_processor", [0.0, 0.0]);
|
||||
case.graph.node_mut(source)?.params.insert("function".into(), Value::Function(Box::new(FunctionGraph::constant(Value::Float(0.375)))));
|
||||
case.finish(source)?;
|
||||
result.push(case);
|
||||
result.extend(super::function_cases::cases()?);
|
||||
result.extend(super::processor_cases::cases()?);
|
||||
result.extend(super::atomic_cases::cases()?);
|
||||
result.extend(super::control_cases::cases()?);
|
||||
result.extend(super::pattern_cases::cases()?);
|
||||
result.extend(super::supplemental_cases::cases()?);
|
||||
result.extend(super::kernel_cases::cases()?);
|
||||
Ok(result)
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
use materialcraft_core::Value;
|
||||
use serde_json::{Value as Json, json};
|
||||
|
||||
pub(super) fn typed(local: &Value, output: &Json) -> Json {
|
||||
let (kind, values): (&str, Vec<Json>) = match local {
|
||||
Value::Float(v) => ("float", vec![json!(v)]),
|
||||
Value::Float2(v) => ("float2", v.iter().map(|v| json!(v)).collect()),
|
||||
Value::Float3(v) => ("float3", v.iter().map(|v| json!(v)).collect()),
|
||||
Value::Float4(v) => ("float4", v.iter().map(|v| json!(v)).collect()),
|
||||
Value::Int(v) => ("int", vec![json!(v)]),
|
||||
Value::Int2(v) => ("int2", v.iter().map(|v| json!(v)).collect()),
|
||||
Value::Int3(v) => ("int3", v.iter().map(|v| json!(v)).collect()),
|
||||
Value::Int4(v) => ("int4", v.iter().map(|v| json!(v)).collect()),
|
||||
Value::Bool(v) => ("bool", vec![json!(v)]),
|
||||
Value::Text(v) => ("string", vec![json!(v)]),
|
||||
_ => return json!({"status": "unsupported_local_value"}),
|
||||
};
|
||||
let reference = output.get("value").map(|value| value.as_array().cloned().unwrap_or_else(|| vec![value.clone()])).unwrap_or_default();
|
||||
let type_match = output["type"].as_str() == Some(kind);
|
||||
let mut mismatches = values.len().abs_diff(reference.len());
|
||||
let mut max_error = 0.0_f64;
|
||||
let mut unavailable_numeric_components = 0;
|
||||
for (a, b) in values.iter().zip(&reference) {
|
||||
if kind.starts_with("float") {
|
||||
match (a.as_f64(), b.as_f64()) {
|
||||
(Some(a), Some(b)) => {
|
||||
let (a, b) = (a as f32, b as f32);
|
||||
|
||||
// JSON value reports do not preserve the sign of zero
|
||||
if a != b {
|
||||
mismatches += 1;
|
||||
}
|
||||
max_error = max_error.max((f64::from(a) - f64::from(b)).abs());
|
||||
}
|
||||
_ => {
|
||||
unavailable_numeric_components += 1;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if a != b {
|
||||
mismatches += 1;
|
||||
}
|
||||
if let (Some(a), Some(b)) = (a.as_i64(), b.as_i64()) {
|
||||
max_error = max_error.max((a as f64 - b as f64).abs());
|
||||
}
|
||||
}
|
||||
}
|
||||
let numeric = kind.starts_with("float") || kind.starts_with("int");
|
||||
let max_error = if numeric && unavailable_numeric_components == 0 && values.len() == reference.len() { json!(max_error) } else { Json::Null };
|
||||
|
||||
let status = if unavailable_numeric_components != 0 {
|
||||
"unmeasurable_value"
|
||||
} else if mismatches == 0 && type_match {
|
||||
"exact_value"
|
||||
} else {
|
||||
"value_mismatch"
|
||||
};
|
||||
|
||||
json!({"status": status, "type_match": type_match, "samples": values.len(),
|
||||
"mismatches": if unavailable_numeric_components == 0 { json!(mismatches) } else { Json::Null },
|
||||
"known_mismatches": mismatches, "max_error": max_error,
|
||||
"unavailable_numeric_components": unavailable_numeric_components})
|
||||
}
|
||||
@@ -1,117 +0,0 @@
|
||||
use super::{ProbeCase, Result};
|
||||
use materialcraft_core::{FunctionGraph, Value, ValueType};
|
||||
|
||||
pub(super) fn cases() -> Result<Vec<ProbeCase>> {
|
||||
let mut cases = Vec::new();
|
||||
for pixel in [false, true] {
|
||||
for branch in [false, true] {
|
||||
let mut graph = FunctionGraph::default();
|
||||
let a = graph.add_constant(Value::Float(0.25));
|
||||
let b = graph.add_constant(Value::Float(0.75));
|
||||
let set_a = graph.add("set", &[a], Some(Value::Text("counter".into())));
|
||||
let set_b = graph.add("set", &[b], Some(Value::Text("counter".into())));
|
||||
let condition = graph.add_constant(Value::Bool(branch));
|
||||
let choose = graph.add("ifelse", &[condition, set_a, set_b], None);
|
||||
let read = graph.add("get_float1", &[], Some(Value::Text("counter".into())));
|
||||
graph.output = Some(graph.add("sequence", &[choose, read], None));
|
||||
cases.push(ProbeCase::function(&format!("control_lazy_branch_pixel{pixel}_{branch}"), graph, pixel)?);
|
||||
}
|
||||
let mut graph = FunctionGraph::default();
|
||||
let get = graph.add("get_float1", &[], Some(Value::Text("counter".into())));
|
||||
let a = graph.add_constant(Value::Float(0.75));
|
||||
let set = graph.add("set", &[a], Some(Value::Text("counter".into())));
|
||||
let after = graph.add("sequence", &[set, get], None);
|
||||
graph.output = Some(graph.add("sequence", &[get, after], None));
|
||||
cases.push(ProbeCase::function(&format!("control_shared_get_pixel{pixel}"), graph, pixel)?);
|
||||
let mut graph = FunctionGraph::default();
|
||||
let get = graph.add("get_float1", &[], Some(Value::Text("counter".into())));
|
||||
let snapshot = graph.add("set", &[get], Some(Value::Text("snapshot".into())));
|
||||
let value = graph.add_constant(Value::Float(0.75));
|
||||
let set = graph.add("set", &[value], Some(Value::Text("counter".into())));
|
||||
let read_snapshot = graph.add("get_float1", &[], Some(Value::Text("snapshot".into())));
|
||||
let sum = graph.add("add", &[read_snapshot, get], None);
|
||||
let after_set = graph.add("sequence", &[set, sum], None);
|
||||
graph.output = Some(graph.add("sequence", &[snapshot, after_set], None));
|
||||
cases.push(ProbeCase::function(&format!("control_observable_snapshot_pixel{pixel}"), graph, pixel)?);
|
||||
for condition in [false, true] {
|
||||
let mut graph = FunctionGraph::default();
|
||||
let initial = graph.add_constant(Value::Float(0.25));
|
||||
let condition_node = graph.add_constant(Value::Bool(condition));
|
||||
let body = graph.add_constant(Value::Float(0.75));
|
||||
graph.output = Some(graph.add("while", &[initial, condition_node, body], Some(Value::Int(3))));
|
||||
cases.push(ProbeCase::function(&format!("control_constant_loop_pixel{pixel}_condition{condition}"), graph, pixel)?);
|
||||
}
|
||||
for limit in [0, 1, 3, -1] {
|
||||
let mut graph = FunctionGraph::default();
|
||||
let zero = graph.add_constant(Value::Float(0.0));
|
||||
let init = graph.add("set", &[zero], Some(Value::Text("counter".into())));
|
||||
let read_cond = graph.add("get_float1", &[], Some(Value::Text("counter".into())));
|
||||
let three = graph.add_constant(Value::Float(3.0));
|
||||
let condition = graph.add("gteq", &[read_cond, three], None);
|
||||
let read_body = graph.add("get_float1", &[], Some(Value::Text("counter".into())));
|
||||
let step = graph.add_constant(Value::Float(1.0));
|
||||
let next = graph.add("add", &[read_body, step], None);
|
||||
let body = graph.add("set", &[next], Some(Value::Text("counter".into())));
|
||||
graph.output = Some(graph.add("while", &[init, condition, body], Some(Value::Int(limit))));
|
||||
cases.push(ProbeCase::function(&format!("control_loop_pixel{pixel}_limit{limit}"), graph, pixel)?);
|
||||
}
|
||||
for (index, (op, a, b)) in [("div", 0.0, 0.0), ("div", 1.0, 0.0), ("sqrt", -1.0, 0.0)].into_iter().enumerate() {
|
||||
let mut graph = FunctionGraph::default();
|
||||
let a = graph.add_constant(Value::Float(a));
|
||||
let b = graph.add_constant(Value::Float(b));
|
||||
graph.output = Some(if op == "sqrt" { graph.add(op, &[a], None) } else { graph.add(op, &[a, b], None) });
|
||||
cases.push(ProbeCase::function(&format!("nonfinite_{op}_pixel{pixel}_case{index}"), graph, pixel)?);
|
||||
}
|
||||
}
|
||||
for op in ["const_string", "get_string", "set"] {
|
||||
let mut graph = FunctionGraph::constant(Value::Text("original probe".into()));
|
||||
let text = graph.output.ok_or("missing string")?;
|
||||
let value = if op == "const_string" {
|
||||
text
|
||||
} else {
|
||||
let set = graph.add("set", &[text], Some(Value::Text("local_text".into())));
|
||||
if op == "set" {
|
||||
set
|
||||
} else {
|
||||
let get = graph.add("get_string", &[], Some(Value::Text("local_text".into())));
|
||||
graph.add("sequence", &[set, get], None)
|
||||
}
|
||||
};
|
||||
graph.output = Some(graph.add("eq", &[value, text], None));
|
||||
cases.push(ProbeCase::function(&format!("string_{op}_equality"), graph, false)?);
|
||||
}
|
||||
for operation in ["vector2", "vector3", "vector4", "ivector2", "ivector3", "ivector4"] {
|
||||
for missing in [0, 1] {
|
||||
let mut graph = FunctionGraph::default();
|
||||
let constant = graph.add_constant(if operation.starts_with('i') { Value::Int(7) } else { Value::Float(0.75) });
|
||||
let output = graph.add(operation, &[], None);
|
||||
if let Some(node) = graph.nodes.last_mut() {
|
||||
node.inputs = if missing == 0 { vec![None, Some(constant)] } else { vec![Some(constant), None] };
|
||||
}
|
||||
graph.output = Some(output);
|
||||
cases.push(ProbeCase::function(&format!("partial_{operation}_missing{missing}"), graph, false)?);
|
||||
}
|
||||
}
|
||||
let mut graph = FunctionGraph::default();
|
||||
let read = graph.add("get_float1", &[], Some(Value::Text("signal".into())));
|
||||
let two = graph.add_constant(Value::Float(2.0));
|
||||
graph.output = Some(graph.add("mul", &[read, two], None));
|
||||
let mut child = ProbeCase::function("nested_value_to_pixel", graph, true)?;
|
||||
let pixel = materialcraft_core::NodeId(1);
|
||||
child.graph.node_mut(pixel)?.input_values.insert("signal".into(), ValueType::Float);
|
||||
let value = child.graph.add_node("value_processor", [-200.0, 0.0]);
|
||||
child.graph.node_mut(value)?.params.insert("function".into(), Value::Function(Box::new(FunctionGraph::constant(Value::Float(0.375)))));
|
||||
child.graph.connect(value, "output", pixel, "signal")?;
|
||||
cases.push(child);
|
||||
let mut outer = ProbeCase::new("nested_material_processors");
|
||||
let mut child = cases.last().ok_or("missing processor graph")?.graph.clone();
|
||||
child.name = "child_processors".into();
|
||||
let instance = outer.graph.add_node("graph_instance", [0.0, 0.0]);
|
||||
outer.graph.node_mut(instance)?.params.insert("graph".into(), Value::Text(child.name.clone()));
|
||||
outer.output = outer.graph.add_node("output", [200.0, 0.0]);
|
||||
outer.graph.node_mut(outer.output)?.params.insert("identifier".into(), Value::Text("result".into()));
|
||||
outer.graph.connect(instance, "result", outer.output, "input")?;
|
||||
outer.children.push(child);
|
||||
cases.push(outer);
|
||||
Ok(cases)
|
||||
}
|
||||
@@ -1,128 +0,0 @@
|
||||
use super::{ProbeCase, Result};
|
||||
use materialcraft_core::{FunctionGraph, Value};
|
||||
use materialcraft_nodes::function::{FUNCTIONS, default_value};
|
||||
|
||||
fn operation(op: &str, arguments: &[Value], setting: Option<Value>) -> FunctionGraph {
|
||||
let mut graph = FunctionGraph::default();
|
||||
let sources: Vec<_> = arguments.iter().map(|value| graph.add_constant(value.clone())).collect();
|
||||
let id = graph.add(op, &sources, setting);
|
||||
graph.output = Some(if op == "passthrough" { graph.add("sequence", &[id, id], None) } else { id });
|
||||
graph
|
||||
}
|
||||
|
||||
pub(super) fn cases() -> Result<Vec<ProbeCase>> {
|
||||
let mut result = Vec::new();
|
||||
for definition in FUNCTIONS {
|
||||
let op = definition.id;
|
||||
let mut setting = default_value(op);
|
||||
let mut arguments = vec![Value::Float(0.375); definition.inputs.len()];
|
||||
match op {
|
||||
"and" | "or" | "not" => arguments.fill(Value::Bool(true)),
|
||||
"atan2" | "samplecol" | "samplelum" => arguments = vec![Value::Float2([0.25, 0.75])],
|
||||
"dot" => arguments = vec![Value::Float2([0.25, 0.75]), Value::Float2([0.5, 0.125])],
|
||||
"vector3" => arguments = vec![Value::Float2([0.125, 0.25]), Value::Float(0.75)],
|
||||
"vector4" => arguments = vec![Value::Float2([0.125, 0.25]), Value::Float2([0.5, 0.75])],
|
||||
"ivector2" => arguments = vec![Value::Int(-3), Value::Int(7)],
|
||||
"ivector3" => arguments = vec![Value::Int2([-3, 7]), Value::Int(19)],
|
||||
"ivector4" => arguments = vec![Value::Int2([-3, 7]), Value::Int2([19, 23])],
|
||||
"tofloat" => arguments = vec![Value::Int(-7)],
|
||||
"tofloat2" => arguments = vec![Value::Int2([-7, 3])],
|
||||
"tofloat3" => arguments = vec![Value::Int3([-7, 3, 19])],
|
||||
"tofloat4" => arguments = vec![Value::Int4([-7, 3, 19, 23])],
|
||||
"toint1" => arguments = vec![Value::Float(-1.75)],
|
||||
"toint2" => arguments = vec![Value::Float2([-1.75, 2.75])],
|
||||
"toint3" => arguments = vec![Value::Float3([-1.75, 2.75, 0.0])],
|
||||
"toint4" => arguments = vec![Value::Float4([-1.75, 2.75, 0.0, -0.0])],
|
||||
"ifelse" => arguments = vec![Value::Bool(false), Value::Float(0.125), Value::Float(0.875)],
|
||||
"while" => arguments = vec![Value::Float(0.125), Value::Bool(false), Value::Float(0.875)],
|
||||
_ if op.starts_with("iswizzle") => arguments = vec![Value::Int4([-3, 7, 19, 23])],
|
||||
_ if op.starts_with("swizzle") => arguments = vec![Value::Float4([0.125, 0.25, 0.5, 0.75])],
|
||||
_ => {}
|
||||
}
|
||||
if op.starts_with("get_") || matches!(op, "set" | "isdefined") {
|
||||
setting = Some(Value::Text("audit_variable".into()));
|
||||
}
|
||||
let mut function = operation(op, &arguments, setting.clone());
|
||||
if op.starts_with("get_") || op == "isdefined" {
|
||||
let value = match op {
|
||||
"get_bool" => Value::Bool(true),
|
||||
"get_string" => Value::Text("original probe".into()),
|
||||
"get_integer1" => Value::Int(16_777_217),
|
||||
"get_integer2" => Value::Int2([-3, 7]),
|
||||
"get_integer3" => Value::Int3([-3, 7, 19]),
|
||||
"get_integer4" => Value::Int4([-3, 7, 19, 23]),
|
||||
"get_float2" => Value::Float2([0.125, 0.25]),
|
||||
"get_float3" => Value::Float3([0.125, 0.25, 0.5]),
|
||||
"get_float4" => Value::Float4([0.125, 0.25, 0.5, 0.75]),
|
||||
_ => Value::Float(0.375),
|
||||
};
|
||||
let value = function.add_constant(value);
|
||||
let set = function.add("set", &[value], setting.clone());
|
||||
function.output = Some(function.add("sequence", &[set, 1], None));
|
||||
}
|
||||
let mut case = ProbeCase::function(&format!("function_{op}_nominal"), function, false)?;
|
||||
if matches!(op, "samplecol" | "samplelum") {
|
||||
case.image_input(materialcraft_core::NodeId(1), "input0", op == "samplelum")?;
|
||||
}
|
||||
result.push(case);
|
||||
|
||||
let mut function = operation(op, &[], setting);
|
||||
if let Some(node) = function.nodes.first_mut() {
|
||||
node.inputs.resize(definition.inputs.len(), None);
|
||||
}
|
||||
result.push(ProbeCase::function(&format!("function_{op}_unconnected"), function, false)?);
|
||||
}
|
||||
for op in ["add", "sub", "mul", "div", "mod", "min", "max", "pow", "dot"] {
|
||||
for (index, (a, b)) in [(-2.75, 2.0), (0.0, 0.0), (1.0, 0.0), (f32::MAX, 2.0), (1e-30, 1e-20)].into_iter().enumerate() {
|
||||
result.push(ProbeCase::function(&format!("function_{op}_boundary{index}"), operation(op, &[Value::Float(a), Value::Float(b)], None), false)?);
|
||||
}
|
||||
for (name, a, b) in [
|
||||
("float2", Value::Float2([-0.25, 2.5]), Value::Float2([0.5, -0.75])),
|
||||
("float3", Value::Float3([-0.25, 2.5, 4.0]), Value::Float3([0.5, -0.75, 8.0])),
|
||||
("float4", Value::Float4([-0.25, 2.5, 4.0, 0.0]), Value::Float4([0.5, -0.75, 8.0, 1.0])),
|
||||
("integer", Value::Int(-7), Value::Int(3)),
|
||||
("integer2", Value::Int2([-7, 8]), Value::Int2([3, -3])),
|
||||
("integer3", Value::Int3([-7, 8, 16_777_217]), Value::Int3([3, -3, 1])),
|
||||
("integer4", Value::Int4([-7, 8, 16_777_217, 0]), Value::Int4([3, -3, 1, 1])),
|
||||
] {
|
||||
result.push(ProbeCase::function(&format!("function_{op}_{name}"), operation(op, &[a, b], None), false)?);
|
||||
}
|
||||
}
|
||||
for op in ["neg", "abs", "floor", "ceil", "sqrt", "log", "log2", "exp", "pow2", "sin", "cos", "tan"] {
|
||||
for (index, a) in [-1.5, -0.0, 0.0, 0.5, 1.0, 2.0, f32::MAX, f32::MIN_POSITIVE].into_iter().enumerate() {
|
||||
result.push(ProbeCase::function(&format!("function_{op}_boundary{index}"), operation(op, &[Value::Float(a)], None), false)?);
|
||||
}
|
||||
result.push(ProbeCase::function(&format!("function_{op}_float4"), operation(op, &[Value::Float4([-1.5, 0.0, 0.5, 2.0])], None), false)?);
|
||||
}
|
||||
for op in ["add", "sub", "mul", "div", "mod", "abs", "neg"] {
|
||||
for (index, a, b) in [(0, i32::MAX, 1), (1, i32::MIN, -1), (2, 1, 0)] {
|
||||
let args = if matches!(op, "abs" | "neg") { vec![Value::Int(a)] } else { vec![Value::Int(a), Value::Int(b)] };
|
||||
result.push(ProbeCase::function(&format!("function_{op}_integer_boundary{index}"), operation(op, &args, None), false)?);
|
||||
}
|
||||
}
|
||||
for op in ["eq", "noteq", "gt", "gteq", "lr", "lreq"] {
|
||||
for (index, a, b) in [
|
||||
(0, Value::Int(16_777_217), Value::Int(16_777_216)),
|
||||
(1, Value::Bool(true), Value::Bool(false)),
|
||||
(2, Value::Text("original probe".into()), Value::Text("original probe".into())),
|
||||
(3, Value::Float2([1.0, 2.0]), Value::Float2([1.0, 3.0])),
|
||||
(4, Value::Int(1), Value::Float(1.0)),
|
||||
] {
|
||||
result.push(ProbeCase::function(&format!("function_{op}_types{index}"), operation(op, &[a, b], None), false)?);
|
||||
}
|
||||
}
|
||||
for op in ["and", "or"] {
|
||||
for (index, a, b) in [(0, false, false), (1, false, true), (2, true, false)] {
|
||||
result.push(ProbeCase::function(&format!("function_{op}_bool{index}"), operation(op, &[Value::Bool(a), Value::Bool(b)], None), false)?);
|
||||
}
|
||||
}
|
||||
for op in ["toint1", "tofloat"] {
|
||||
for (index, value) in [Value::Float(0.0), Value::Float(-0.5), Value::Float(2147483648.0), Value::Int(i32::MIN), Value::Int(i32::MAX), Value::Bool(true)]
|
||||
.into_iter()
|
||||
.enumerate()
|
||||
{
|
||||
result.push(ProbeCase::function(&format!("function_{op}_conversion{index}"), operation(op, &[value], None), false)?);
|
||||
}
|
||||
}
|
||||
Ok(result)
|
||||
}
|
||||
@@ -1,156 +0,0 @@
|
||||
use super::{ProbeCase, Result};
|
||||
use materialcraft_core::{OutputFormat, Value};
|
||||
use materialcraft_image::{Image, Kind};
|
||||
|
||||
pub(super) fn cases() -> Result<Vec<ProbeCase>> {
|
||||
let mut cases = Vec::new();
|
||||
for operation in ["blur", "directional_blur", "sharpen"] {
|
||||
for size in [4, 6, 8] {
|
||||
for intensity in [0.0, 1.0, 4.0, 10.0] {
|
||||
let mut case = ProbeCase::new(&format!("kernel_{operation}_size{size}_intensity{intensity}"));
|
||||
case.graph.size = [size, size];
|
||||
let source = case.graph.add_node(operation, [0.0; 2]);
|
||||
case.graph.node_mut(source)?.params.insert("intensity".into(), Value::Float(intensity));
|
||||
case.image_input(source, "input", true)?;
|
||||
let side = 1 << size;
|
||||
for image in case.inputs.values_mut() {
|
||||
*image = Image::gray(side, side, |x, y| f32::from(x == side / 2 && y == side / 2));
|
||||
}
|
||||
case.finish(source)?;
|
||||
cases.push(case);
|
||||
}
|
||||
}
|
||||
}
|
||||
for channel in 0..10 {
|
||||
let mut case = ProbeCase::new(&format!("kernel_shuffle_gray_channel{channel}"));
|
||||
let source = case.graph.add_node("channels_shuffle", [0.0; 2]);
|
||||
for name in ["red", "green", "blue", "alpha"] {
|
||||
case.graph.node_mut(source)?.params.insert(name.into(), Value::Enum(channel));
|
||||
}
|
||||
case.image_input(source, "input1", true)?;
|
||||
case.image_input(source, "input2", true)?;
|
||||
for (index, image) in case.inputs.values_mut().enumerate() {
|
||||
*image = Image::filled(16, 16, Kind::Gray, [if index == 0 { 0.25 } else { 0.75 }; 4]);
|
||||
}
|
||||
case.finish(source)?;
|
||||
cases.push(case);
|
||||
}
|
||||
for operation in ["text", "svg"] {
|
||||
for color in [false, true] {
|
||||
for gray_input in [false, true] {
|
||||
let mut case = ProbeCase::new(&format!("kernel_{operation}_background_color{color}_gray{gray_input}"));
|
||||
let source = case.graph.add_node(operation, [0.0; 2]);
|
||||
case.graph.node_mut(source)?.params.insert("color_mode".into(), Value::Bool(color));
|
||||
if operation == "text" {
|
||||
case.graph.node_mut(source)?.params.insert("text".into(), Value::Text(String::new()));
|
||||
}
|
||||
case.image_input(source, "background", gray_input)?;
|
||||
for image in case.inputs.values_mut() {
|
||||
*image = Image::filled(16, 16, if gray_input { Kind::Gray } else { Kind::Color }, [0.25, 0.5, 0.75, 0.125]);
|
||||
}
|
||||
case.finish(source)?;
|
||||
cases.push(case);
|
||||
}
|
||||
}
|
||||
}
|
||||
cases.extend(detail_cases()?);
|
||||
cases.extend(boundary_cases()?);
|
||||
Ok(cases)
|
||||
}
|
||||
|
||||
fn boundary_cases() -> Result<Vec<ProbeCase>> {
|
||||
let mut cases = Vec::new();
|
||||
for operation in ["blur", "directional_blur", "sharpen", "channels_shuffle"] {
|
||||
for size in [[5, 4], [4, 5]] {
|
||||
for format in [OutputFormat::U8, OutputFormat::U16, OutputFormat::F16, OutputFormat::F32] {
|
||||
let mut case = ProbeCase::new(&format!("kernel_boundary_{operation}_{}x{}_{format:?}", size[0], size[1]));
|
||||
case.graph.size = size;
|
||||
case.graph.format = format;
|
||||
let source = case.graph.add_node(operation, [0.0; 2]);
|
||||
if operation != "channels_shuffle" {
|
||||
case.graph.node_mut(source)?.params.insert("intensity".into(), Value::Float(10.0));
|
||||
}
|
||||
case.image_input(source, if operation == "channels_shuffle" { "input1" } else { "input" }, false)?;
|
||||
let (w, h) = (1 << size[0], 1 << size[1]);
|
||||
for image in case.inputs.values_mut() {
|
||||
*image = Image::generate(w, h, Kind::Color, |x, y| if [x, y] == [w / 2, h / 2] { [1.0, 0.0, 2.0, 0.25] } else { [0.0, 0.5, -0.5, 0.75] });
|
||||
}
|
||||
case.finish(source)?;
|
||||
cases.push(case);
|
||||
}
|
||||
}
|
||||
for (label, value) in [("nan", f32::NAN), ("positive_infinity", f32::INFINITY), ("negative_infinity", f32::NEG_INFINITY)] {
|
||||
let mut case = ProbeCase::new(&format!("kernel_nonfinite_{operation}_{label}"));
|
||||
let source = case.graph.add_node(operation, [0.0; 2]);
|
||||
case.image_input(source, if operation == "channels_shuffle" { "input1" } else { "input" }, true)?;
|
||||
for image in case.inputs.values_mut() {
|
||||
*image = Image::gray(16, 16, |x, y| if x == 8 && y == 8 { value } else { 0.25 });
|
||||
}
|
||||
case.finish(source)?;
|
||||
cases.push(case);
|
||||
}
|
||||
}
|
||||
Ok(cases)
|
||||
}
|
||||
|
||||
fn detail_cases() -> Result<Vec<ProbeCase>> {
|
||||
let mut cases = Vec::new();
|
||||
for operation in ["blur", "directional_blur", "sharpen"] {
|
||||
for size in [[4, 4], [5, 4], [8, 8]] {
|
||||
for tile in [false, true] {
|
||||
for edge in [false, true] {
|
||||
for color in [false, true] {
|
||||
let mut case = ProbeCase::new(&format!("kernel_detail_{operation}_{}x{}_tile{tile}_edge{edge}_color{color}", size[0], size[1]));
|
||||
case.graph.size = size;
|
||||
case.graph.tiling = [tile; 2];
|
||||
let source = case.graph.add_node(operation, [0.0; 2]);
|
||||
case.graph.node_mut(source)?.params.insert("intensity".into(), Value::Float(1.0));
|
||||
case.image_input(source, "input", !color)?;
|
||||
let (w, h) = (1 << size[0], 1 << size[1]);
|
||||
let center = if edge { [0, 0] } else { [w / 2, h / 2] };
|
||||
for image in case.inputs.values_mut() {
|
||||
*image = Image::generate(w, h, if color { Kind::Color } else { Kind::Gray }, |x, y| {
|
||||
let impulse = if [x, y] == center { 0.0625 } else { 0.0 };
|
||||
[0.5 + impulse, 0.25 - impulse, 2.0 + impulse, 0.5 + impulse]
|
||||
});
|
||||
}
|
||||
case.finish(source)?;
|
||||
cases.push(case);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for intensity in [0.25, 0.5, 0.75, 1.5, 2.75, 10.0] {
|
||||
for angle in [0.0, 0.125, 0.25, 0.333] {
|
||||
let mut case = ProbeCase::new(&format!("kernel_directional_angle{angle}_intensity{intensity}"));
|
||||
case.graph.size = [8, 8];
|
||||
let source = case.graph.add_node("directional_blur", [0.0; 2]);
|
||||
case.graph.node_mut(source)?.params.insert("intensity".into(), Value::Float(intensity));
|
||||
case.graph.node_mut(source)?.params.insert("angle".into(), Value::Float(angle));
|
||||
case.image_input(source, "input", true)?;
|
||||
for image in case.inputs.values_mut() {
|
||||
*image = Image::gray(256, 256, |x, y| f32::from(x == 128 && y == 128));
|
||||
}
|
||||
case.finish(source)?;
|
||||
cases.push(case);
|
||||
}
|
||||
}
|
||||
for operation in ["text", "svg"] {
|
||||
for color in [false, true] {
|
||||
for gray_input in [false, true] {
|
||||
let mut case = ProbeCase::new(&format!("kernel_{operation}_fallback_color{color}_gray{gray_input}"));
|
||||
let source = case.graph.add_node(operation, [0.0; 2]);
|
||||
case.graph.node_mut(source)?.params.insert("color_mode".into(), Value::Bool(color));
|
||||
case.graph.node_mut(source)?.params.insert("background".into(), Value::Color([0.125, 0.25, 0.5, 0.75]));
|
||||
case.image_input(source, "background", gray_input)?;
|
||||
for image in case.inputs.values_mut() {
|
||||
*image = Image::filled(16, 16, if gray_input { Kind::Gray } else { Kind::Color }, [0.25, 0.5, 0.75, 0.0]);
|
||||
}
|
||||
case.finish(source)?;
|
||||
cases.push(case);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(cases)
|
||||
}
|
||||
@@ -1,166 +0,0 @@
|
||||
use super::{ProbeCase, Result};
|
||||
use materialcraft_eval::{Cache, Options, cook};
|
||||
use serde_json::{Value, json};
|
||||
use std::{path::Path, sync::Mutex};
|
||||
|
||||
pub(super) fn measure(case: &ProbeCase, root: &Path, tools: Option<&Path>) -> Result<Value> {
|
||||
let directory = root.join(&case.name);
|
||||
std::fs::create_dir_all(&directory)?;
|
||||
let package = case.package();
|
||||
let source = directory.join("probe.sbs");
|
||||
let bytes = materialcraft_formats::sbs::write_sbs(&package)?;
|
||||
std::fs::write(&source, &bytes)?;
|
||||
let resource = |key: &str| {
|
||||
let (name, linear) = materialcraft_image::split_resource_key(key);
|
||||
package.resource(name).and_then(|r| materialcraft_formats::decode(r.bytes.as_slice(), linear).ok())
|
||||
};
|
||||
let mut options = Options::new(&resource);
|
||||
options.inputs.clone_from(&case.inputs);
|
||||
let cooked = cook(&package, 0, &options, &Mutex::new(Cache::default()));
|
||||
let errors: Vec<_> = cooked.nodes.values().filter_map(|node| node.error.as_ref()).collect();
|
||||
let mut report = json!({"case": case.name, "status": "untested", "local_errors": errors,
|
||||
"local_value": cooked.value(case.output, 0)});
|
||||
let Some(tools) = tools else { return Ok(report) };
|
||||
|
||||
let measured = super::reference_run::measure(case, &directory, tools, bytes)?;
|
||||
report["transport_header_version"] = super::reference_run::REFERENCE_FORMAT_VERSION.into();
|
||||
report["reference_engine"] = measured.engine.into();
|
||||
report["reference_cpu_count"] = json!(measured.cpu_count);
|
||||
report["cached_reference"] = measured.cached.into();
|
||||
if measured.status != "measured" {
|
||||
report["status"] = measured.status.into();
|
||||
return Ok(report);
|
||||
}
|
||||
|
||||
let path = directory.join("result.exr");
|
||||
if path.exists()
|
||||
&& let Some(local) = cooked.image(case.output, 0)
|
||||
{
|
||||
let (reference, reference_channels) = read_exr(&path)?;
|
||||
if std::env::var_os("MC_PARITY_DUMP_PIXELS").is_some() {
|
||||
std::fs::write(
|
||||
directory.join("pixels.json"),
|
||||
serde_json::to_vec(&json!({
|
||||
"inputs": case.inputs.iter().map(|(name, image)| (name, json!({"size": [image.w, image.h], "kind": format!("{:?}", image.kind), "pixels": &*image.data}))).collect::<std::collections::BTreeMap<_, _>>(),
|
||||
"local": {"size": [local.w, local.h], "kind": format!("{:?}", local.kind), "pixels": &*local.data},
|
||||
"reference": {"size": [reference.w, reference.h], "kind": format!("{:?}", reference.kind), "pixels": &*reference.data},
|
||||
}))?,
|
||||
)?;
|
||||
}
|
||||
|
||||
report["reference_channels"] = json!(reference_channels);
|
||||
report["local_size"] = json!([local.w, local.h]);
|
||||
report["reference_size"] = json!([reference.w, reference.h]);
|
||||
if (local.w, local.h) != (reference.w, reference.h) {
|
||||
report["status"] = "size_mismatch".into();
|
||||
return Ok(report);
|
||||
}
|
||||
|
||||
if !errors.is_empty() {
|
||||
report["status"] = "local_error".into();
|
||||
return Ok(report);
|
||||
}
|
||||
|
||||
report["kind_match"] = (local.kind == reference.kind).into();
|
||||
if local.kind != reference.kind {
|
||||
report["status"] = "kind_mismatch".into();
|
||||
return Ok(report);
|
||||
}
|
||||
|
||||
let channels: Vec<usize> = if local.is_gray() || reference.is_gray() {
|
||||
vec![0]
|
||||
} else {
|
||||
["R", "G", "B", "A"]
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(index, name)| reference_channels.iter().any(|channel| channel == name).then_some(index))
|
||||
.collect()
|
||||
};
|
||||
if channels.is_empty() {
|
||||
return Err("reference EXR has no comparable channels".into());
|
||||
}
|
||||
|
||||
let mut mismatches = 0_u64;
|
||||
let mut pixel_mismatches = 0_u64;
|
||||
let mut max_error = 0.0_f64;
|
||||
let mut non_finite_mismatches = 0_u64;
|
||||
for y in 0..local.h {
|
||||
for x in 0..local.w {
|
||||
let a = local.get(i64::from(x), i64::from(y), false);
|
||||
let b = reference.get(i64::from(x), i64::from(y), false);
|
||||
let mut changed = false;
|
||||
for (_, (a, b)) in a.into_iter().zip(b).enumerate().filter(|(index, _)| channels.contains(index)) {
|
||||
if a.to_bits() != b.to_bits() {
|
||||
changed = true;
|
||||
mismatches += 1;
|
||||
if a.is_finite() && b.is_finite() {
|
||||
max_error = max_error.max((f64::from(a) - f64::from(b)).abs());
|
||||
} else {
|
||||
non_finite_mismatches += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
pixel_mismatches += u64::from(changed);
|
||||
}
|
||||
}
|
||||
report["channels"] = channels.len().into();
|
||||
report["samples"] = (u64::from(local.w) * u64::from(local.h) * channels.len() as u64).into();
|
||||
report["mismatches"] = mismatches.into();
|
||||
report["pixel_mismatches"] = pixel_mismatches.into();
|
||||
report["max_finite_error"] = max_error.into();
|
||||
report["max_error"] = if non_finite_mismatches == 0 { max_error.into() } else { Value::Null };
|
||||
report["non_finite_mismatches"] = non_finite_mismatches.into();
|
||||
report["unmeasured_alpha"] = (!local.is_gray() && !reference_channels.iter().any(|channel| channel == "A")).into();
|
||||
report["status"] = if mismatches == 0 && local.kind == reference.kind {
|
||||
if !local.is_gray() && channels.len() < 4 { "exact_available_channels" } else { "exact" }
|
||||
} else {
|
||||
"pixel_mismatch"
|
||||
}
|
||||
.into();
|
||||
report["local_first"] = json!(local.get(0, 0, false));
|
||||
report["reference_first"] = json!(reference.get(0, 0, false));
|
||||
} else {
|
||||
let text = String::from_utf8_lossy(&measured.stdout);
|
||||
let start = text.find("[\r\n {").or_else(|| text.find("[\n {"));
|
||||
let data = start.and_then(|start| serde_json::from_str::<Value>(&text[start..]).ok());
|
||||
let output = data.as_ref().and_then(|data| data.get(0)).and_then(|graph| graph.get("outputs")).and_then(|outputs| outputs.get(0));
|
||||
if let (Some(local), Some(output)) = (cooked.value(case.output, 0), output) {
|
||||
let metrics = super::comparison::typed(local, output);
|
||||
if let Some(metrics) = metrics.as_object() {
|
||||
for (key, value) in metrics {
|
||||
report[key] = value.clone();
|
||||
}
|
||||
}
|
||||
report["reference_value"] = output.clone();
|
||||
} else {
|
||||
report["reference_value"] = output.cloned().unwrap_or(Value::Null);
|
||||
report["status"] = if errors.is_empty() { "reference_value_unread" } else { "local_error" }.into();
|
||||
}
|
||||
}
|
||||
Ok(report)
|
||||
}
|
||||
|
||||
fn read_exr(path: &Path) -> Result<(materialcraft_image::Image, Vec<String>)> {
|
||||
use materialcraft_image::{Image, Kind};
|
||||
let image = exr::prelude::read_first_flat_layer_from_file(path)?;
|
||||
let layer = image.layer_data;
|
||||
let channels: std::collections::BTreeMap<_, Vec<_>> =
|
||||
layer.channel_data.list.iter().map(|channel| (channel.name.to_string(), channel.sample_data.values_as_f32().collect())).collect();
|
||||
let (w, h) = (u32::try_from(layer.size.0)?, u32::try_from(layer.size.1)?);
|
||||
let names: Vec<_> = channels.keys().cloned().collect();
|
||||
if channels.len() == 1 {
|
||||
let values = channels.values().next().ok_or("empty EXR")?;
|
||||
return Ok((Image { w, h, kind: Kind::Gray, integer_sampling: false, data: std::sync::Arc::new(values.clone()) }, names));
|
||||
}
|
||||
let image = Image::generate(w, h, Kind::Color, |x, y| {
|
||||
std::array::from_fn(|channel| {
|
||||
let name = ["R", "G", "B", "A"].get(channel).copied().unwrap_or("");
|
||||
channels.get(name).and_then(|values| values.get((y as usize) * (w as usize) + (x as usize))).copied().unwrap_or(if channel == 3 {
|
||||
1.0
|
||||
} else {
|
||||
0.0
|
||||
})
|
||||
})
|
||||
});
|
||||
Ok((image, names))
|
||||
}
|
||||
@@ -1,143 +0,0 @@
|
||||
use super::{ProbeCase, Result};
|
||||
use materialcraft_core::{FunctionGraph, OutputFormat, PatternGraph, PatternNodeKind, Resource, ResourceBytes, Value};
|
||||
|
||||
fn square(graph: &mut PatternGraph, depth: usize) -> Result<()> {
|
||||
let node = graph.nodes.get_mut(depth).ok_or("missing pattern")?;
|
||||
node.parameters.insert("patterntype".into(), Value::Int(2));
|
||||
node.parameters.insert("opacity".into(), Value::Float4([0.375, 0.5, 0.75, 1.0]));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn pattern_case(name: &str, graph: PatternGraph, color: bool, size: [u32; 2], roughness: f32, seed: i32) -> Result<ProbeCase> {
|
||||
let mut case = ProbeCase::new(name);
|
||||
case.graph.size = size;
|
||||
case.graph.seed = seed;
|
||||
let source = case.graph.add_node("fx_map", [0.0, 0.0]);
|
||||
let node = case.graph.node_mut(source)?;
|
||||
node.params.insert("pattern".into(), Value::PatternGraph(Box::new(graph)));
|
||||
node.params.insert("color_mode".into(), Value::Bool(color));
|
||||
node.params.insert("roughness".into(), Value::Float(roughness));
|
||||
case.finish(source)?;
|
||||
Ok(case)
|
||||
}
|
||||
|
||||
pub(super) fn cases() -> Result<Vec<ProbeCase>> {
|
||||
let mut cases = Vec::new();
|
||||
for shape in 2..=18 {
|
||||
for color in [false, true] {
|
||||
for size in [[4, 4], [5, 4]] {
|
||||
let mut graph = PatternGraph::with_root(PatternNodeKind::Quadrant);
|
||||
square(&mut graph, 0)?;
|
||||
let node = graph.nodes.first_mut().ok_or("missing quadrant")?;
|
||||
node.parameters.insert("patterntype".into(), Value::Int(shape));
|
||||
node.parameters.insert("patternsize".into(), Value::Float2([0.625, 0.75]));
|
||||
node.parameters.insert("patternrotation".into(), Value::Float(0.125));
|
||||
node.parameters.insert("patternsuppl".into(), Value::Float(0.5));
|
||||
cases.push(pattern_case(&format!("fx_shape{shape}_color{color}_{}x{}", size[0], size[1]), graph, color, size, 1.0, 0)?);
|
||||
}
|
||||
}
|
||||
}
|
||||
for depth in 0..=2 {
|
||||
for roughness in [0.0, 0.5, 1.0] {
|
||||
for seed in [0, 7] {
|
||||
let mut graph = PatternGraph::with_root(PatternNodeKind::Quadrant);
|
||||
for index in 0..depth {
|
||||
let child = graph.add(PatternNodeKind::Quadrant)?;
|
||||
graph.nodes.get_mut(index).ok_or("missing ancestor")?.children.fill(Some(child));
|
||||
}
|
||||
square(&mut graph, depth)?;
|
||||
cases.push(pattern_case(&format!("fx_depth{depth}_rough{roughness}_seed{seed}"), graph, false, [5, 4], roughness, seed)?);
|
||||
}
|
||||
}
|
||||
}
|
||||
for seed in [0, 1, 7, -1] {
|
||||
let mut graph = PatternGraph::with_root(PatternNodeKind::Quadrant);
|
||||
square(&mut graph, 0)?;
|
||||
let mut random = FunctionGraph::default();
|
||||
let one = random.add_constant(Value::Float(1.0));
|
||||
random.output = Some(random.add("rand", &[one], None));
|
||||
graph.nodes.first_mut().ok_or("missing quadrant")?.parameters.insert("opacity".into(), Value::Function(Box::new(random)));
|
||||
cases.push(pattern_case(&format!("fx_random_seed{seed}"), graph, false, [4, 4], 1.0, seed)?);
|
||||
}
|
||||
for variable in materialcraft_nodes::function::SystemVariable::ALL {
|
||||
let mut graph = PatternGraph::with_root(PatternNodeKind::Quadrant);
|
||||
square(&mut graph, 0)?;
|
||||
let mut function = FunctionGraph::input(variable.name(), variable.value_type());
|
||||
let output = function.output.ok_or("missing variable")?;
|
||||
function.output = Some(match variable.value_type() {
|
||||
materialcraft_core::ValueType::Float2 | materialcraft_core::ValueType::Float3 => function.add("swizzle1", &[output], Some(Value::Int(0))),
|
||||
materialcraft_core::ValueType::Integer => function.add("tofloat", &[output], None),
|
||||
materialcraft_core::ValueType::Integer2 => {
|
||||
let first = function.add("iswizzle1", &[output], Some(Value::Int(0)));
|
||||
function.add("tofloat", &[first], None)
|
||||
}
|
||||
_ => output,
|
||||
});
|
||||
graph.nodes.first_mut().ok_or("missing quadrant")?.parameters.insert("opacity".into(), Value::Function(Box::new(function)));
|
||||
cases.push(pattern_case(&format!("fx_scope_{}", variable.name().trim_start_matches('$')), graph, false, [5, 4], 1.0, 0)?);
|
||||
}
|
||||
for branch in [false, true] {
|
||||
let mut graph = PatternGraph::with_root(PatternNodeKind::Switch);
|
||||
let left = graph.add(PatternNodeKind::Quadrant)?;
|
||||
let right = graph.add(PatternNodeKind::Quadrant)?;
|
||||
graph.nodes.first_mut().ok_or("missing switch")?.children = vec![Some(left), Some(right)];
|
||||
graph.nodes.first_mut().ok_or("missing switch")?.parameters.insert("switch".into(), Value::Bool(branch));
|
||||
square(&mut graph, 1)?;
|
||||
square(&mut graph, 2)?;
|
||||
graph.nodes.get_mut(2).ok_or("missing right branch")?.parameters.insert("opacity".into(), Value::Float4([0.75; 4]));
|
||||
cases.push(pattern_case(&format!("fx_switch_{branch}"), graph, false, [4, 4], 1.0, 0)?);
|
||||
}
|
||||
for count in [0, 1, 4] {
|
||||
let mut graph = PatternGraph::with_root(PatternNodeKind::Iterate);
|
||||
let child = graph.add(PatternNodeKind::Quadrant)?;
|
||||
graph.nodes.first_mut().ok_or("missing iterate")?.children = vec![None, Some(child)];
|
||||
graph.nodes.first_mut().ok_or("missing iterate")?.parameters.insert("numberadded".into(), Value::Int(count));
|
||||
square(&mut graph, 1)?;
|
||||
let mut function = FunctionGraph::default();
|
||||
let current = function.add("get_float1", &[], Some(Value::Text("audit_counter".into())));
|
||||
let step = function.add_constant(Value::Float(0.125));
|
||||
let next = function.add("add", &[current, step], None);
|
||||
function.output = Some(function.add("set", &[next], Some(Value::Text("audit_counter".into()))));
|
||||
graph.nodes.get_mut(1).ok_or("missing leaf")?.parameters.insert("opacity".into(), Value::Function(Box::new(function)));
|
||||
cases.push(pattern_case(&format!("fx_iterate_assignments_{count}"), graph, false, [4, 4], 1.0, 0)?);
|
||||
}
|
||||
let mut graph = PatternGraph::with_root(PatternNodeKind::Quadrant);
|
||||
square(&mut graph, 0)?;
|
||||
graph.nodes.first_mut().ok_or("missing quadrant")?.parameters.insert("patterntype".into(), Value::Int(1));
|
||||
let mut case = pattern_case("fx_nested_pixel_input", graph, false, [5, 4], 1.0, 0)?;
|
||||
let mut function = FunctionGraph::default();
|
||||
let position = function.add("get_float2", &[], Some(Value::Text("$pos".into())));
|
||||
function.output = Some(function.add("swizzle1", &[position], Some(Value::Int(0))));
|
||||
let pixel = case.graph.add_node("pixel_processor", [-200.0, 0.0]);
|
||||
case.graph.node_mut(pixel)?.params.insert("function".into(), Value::Function(Box::new(function)));
|
||||
case.graph.node_mut(pixel)?.params.insert("color_mode".into(), Value::Bool(false));
|
||||
case.graph.connect(pixel, "output", materialcraft_core::NodeId(1), "pattern0")?;
|
||||
cases.push(case);
|
||||
for (id, file, bytes) in [
|
||||
("bitmap", "original.pgm", b"P2\n4 4\n255\n0 85 170 255\n255 170 85 0\n0 255 0 255\n255 0 255 0\n".to_vec()),
|
||||
(
|
||||
"svg",
|
||||
"original.svg",
|
||||
b"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\"><rect x=\"2\" y=\"3\" width=\"8\" height=\"10\" fill=\"#4080c0\"/></svg>"
|
||||
.to_vec(),
|
||||
),
|
||||
] {
|
||||
for size in [[4, 4], [5, 4], [6, 6]] {
|
||||
let mut case = ProbeCase::new(&format!("resource_{id}_{}x{}", size[0], size[1]));
|
||||
case.graph.size = size;
|
||||
let source = case.graph.add_node(id, [0.0, 0.0]);
|
||||
case.graph.node_mut(source)?.params.insert("resource".into(), Value::Text("original".into()));
|
||||
case.resources.push(Resource::new("original", file, ResourceBytes::new(bytes.clone())));
|
||||
case.finish(source)?;
|
||||
cases.push(case);
|
||||
}
|
||||
}
|
||||
for format in [OutputFormat::U8, OutputFormat::U16, OutputFormat::F16] {
|
||||
let mut graph = PatternGraph::with_root(PatternNodeKind::Quadrant);
|
||||
square(&mut graph, 0)?;
|
||||
let mut case = pattern_case(&format!("fx_precision_{format:?}"), graph, false, [4, 4], 1.0, 0)?;
|
||||
case.graph.format = format;
|
||||
cases.push(case);
|
||||
}
|
||||
Ok(cases)
|
||||
}
|
||||
@@ -1,72 +0,0 @@
|
||||
use super::Result;
|
||||
use materialcraft_core::{Graph, OutputFormat, Package, Value};
|
||||
|
||||
pub(super) struct ProbeCase {
|
||||
pub(super) name: String,
|
||||
pub(super) graph: Graph,
|
||||
pub(super) output: materialcraft_core::NodeId,
|
||||
pub(super) inputs: std::collections::BTreeMap<String, materialcraft_image::Image>,
|
||||
pub(super) children: Vec<Graph>,
|
||||
pub(super) resources: Vec<materialcraft_core::Resource>,
|
||||
}
|
||||
|
||||
impl ProbeCase {
|
||||
pub(super) fn new(name: &str) -> Self {
|
||||
let mut graph = Graph::new("probe");
|
||||
graph.size = [4, 4];
|
||||
graph.format = OutputFormat::F32;
|
||||
graph.tiling_mode = materialcraft_core::ParameterInheritance::Absolute;
|
||||
|
||||
Self { name: name.into(), graph, output: materialcraft_core::NodeId(0), inputs: Default::default(), children: Vec::new(), resources: Vec::new() }
|
||||
}
|
||||
|
||||
pub(super) fn finish(&mut self, source: materialcraft_core::NodeId) -> Result<()> {
|
||||
self.output = self.graph.add_node("output", [400.0, 0.0]);
|
||||
self.graph.node_mut(self.output)?.params.insert("identifier".into(), Value::Text("result".into()));
|
||||
self.graph.node_mut(self.output)?.params.insert("usage".into(), Value::Enum(9));
|
||||
self.graph.connect(source, "output", self.output, "input")?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) fn function(name: &str, function: materialcraft_core::FunctionGraph, pixel: bool) -> Result<Self> {
|
||||
let mut case = Self::new(name);
|
||||
let source = case.graph.add_node(if pixel { "pixel_processor" } else { "value_processor" }, [0.0, 0.0]);
|
||||
case.graph.node_mut(source)?.params.insert("function".into(), Value::Function(Box::new(function)));
|
||||
if pixel {
|
||||
case.graph.node_mut(source)?.params.insert("color_mode".into(), Value::Bool(false));
|
||||
}
|
||||
|
||||
case.finish(source)?;
|
||||
|
||||
Ok(case)
|
||||
}
|
||||
|
||||
pub(super) fn image_input(&mut self, target: materialcraft_core::NodeId, port: &str, gray: bool) -> Result<()> {
|
||||
use materialcraft_image::{Image, Kind};
|
||||
let name = format!("image{}", self.inputs.len());
|
||||
let input = self.graph.add_node(if gray { "input_grayscale" } else { "input_color" }, [-200.0, self.inputs.len() as f32 * 120.0]);
|
||||
self.graph.node_mut(input)?.params.insert("identifier".into(), Value::Text(name.clone()));
|
||||
|
||||
let w = 1_u32.checked_shl(self.graph.size[0]).ok_or("invalid width")?;
|
||||
let h = 1_u32.checked_shl(self.graph.size[1]).ok_or("invalid height")?;
|
||||
let image = Image::generate(w, h, if gray { Kind::Gray } else { Kind::Color }, |x, y| {
|
||||
let u = x as f32 / (w - 1).max(1) as f32;
|
||||
let v = y as f32 / (h - 1).max(1) as f32;
|
||||
[u, v, if (x / 3 + y / 5) % 2 == 0 { 0.125 } else { 0.875 }, 0.25 + 0.75 * v]
|
||||
});
|
||||
self.inputs.insert(name, image);
|
||||
self.graph.connect(input, "output", target, port)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) fn package(&self) -> Package {
|
||||
let mut package = Package::new("Original numerical probe");
|
||||
package.graphs.push(self.graph.clone());
|
||||
package.graphs.extend(self.children.clone());
|
||||
package.resources.clone_from(&self.resources);
|
||||
|
||||
package
|
||||
}
|
||||
}
|
||||
@@ -1,111 +0,0 @@
|
||||
use super::{ProbeCase, Result};
|
||||
use materialcraft_core::{FunctionGraph, OutputFormat, PatternGraph, PatternNodeKind, Value};
|
||||
|
||||
pub(super) fn cases() -> Result<Vec<ProbeCase>> {
|
||||
let mut result = Vec::new();
|
||||
for size in [[4, 4], [5, 4], [6, 6]] {
|
||||
for format in [OutputFormat::U8, OutputFormat::U16, OutputFormat::F16, OutputFormat::F32] {
|
||||
for seed in [0, 7, -1] {
|
||||
let mut graph = FunctionGraph::default();
|
||||
let position = graph.add("get_float2", &[], Some(Value::Text("$pos".into())));
|
||||
graph.output = Some(graph.add("swizzle1", &[position], Some(Value::Int(0))));
|
||||
let mut case = ProbeCase::function(&format!("pixel_position_{}x{}_{format:?}_seed{seed}", size[0], size[1]), graph, true)?;
|
||||
case.graph.size = size;
|
||||
case.graph.format = format;
|
||||
case.graph.seed = seed;
|
||||
result.push(case);
|
||||
let mut graph = FunctionGraph::default();
|
||||
let one = graph.add_constant(Value::Float(1.0));
|
||||
graph.output = Some(graph.add("rand", &[one], None));
|
||||
let mut case = ProbeCase::function(&format!("pixel_random_{}x{}_{format:?}_seed{seed}", size[0], size[1]), graph, true)?;
|
||||
case.graph.size = size;
|
||||
case.graph.format = format;
|
||||
case.graph.seed = seed;
|
||||
result.push(case);
|
||||
}
|
||||
}
|
||||
}
|
||||
for variable in materialcraft_nodes::function::SystemVariable::ALL {
|
||||
for pixel in [false, true] {
|
||||
let value_type = variable.value_type();
|
||||
let graph = FunctionGraph::input(variable.name(), value_type);
|
||||
let name = format!("scope_{}_{}", if pixel { "pixel" } else { "value" }, variable.name().trim_start_matches('$'));
|
||||
if pixel {
|
||||
let mut graph = graph;
|
||||
let output = graph.output.ok_or("missing variable output")?;
|
||||
let scalar = match value_type {
|
||||
materialcraft_core::ValueType::Float2 | materialcraft_core::ValueType::Float3 => graph.add("swizzle1", &[output], Some(Value::Int(0))),
|
||||
materialcraft_core::ValueType::Integer => graph.add("tofloat", &[output], None),
|
||||
materialcraft_core::ValueType::Integer2 => {
|
||||
let first = graph.add("iswizzle1", &[output], Some(Value::Int(0)));
|
||||
graph.add("tofloat", &[first], None)
|
||||
}
|
||||
_ => output,
|
||||
};
|
||||
graph.output = Some(scalar);
|
||||
result.push(ProbeCase::function(&name, graph, true)?);
|
||||
} else {
|
||||
result.push(ProbeCase::function(&name, graph, false)?);
|
||||
}
|
||||
}
|
||||
}
|
||||
for filter in [0, 1] {
|
||||
for tile in [[false, false], [true, true], [true, false], [false, true]] {
|
||||
for position in [[0.0, 0.0], [1.0, 1.0], [-0.125, 1.125], [0.125, 0.375]] {
|
||||
for gray in [false, true] {
|
||||
let mut graph = FunctionGraph::default();
|
||||
let pos = graph.add_constant(Value::Float2(position));
|
||||
graph.output = Some(graph.add(if gray { "samplelum" } else { "samplecol" }, &[pos], Some(Value::Int2([0, filter]))));
|
||||
let mut case = ProbeCase::function(
|
||||
&format!(
|
||||
"sample_{}_filter{filter}_tile{}{}_pos{}_{}",
|
||||
if gray { "gray" } else { "color" },
|
||||
u8::from(tile[0]),
|
||||
u8::from(tile[1]),
|
||||
position[0],
|
||||
position[1]
|
||||
),
|
||||
graph.clone(),
|
||||
false,
|
||||
)?;
|
||||
case.graph.tiling = tile;
|
||||
case.image_input(materialcraft_core::NodeId(1), "input0", gray)?;
|
||||
let mut pixel_case = ProbeCase::function(&format!("pixel_{}", case.name), graph, true)?;
|
||||
pixel_case.graph.tiling = tile;
|
||||
pixel_case.graph.node_mut(materialcraft_core::NodeId(1))?.params.insert("color_mode".into(), Value::Bool(!gray));
|
||||
pixel_case.image_input(materialcraft_core::NodeId(1), "input0", gray)?;
|
||||
result.push(case);
|
||||
result.push(pixel_case);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for kind in [PatternNodeKind::Quadrant, PatternNodeKind::Switch, PatternNodeKind::Iterate, PatternNodeKind::Dot] {
|
||||
for size in [[4, 4], [5, 4], [6, 6]] {
|
||||
let mut case = ProbeCase::new(&format!("pattern_{}_{}x{}", kind.native_id(), size[0], size[1]));
|
||||
case.graph.size = size;
|
||||
let source = case.graph.add_node("fx_map", [0.0, 0.0]);
|
||||
let mut graph = PatternGraph::with_root(kind);
|
||||
if kind != PatternNodeKind::Quadrant {
|
||||
let child = graph.add(PatternNodeKind::Quadrant)?;
|
||||
if let Some(root) = graph.nodes.first_mut() {
|
||||
root.children.fill(Some(child));
|
||||
if kind == PatternNodeKind::Iterate {
|
||||
root.parameters.insert("numberadded".into(), Value::Int(3));
|
||||
}
|
||||
}
|
||||
}
|
||||
for node in &mut graph.nodes {
|
||||
if node.kind == PatternNodeKind::Quadrant {
|
||||
node.parameters.insert("patterntype".into(), Value::Int(2));
|
||||
node.parameters.insert("patternsize".into(), Value::Float2([0.5, 0.75]));
|
||||
node.parameters.insert("opacity".into(), Value::Float4([0.375, 0.375, 0.375, 1.0]));
|
||||
}
|
||||
}
|
||||
case.graph.node_mut(source)?.params.insert("pattern".into(), Value::PatternGraph(Box::new(graph)));
|
||||
case.finish(source)?;
|
||||
result.push(case);
|
||||
}
|
||||
}
|
||||
Ok(result)
|
||||
}
|
||||
@@ -1,151 +0,0 @@
|
||||
use super::{ProbeCase, Result};
|
||||
use materialcraft_core::{OutputFormat, ParameterInheritance, Value};
|
||||
use materialcraft_image::{Image, Kind};
|
||||
use serde_json::Value as Json;
|
||||
use std::{collections::BTreeMap, io::Read, path::Path};
|
||||
|
||||
// Original, bounded recipes allow numerical experiments without recompiling the runner
|
||||
const MAX_CASES: usize = 2048;
|
||||
const MAX_SIZE_LOG2: u32 = 10;
|
||||
const MAX_RECIPE_BYTES: u64 = 16 * 1024 * 1024;
|
||||
const MAX_INPUT_COMPONENTS: u64 = 32 * 1024 * 1024;
|
||||
|
||||
pub(super) fn read(path: &Path) -> Result<Vec<ProbeCase>> {
|
||||
let mut bytes = Vec::new();
|
||||
std::fs::File::open(path)?.take(MAX_RECIPE_BYTES + 1).read_to_end(&mut bytes)?;
|
||||
if bytes.len() as u64 > MAX_RECIPE_BYTES {
|
||||
return Err("probe recipe file exceeds the byte limit".into());
|
||||
}
|
||||
|
||||
let recipes: Vec<Json> = serde_json::from_slice(&bytes)?;
|
||||
if recipes.len() > MAX_CASES {
|
||||
return Err("too many probe recipes".into());
|
||||
}
|
||||
|
||||
// Bound all resident input images before allocating any probe graphs
|
||||
let mut components = 0_u64;
|
||||
for recipe in &recipes {
|
||||
let size: [u32; 2] = field(recipe, "size", [4, 4])?;
|
||||
if size.iter().any(|side| *side > MAX_SIZE_LOG2) {
|
||||
return Err("recipe exceeds the image size limit".into());
|
||||
}
|
||||
|
||||
for input in recipe["inputs"].as_array().into_iter().flatten() {
|
||||
let channels = if field(input, "gray", true)? { 1 } else { 4 };
|
||||
components = components.saturating_add((1_u64 << (size[0] + size[1])) * channels);
|
||||
if components > MAX_INPUT_COMPONENTS {
|
||||
return Err("probe inputs exceed the total component limit".into());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
recipes.iter().map(case).collect()
|
||||
}
|
||||
|
||||
fn case(recipe: &Json) -> Result<ProbeCase> {
|
||||
let name = recipe["name"].as_str().ok_or("missing recipe name")?;
|
||||
if name.is_empty() || !name.bytes().all(|c| c.is_ascii_alphanumeric() || matches!(c, b'_' | b'-' | b'.')) || name.contains("..") {
|
||||
return Err("recipe name must be a plain file name".into());
|
||||
}
|
||||
|
||||
let operation = recipe["operation"].as_str().ok_or("missing operation")?;
|
||||
let mut case = ProbeCase::new(name);
|
||||
case.graph.size = field(recipe, "size", [4, 4])?;
|
||||
if case.graph.size.iter().any(|size| *size > MAX_SIZE_LOG2) {
|
||||
return Err("recipe exceeds the image size limit".into());
|
||||
}
|
||||
|
||||
case.graph.format = field(recipe, "format", OutputFormat::F32)?;
|
||||
case.graph.tiling = field(recipe, "tile", [true; 2])?;
|
||||
case.graph.pixel_ratio = field(recipe, "pixel_ratio", 1)?;
|
||||
case.graph.pixel_ratio_mode = ParameterInheritance::Absolute;
|
||||
let source = case.graph.add_node(operation, [0.0; 2]);
|
||||
let params: BTreeMap<String, Value> = field(recipe, "params", BTreeMap::new())?;
|
||||
case.graph.node_mut(source)?.params.extend(params);
|
||||
if let Some(format) = recipe.get("node_format") {
|
||||
let node = case.graph.node_mut(source)?;
|
||||
node.base.format = serde_json::from_value(format.clone())?;
|
||||
node.base.format_mode = ParameterInheritance::Absolute;
|
||||
}
|
||||
if let Some(size) = recipe.get("pixel_size") {
|
||||
let node = case.graph.node_mut(source)?;
|
||||
node.base.pixel_size = serde_json::from_value(size.clone())?;
|
||||
node.base.pixel_size_mode = ParameterInheritance::Absolute;
|
||||
}
|
||||
if let Some(inputs) = recipe["inputs"].as_array() {
|
||||
for input in inputs {
|
||||
let port = input["port"].as_str().ok_or("missing input port")?;
|
||||
let gray = field(input, "gray", true)?;
|
||||
let name = format!("image{}", case.inputs.len());
|
||||
case.image_input(source, port, gray)?;
|
||||
let original = case.inputs.get(&name).ok_or("missing generated input")?;
|
||||
let image = input_image(input, original)?;
|
||||
case.inputs.insert(name, image);
|
||||
}
|
||||
}
|
||||
if let Some(format) = recipe.get("input_format") {
|
||||
for node in &mut case.graph.nodes {
|
||||
if matches!(node.def.as_str(), "input_color" | "input_grayscale") {
|
||||
node.base.format = serde_json::from_value(format.clone())?;
|
||||
node.base.format_mode = ParameterInheritance::Absolute;
|
||||
}
|
||||
}
|
||||
}
|
||||
case.finish(source)?;
|
||||
Ok(case)
|
||||
}
|
||||
|
||||
fn input_image(input: &Json, original: &Image) -> Result<Image> {
|
||||
let (w, h) = (original.w, original.h);
|
||||
let pattern = input["pattern"].as_str().unwrap_or("catalog");
|
||||
if pattern == "catalog" {
|
||||
return Ok(original.clone());
|
||||
}
|
||||
let background: [f32; 4] = field(input, "background", [0.0; 4])?;
|
||||
let value: [f32; 4] = field(input, "value", [1.0; 4])?;
|
||||
let position: [u32; 2] = field(input, "position", [w / 2, h / 2])?;
|
||||
let pixels: Vec<f32> = field(input, "pixels", Vec::new())?;
|
||||
if pattern == "pixels" && pixels.len() != w as usize * h as usize * original.channels() {
|
||||
return Err("recipe pixel count does not match its size and kind".into());
|
||||
}
|
||||
|
||||
let image = Image::generate(w, h, original.kind, |x, y| match pattern {
|
||||
"constant" => value,
|
||||
"impulse" => {
|
||||
if [x, y] == position {
|
||||
value
|
||||
} else {
|
||||
background
|
||||
}
|
||||
}
|
||||
"grid" => {
|
||||
let v = ((x * 13 + y * 7) % 97) as f32 / 256.0;
|
||||
[v, 0.5 - v, v * 2.0, 0.25 + v]
|
||||
}
|
||||
"ramp_x" | "ramp_y" => {
|
||||
let v = if pattern == "ramp_x" { x as f32 / (w - 1).max(1) as f32 } else { y as f32 / (h - 1).max(1) as f32 };
|
||||
[v; 4]
|
||||
}
|
||||
"pixels" => {
|
||||
let start = (y as usize * w as usize + x as usize) * original.channels();
|
||||
if original.kind == Kind::Gray {
|
||||
[pixels.get(start).copied().unwrap_or(0.0); 4]
|
||||
} else {
|
||||
std::array::from_fn(|c| pixels.get(start + c).copied().unwrap_or(0.0))
|
||||
}
|
||||
}
|
||||
_ => background,
|
||||
});
|
||||
if !matches!(pattern, "constant" | "impulse" | "grid" | "ramp_x" | "ramp_y" | "pixels") {
|
||||
return Err(format!("unknown recipe pattern: {pattern}").into());
|
||||
}
|
||||
|
||||
Ok(image)
|
||||
}
|
||||
|
||||
fn field<T: serde::de::DeserializeOwned>(value: &Json, key: &str, default: T) -> Result<T> {
|
||||
match value.get(key) {
|
||||
Some(value) => Ok(serde_json::from_value(value.clone())?),
|
||||
None => Ok(default),
|
||||
}
|
||||
}
|
||||
@@ -1,141 +0,0 @@
|
||||
use super::{ProbeCase, Result};
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::{
|
||||
fs::File,
|
||||
path::Path,
|
||||
process::{Command, Stdio},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
const REFERENCE_TIMEOUT: Duration = Duration::from_secs(30);
|
||||
const PROCESS_POLL_INTERVAL: Duration = Duration::from_millis(20);
|
||||
|
||||
// Measured from an empty package saved by the reference app
|
||||
pub(super) const REFERENCE_FORMAT_VERSION: &str = "1.1.0.202502";
|
||||
|
||||
pub(super) fn run(command: &mut Command, directory: &Path, stage: &str) -> Result<(bool, Vec<u8>)> {
|
||||
let stdout = directory.join(format!("{stage}.stdout.txt"));
|
||||
let stderr = directory.join(format!("{stage}.stderr.txt"));
|
||||
let mut child = command.stdout(Stdio::from(File::create(&stdout)?)).stderr(Stdio::from(File::create(stderr)?)).spawn()?;
|
||||
let start = Instant::now();
|
||||
loop {
|
||||
if let Some(status) = child.try_wait()? {
|
||||
std::fs::write(
|
||||
directory.join(format!("{stage}.exit.json")),
|
||||
serde_json::to_vec(&serde_json::json!({"success": status.success(), "code": status.code()}))?,
|
||||
)?;
|
||||
return Ok((status.success(), std::fs::read(stdout)?));
|
||||
}
|
||||
if start.elapsed() > REFERENCE_TIMEOUT {
|
||||
child.kill()?;
|
||||
child.wait()?;
|
||||
return Err(format!("reference {stage} exceeded {} seconds", REFERENCE_TIMEOUT.as_secs()).into());
|
||||
}
|
||||
std::thread::sleep(PROCESS_POLL_INTERVAL);
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) struct ReferenceRun {
|
||||
pub status: String,
|
||||
pub stdout: Vec<u8>,
|
||||
pub cached: bool,
|
||||
pub engine: String,
|
||||
pub cpu_count: Option<u32>,
|
||||
}
|
||||
|
||||
pub(super) fn measure(case: &ProbeCase, directory: &Path, tools: &Path, bytes: Vec<u8>) -> Result<ReferenceRun> {
|
||||
let engine = std::env::var("MC_PARITY_REFERENCE_ENGINE").unwrap_or_else(|_| "sse2".into());
|
||||
let cpu_count = std::env::var("MC_PARITY_REFERENCE_CPUS").ok().map(|value| value.parse::<u32>()).transpose()?;
|
||||
if cpu_count == Some(0) {
|
||||
return Err("reference CPU count must be positive".into());
|
||||
}
|
||||
|
||||
let mut digest = Sha256::new();
|
||||
digest.update(b"original-probe-v3-native-channels");
|
||||
digest.update(&bytes);
|
||||
digest.update(engine.as_bytes());
|
||||
if let Some(cpu_count) = &cpu_count {
|
||||
digest.update(cpu_count.to_string().as_bytes());
|
||||
}
|
||||
for (name, image) in &case.inputs {
|
||||
digest.update(name.as_bytes());
|
||||
digest.update(image.w.to_le_bytes());
|
||||
digest.update(image.h.to_le_bytes());
|
||||
for value in image.data.iter() {
|
||||
digest.update(value.to_bits().to_le_bytes());
|
||||
}
|
||||
}
|
||||
let key = format!("{:x}", digest.finalize());
|
||||
let key_path = directory.join("reference-key.txt");
|
||||
let status_path = directory.join("reference-status.txt");
|
||||
if std::fs::read_to_string(&key_path).is_ok_and(|previous| previous == key)
|
||||
&& let Ok(status) = std::fs::read_to_string(&status_path)
|
||||
{
|
||||
let stdout = std::fs::read(directory.join("render.stdout.txt")).unwrap_or_default();
|
||||
return Ok(ReferenceRun { status, stdout, cached: true, engine, cpu_count });
|
||||
}
|
||||
|
||||
// Native readers reject the application release in the SBS version header
|
||||
// Keep the original; only the transport copy uses the measured empty-package header
|
||||
let xml = String::from_utf8(bytes)?
|
||||
.replace(&format!("<formatVersion v=\"{}\"/>", env!("CARGO_PKG_VERSION")), &format!("<formatVersion v=\"{REFERENCE_FORMAT_VERSION}\"/>"))
|
||||
.replace(&format!("<updaterVersion v=\"{}\"/>", env!("CARGO_PKG_VERSION")), &format!("<updaterVersion v=\"{REFERENCE_FORMAT_VERSION}\"/>"));
|
||||
let source = directory.join("reference.sbs");
|
||||
std::fs::write(&source, xml)?;
|
||||
let mut cooker = Command::new(tools.join("sbscooker.exe"));
|
||||
cooker.arg("--inputs").arg(&source).arg("--output-path").arg(directory).args([
|
||||
"--output-name",
|
||||
"probe",
|
||||
"--expose-output-size",
|
||||
"1",
|
||||
"--expose-random-seed",
|
||||
"1",
|
||||
]);
|
||||
let (success, _) = run(&mut cooker, directory, "cook")?;
|
||||
let (status, stdout) = if success {
|
||||
let output = directory.join("result.exr");
|
||||
if output.exists() {
|
||||
std::fs::remove_file(output)?;
|
||||
}
|
||||
|
||||
let mut render = Command::new(tools.join("sbsrender.exe"));
|
||||
render
|
||||
.arg("render")
|
||||
.arg("--inputs")
|
||||
.arg(directory.join("probe.sbsar"))
|
||||
.arg("--output-path")
|
||||
.arg(directory)
|
||||
.args(["--output-name", "result", "--output-format", "exr", "--output-bit-depth", "32f", "--exr-format-use-float", "--engine"])
|
||||
.arg(&engine)
|
||||
.arg("--set-value")
|
||||
.arg(format!("$outputsize@{},{}", case.graph.size[0], case.graph.size[1]));
|
||||
if let Some(cpu_count) = &cpu_count {
|
||||
render.arg("--cpu-count").arg(cpu_count.to_string());
|
||||
}
|
||||
for (name, image) in &case.inputs {
|
||||
let path = directory.join(format!("{name}.exr"));
|
||||
|
||||
// Preserve gray channels to avoid introducing an extra RGB-to-gray conversion
|
||||
if image.is_gray() {
|
||||
use exr::prelude::*;
|
||||
let channels = SpecificChannels::build()
|
||||
.with_channel("Y")
|
||||
.with_pixel_fn(|position: Vec2<usize>| (image.get_gray(position.x() as i64, position.y() as i64, false),));
|
||||
exr::prelude::Image::from_channels((image.w as usize, image.h as usize), channels).write().to_file(&path)?;
|
||||
} else {
|
||||
exr::prelude::write_rgba_file(&path, image.w as usize, image.h as usize, |x, y| {
|
||||
let [r, g, b, a] = image.get(x as i64, y as i64, false);
|
||||
(r, g, b, a)
|
||||
})?;
|
||||
}
|
||||
render.arg("--set-entry").arg(format!("{name}@{}", path.display()));
|
||||
}
|
||||
let (success, stdout) = run(&mut render, directory, "render")?;
|
||||
(if success { "measured" } else { "reference_render_error" }, stdout)
|
||||
} else {
|
||||
("reference_cook_error", Vec::new())
|
||||
};
|
||||
std::fs::write(key_path, key)?;
|
||||
std::fs::write(status_path, status)?;
|
||||
Ok(ReferenceRun { status: status.into(), stdout, cached: false, engine, cpu_count })
|
||||
}
|
||||
@@ -1,115 +0,0 @@
|
||||
use super::{ProbeCase, Result};
|
||||
use materialcraft_core::{FunctionGraph, Graph, GraphInstance, NodeId, OutputFormat, ParameterInheritance, Value, ValueType};
|
||||
use std::sync::Arc;
|
||||
|
||||
pub(super) fn cases() -> Result<Vec<ProbeCase>> {
|
||||
let mut cases = Vec::new();
|
||||
for color in [false, true] {
|
||||
for (kind, value) in [
|
||||
("float", Value::Float(0.375)),
|
||||
("float2", Value::Float2([0.375, 0.625])),
|
||||
("float3", Value::Float3([0.375, 0.625, 0.875])),
|
||||
("float4", Value::Float4([0.375, 0.625, 0.875, 0.125])),
|
||||
("int", Value::Int(17)),
|
||||
("int2", Value::Int2([17, -3])),
|
||||
("int3", Value::Int3([17, -3, 7])),
|
||||
("int4", Value::Int4([17, -3, 7, 1])),
|
||||
("bool", Value::Bool(true)),
|
||||
] {
|
||||
let mut case = ProbeCase::function(&format!("pixel_output_{kind}_color{color}"), FunctionGraph::constant(value), true)?;
|
||||
case.graph.node_mut(NodeId(1))?.params.insert("color_mode".into(), Value::Bool(color));
|
||||
cases.push(case);
|
||||
}
|
||||
}
|
||||
for format in [OutputFormat::U8, OutputFormat::U16, OutputFormat::F16, OutputFormat::F32] {
|
||||
for color in [false, true] {
|
||||
for (index, value) in [Value::Float(0.1), Value::Float(-0.25), Value::Float(1.25), Value::Float(65520.0)].into_iter().enumerate() {
|
||||
let value = if color {
|
||||
let scalar = value.as_f32().ok_or("missing scalar fixture")?;
|
||||
Value::Float4([scalar, 0.25, 0.75, 0.125])
|
||||
} else {
|
||||
value
|
||||
};
|
||||
let mut case = ProbeCase::function(&format!("precision_{format:?}_color{color}_case{index}"), FunctionGraph::constant(value), true)?;
|
||||
case.graph.format = format;
|
||||
case.graph.node_mut(NodeId(1))?.params.insert("color_mode".into(), Value::Bool(color));
|
||||
cases.push(case);
|
||||
}
|
||||
let mut function = FunctionGraph::input("$pos", ValueType::Float2);
|
||||
let position = function.output.ok_or("missing position")?;
|
||||
let x = function.add("swizzle1", &[position], Some(Value::Int(0)));
|
||||
function.output = Some(if color {
|
||||
let remaining = function.add_constant(Value::Float3([0.25, 0.75, 0.125]));
|
||||
function.add("vector4", &[x, remaining], None)
|
||||
} else {
|
||||
x
|
||||
});
|
||||
let mut case = ProbeCase::function(&format!("precision_position_256_{format:?}_color{color}"), function, true)?;
|
||||
case.graph.size = [8, 8];
|
||||
case.graph.format = format;
|
||||
case.graph.node_mut(NodeId(1))?.params.insert("color_mode".into(), Value::Bool(color));
|
||||
cases.push(case);
|
||||
}
|
||||
}
|
||||
for seed in [0, 1, 7, -1] {
|
||||
for vector in [false, true] {
|
||||
let mut graph = FunctionGraph::default();
|
||||
let range = graph.add_constant(if vector { Value::Float4([1.0; 4]) } else { Value::Float(1.0) });
|
||||
graph.output = Some(graph.add("rand", &[range], None));
|
||||
let mut case = ProbeCase::function(&format!("value_random_seed{seed}_vector{vector}"), graph, false)?;
|
||||
case.graph.seed = seed;
|
||||
cases.push(case);
|
||||
}
|
||||
}
|
||||
for tile in [[false, false], [true, true], [true, false], [false, true]] {
|
||||
let function = FunctionGraph::input("$tiling", ValueType::Integer);
|
||||
let mut case = ProbeCase::function(&format!("inheritance_tiling_{}{}", u8::from(tile[0]), u8::from(tile[1])), function, false)?;
|
||||
case.graph.tiling = tile;
|
||||
case.graph.tiling_mode = ParameterInheritance::RelativeToInput;
|
||||
cases.push(case);
|
||||
}
|
||||
for pixel in [false, true] {
|
||||
for assignment in [false, true] {
|
||||
let mut body = FunctionGraph::constant(Value::Float(0.375));
|
||||
if assignment {
|
||||
body = FunctionGraph::default();
|
||||
let current = body.add("get_float1", &[], Some(Value::Text("nested_counter".into())));
|
||||
let step = body.add_constant(Value::Float(0.125));
|
||||
let next = body.add("add", &[current, step], None);
|
||||
body.output = Some(body.add("set", &[next], Some(Value::Text("nested_counter".into()))));
|
||||
}
|
||||
let mut source = Graph::new("original_callee");
|
||||
source.function = Some(body.clone());
|
||||
source.function_type = ValueType::Float as u32;
|
||||
let (inputs, outputs) = materialcraft_nodes::function::graph_ports(&source)?;
|
||||
let mut function = FunctionGraph::default();
|
||||
let mut calls = Vec::new();
|
||||
for _ in 0..if assignment { 2 } else { 1 } {
|
||||
let id = function.add("instance", &[], None);
|
||||
let node = function.nodes.last_mut().ok_or("missing call node")?;
|
||||
node.instance = Some(GraphInstance {
|
||||
label: String::new(),
|
||||
package: String::new(),
|
||||
graph: source.name.clone(),
|
||||
inputs: inputs.clone(),
|
||||
outputs: outputs.clone(),
|
||||
defaults: Default::default(),
|
||||
});
|
||||
node.source = Some(Ok(Arc::new(body.clone())));
|
||||
calls.push(id);
|
||||
}
|
||||
let mut output = *calls.first().ok_or("missing call")?;
|
||||
if assignment {
|
||||
let second = *calls.get(1).ok_or("missing second call")?;
|
||||
let both = function.add("sequence", &[output, second], None);
|
||||
let read = function.add("get_float1", &[], Some(Value::Text("nested_counter".into())));
|
||||
output = function.add("sequence", &[both, read], None);
|
||||
}
|
||||
function.output = Some(output);
|
||||
let mut case = ProbeCase::function(&format!("nested_function_pixel{pixel}_assignment{assignment}"), function, pixel)?;
|
||||
case.children.push(source);
|
||||
cases.push(case);
|
||||
}
|
||||
}
|
||||
Ok(cases)
|
||||
}
|
||||
@@ -1,13 +1,13 @@
|
||||
use materialcraft_core::{FunctionGraph, Graph, Package, Value};
|
||||
|
||||
#[test]
|
||||
fn function_loop_limit_uses_native_scalar_integer_data() {
|
||||
fn function_loop_limit_uses_scalar_integer_data() {
|
||||
let mut function = FunctionGraph::default();
|
||||
let initial = function.add_constant(Value::Float(0.25));
|
||||
let condition = function.add_constant(Value::Bool(true));
|
||||
let body = function.add_constant(Value::Float(0.75));
|
||||
function.output = Some(function.add("while", &[initial, condition, body], Some(Value::Int(3))));
|
||||
let mut graph = Graph::new("Original loop probe");
|
||||
let mut graph = Graph::new("Loop serialization");
|
||||
graph.function = Some(function);
|
||||
let mut package = Package::new("Original function data");
|
||||
package.graphs.push(graph);
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
use materialcraft_core::{Graph, Package, Value};
|
||||
|
||||
#[test]
|
||||
fn grayscale_image_defaults_are_scalar_in_native_sbs() {
|
||||
let mut package = Package::new("Original grayscale defaults probe");
|
||||
let mut graph = Graph::new("probe");
|
||||
fn grayscale_image_defaults_are_scalar_in_sbs() {
|
||||
let mut package = Package::new("Grayscale defaults");
|
||||
let mut graph = Graph::new("defaults");
|
||||
graph.add_node("input_grayscale", [0.0, 0.0]);
|
||||
let colored = graph.add_node("input_grayscale", [0.0, 100.0]);
|
||||
graph.node_mut(colored).unwrap().params.insert("default".into(), Value::Color([0.25, 0.5, 0.75, 0.125]));
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
const MAX_EXPANDED_NODES: usize = 131_072;
|
||||
const MAX_CALL_DEPTH: usize = 16;
|
||||
|
||||
// Fresh loop nodes use the measured iteration limit
|
||||
// Keep absent loop limits aligned with fresh-node defaults
|
||||
const DEFAULT_LOOP_LIMIT: i32 = 32;
|
||||
|
||||
mod arithmetic;
|
||||
|
||||
@@ -52,12 +52,12 @@ fn shuffle_resolves_out_of_range_selectors_after_input_kind() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sharpen_preserves_the_measured_float_order_on_ramps() {
|
||||
fn sharpen_preserves_float_order_on_ramps() {
|
||||
let input = Image::gray(16, 16, |x, _| x as f32 / 15.0);
|
||||
|
||||
let output = cook("sharpen", &[Some(input)], &[("intensity", Value::Float(1.0))], [16, 16], true);
|
||||
|
||||
// Original Float32 ramp probes distinguish the Laplacian's arithmetic order
|
||||
// Float32 ramps distinguish the Laplacian's arithmetic order
|
||||
for (x, bits) in [(1, 0x3d88_8889), (3, 0x3e4c_cccb), (7, 0x3eee_eeed), (13, 0x3f5d_ddde)] {
|
||||
assert_eq!(output.get_gray(x, 7, false).to_bits(), bits, "column {x}");
|
||||
}
|
||||
@@ -89,7 +89,7 @@ fn directional_blur_uses_full_radius_and_fractional_endpoints() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sharpen_has_measured_center_gain_and_clamps_negative_lobes() {
|
||||
fn sharpen_has_center_gain_and_clamps_negative_lobes() {
|
||||
let input = Image::gray(16, 16, |x, y| f32::from(x == 8 && y == 8));
|
||||
|
||||
let output = cook("sharpen", &[Some(input)], &[("intensity", Value::Float(1.0))], [16, 16], true);
|
||||
|
||||
@@ -4,7 +4,7 @@ use materialcraft_nodes::{CookContext, find, resolve_params};
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
#[test]
|
||||
fn absent_textures_match_measured_zero_pixels_and_kinds() {
|
||||
fn absent_textures_have_zero_pixels_and_expected_kinds() {
|
||||
for (id, kind, pixel) in [
|
||||
("channels_shuffle", Kind::Color, [0.0; 4]),
|
||||
("hsl", Kind::Color, [0.0; 4]),
|
||||
@@ -30,7 +30,7 @@ fn absent_textures_match_measured_zero_pixels_and_kinds() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fresh_catalog_defaults_match_runtime_inspection() {
|
||||
fn fresh_catalog_defaults_have_expected_values() {
|
||||
for (id, parameter, expected) in [
|
||||
("uniform", "color", Value::Color([0.0, 0.0, 0.0, 1.0])),
|
||||
("blur", "intensity", Value::Float(10.0)),
|
||||
|
||||
@@ -1,160 +0,0 @@
|
||||
# Exact atomic comparisons, second pass
|
||||
|
||||
This clean-room pass fixes Sharpen's Float32 arithmetic and Channels Shuffle's selector
|
||||
handling. It builds on the [first atomic corrections](atomic-parity-improvements.md).
|
||||
All graphs and inputs are original procedural probes. No proprietary implementation or
|
||||
asset was used. Catalog membership and `assets/sbs` are unchanged.
|
||||
|
||||
## Solved behavior
|
||||
|
||||
- Sharpen now forms each axial second difference before multiplying by strength, adds
|
||||
the two weighted differences, then adds the center. The previous algebraically
|
||||
equivalent expression rounded differently. All 40 new tiled arithmetic probes match
|
||||
bit for bit, across square/rectangular images, fractional strengths, ramps and RGBA
|
||||
patterns. All 27 original Sharpen cases match with the reference SSE2 CPU count set to one.
|
||||
- Channels Shuffle now offers the eight measured source channels. The old Black/White
|
||||
choices conflicted with saved channel selectors. Color swizzles use the low three
|
||||
selector bits; grayscale selection happens before that swizzle. Oversized and signed
|
||||
file values survive import, evaluation and save/load until the connected image kinds
|
||||
determine their result. The 33 original cases, ten gray-selector kernel cases and all
|
||||
64 new selector/kind cases match SSE2 exactly.
|
||||
|
||||
Existing graphs using the former Black/White choices now follow the measured selector
|
||||
behavior. Use a Uniform Color input when a constant black or white channel is intended.
|
||||
Defaults and the eight ordinary source choices retain their meanings.
|
||||
|
||||
Regression coverage is in `crates/nodes/tests/atomic_filter_parity.rs` and
|
||||
`crates/formats/src/sbs/tests.rs`. The new ramp, selector and import checks exposed failures
|
||||
before their corrections; coverage was expanded to mixed input kinds and signed round trips.
|
||||
The runner also accepts bounded JSON recipes, dumps original inputs with diagnostic pixels,
|
||||
and records the reference backend and requested CPU count.
|
||||
|
||||
## Measured results
|
||||
|
||||
The [case ledger](parity/atomic-exact-results.csv) retains failures and unchanged cases.
|
||||
Before means the preceding atomic-correction working tree described in the first report,
|
||||
not the older committed catalog audit. Both sides use scalar EXR Y for gray inputs and
|
||||
Float32 RGBA for color inputs. Comparisons count differing Float32 bit patterns, differing
|
||||
pixels, maximum finite absolute error and non-finite mismatches separately.
|
||||
|
||||
| Original cases, SSE2 automatic CPU allocation | Cases | Exact before → after | Component mismatches before → after | Maximum absolute error after |
|
||||
|---|---:|---:|---:|---:|
|
||||
| Sharpen | 27 | 2 → 21 | 65,200 → 832 | 0.0161290467 |
|
||||
| Channels Shuffle | 33 | 29 → 33 | 1,920 → 0 | 0 |
|
||||
| Blur | 27 | 10 → 10 | 53,048 → 53,048 | 3.57627869e-7 |
|
||||
| Directional Blur | 29 | 18 → 18 | 36,646 → 36,646 | 0.00259685516 |
|
||||
|
||||
The original 1,817-case suite gains 25 exact images, including two gray-selector kernel
|
||||
cases outside this table. The 291 new cases improve from 124 to 179 exact images. Across
|
||||
these 2,108 comparable cases, **80 additional images become exact and none loses exactness**.
|
||||
There are 779 exact images, 393 exact typed values, 698 image differences, 104 typed
|
||||
differences, 82 local errors, 32 size differences, 19 reference cooker errors and one
|
||||
unavailable numeric typed readback. These counts are not a catalog parity percentage.
|
||||
|
||||
The 40 new Sharpen arithmetic cases remove 82,087 component mismatches (previous maximum
|
||||
error 3.57627869e-6). The 64 new Shuffle selector/kind cases remove 27,648 component
|
||||
mismatches (previous maximum error 0.875). Reference pixels stayed identical between
|
||||
the before and after captures, including the signed-selector serialization correction.
|
||||
|
||||
Four original Sharpen cases have a slightly larger remaining maximum error, changing
|
||||
from 0.0161290169 to 0.0161290467. Their residual boundary discrepancy is described below;
|
||||
the corrected arithmetic removes other differing components. No general error-reduction
|
||||
claim is made beyond the reported measurements.
|
||||
|
||||
## Reference settings can change pixels
|
||||
|
||||
The runtime is 16.0.7. Its SSE2 and D3D11 renderers were measured separately. The ledger
|
||||
includes 54 SSE2 thread-control measurements and 98 D3D11 backend-control measurements
|
||||
in addition to the 2,108 primary cases: 2,260 measurements in total.
|
||||
|
||||
- **Thread boundaries:** automatic CPU allocation leaves six original non-tiled Sharpen
|
||||
cases different. For a 32×16 ramp, 16 values in the reference change when CPU count is
|
||||
set to one. For the 64×64 color case, 384 components change along internal stripe
|
||||
boundaries. With one CPU, all 27 original Sharpen images are exact: zero mismatches,
|
||||
maximum error zero. The same CPU-count change leaves all 27 reference Blur images
|
||||
unchanged. MaterialCraft does not emulate the reference's thread-dependent seams.
|
||||
- **Integer precision:** for an input component of 0.5 at U8, SSE2 returns 128/255 while
|
||||
D3D11 and MaterialCraft return 127/255. A U16 Dot input with negative/HDR components
|
||||
passes through SSE2 unchanged in these probes; D3D11 and MaterialCraft clamp and
|
||||
quantize it. The same difference appears with explicit absolute node/input formats.
|
||||
These observations do not establish a general format-inheritance bug.
|
||||
- **Negative float values:** constant Float32 Sharpen input -0.5 produces 0 on SSE2 and
|
||||
-0.5 on D3D11. MaterialCraft currently matches SSE2's lower clamp. The 32 constant
|
||||
precision controls have 16 exact images on SSE2 and 28 on D3D11; two additional D3D11
|
||||
Sharpen pattern controls remain different.
|
||||
- **Invalid selectors:** all 64 selector/kind cases match SSE2, and 63 match D3D11. With
|
||||
gray input 1, color input 2 and selector 11, SSE2 returns the converted gray alpha (1),
|
||||
while D3D11 returns the gray scalar (0.125). All 32 ordinary selector/kind combinations
|
||||
in that group match both backends. The other 32 exercise out-of-range file values.
|
||||
|
||||
One deterministic output cannot equal two different reference outputs for the same graph.
|
||||
Backend/thread agreement therefore cannot be claimed from any one of these configurations.
|
||||
|
||||
## Still different or untested
|
||||
|
||||
Blur retains small arithmetic differences. This pass tested axis order, direct versus
|
||||
running accumulation and rounding order without finding a verified improvement suitable
|
||||
for a production change. Directional Blur retains sampling differences: wider angled
|
||||
kernels in the reference have position-dependent footprints. Shifted original impulses
|
||||
confirm this is more than a final storage rounding error. The new angled group reaches
|
||||
maximum error 0.137573063 at angle 0.333, strength 2. These filters are unchanged this pass.
|
||||
|
||||
Non-dyadic half-float conversion, other precision paths, arbitrary angles and strengths,
|
||||
all other backends, mixed input/output resolutions, non-default Sharpen alpha behavior,
|
||||
and nonempty Text/SVG rasterization remain unestablished. Earlier isolated non-finite,
|
||||
processor and nested map probes were replayed; their earlier limits remain. Arbitrary
|
||||
NaN payloads and combinations of exceptional samples are untested. The 954 inventoried
|
||||
package function bodies remain untested. See the [catalog report](node-catalog-parity.md)
|
||||
for the full inventory and typed-value readback limitations.
|
||||
|
||||
## Reproduction
|
||||
|
||||
Use an empty result directory when changing reference runtime versions. Reference caches
|
||||
are keyed by graph/input content, backend and CPU-count override, not installed runtime
|
||||
version. The existing transport-only SBS version-header adjustment remains required.
|
||||
The runner preserves the original graph, transport graph, raw EXR, logs and report.
|
||||
|
||||
```powershell
|
||||
cargo build -p materialcraft-engine --release --example catalog_parity
|
||||
$env:MC_PARITY_DUMP_PIXELS = '1'
|
||||
$env:MC_PARITY_REFERENCE_ENGINE = 'sse2'
|
||||
Remove-Item Env:MC_PARITY_REFERENCE_CPUS -ErrorAction SilentlyContinue
|
||||
Remove-Item Env:MC_PARITY_CASE_FILE -ErrorAction SilentlyContinue
|
||||
target/release/examples/catalog_parity.exe C:/parity/catalog C:/reference/tools
|
||||
|
||||
$env:MC_PARITY_CASE_FILE = "$PWD/docs/parity/atomic-exact-recipes.json"
|
||||
target/release/examples/catalog_parity.exe C:/parity/extra C:/reference/tools
|
||||
|
||||
Remove-Item Env:MC_PARITY_CASE_FILE
|
||||
$env:MC_PARITY_REFERENCE_CPUS = '1'
|
||||
target/release/examples/catalog_parity.exe C:/parity/sharpen-one-cpu C:/reference/tools atomic_sharpen_
|
||||
target/release/examples/catalog_parity.exe C:/parity/blur-one-cpu C:/reference/tools atomic_blur_
|
||||
|
||||
Remove-Item Env:MC_PARITY_REFERENCE_CPUS
|
||||
$env:MC_PARITY_REFERENCE_ENGINE = 'd3d11'
|
||||
$env:MC_PARITY_CASE_FILE = "$PWD/docs/parity/atomic-exact-recipes.json"
|
||||
target/release/examples/catalog_parity.exe C:/parity/gpu-precision C:/reference/tools exact_precision_
|
||||
target/release/examples/catalog_parity.exe C:/parity/gpu-sharpen C:/reference/tools exact_sharpen_math_4x4_0.1_
|
||||
target/release/examples/catalog_parity.exe C:/parity/gpu-shuffle C:/reference/tools exact_shuffle_
|
||||
```
|
||||
|
||||
The [291 recipes](parity/atomic-exact-recipes.json) describe generated ramps, dyadic grids,
|
||||
constants and isolated impulses. Sizes include 16, 32, 64 and 256 pixel sides, both
|
||||
rectangular orientations, tiling boundaries, several strengths/angles and all four output
|
||||
formats. Sixteen exploratory recipes using the wrong local parameter variant (`Int` for
|
||||
an enum) were replaced by valid enum recipes; they are not counted as parity improvements.
|
||||
Diagnostic JSON encodes non-finite values as null; the actual comparison uses raw image bits.
|
||||
|
||||
## Validation
|
||||
|
||||
- Release tests for `materialcraft-nodes`, `materialcraft-formats`, `materialcraft-eval`
|
||||
and `materialcraft-engine` pass with the known resource test below excluded. This
|
||||
includes the new regressions, `every_node_cooks` and the engine's `panic_hunt`.
|
||||
- Workspace Clippy with `--all-targets -- -D warnings` passes.
|
||||
- `cargo xtask layers` passes for 14 crates; `cargo xtask wasm` passes for ten crates.
|
||||
- Formatting and diff whitespace checks pass.
|
||||
|
||||
The separately rerun `byte_only_sbs_import_resolves_library_resource_substitutes` test
|
||||
still fails at `crates/engine/tests/package_resources.rs:32`, in the existing saved
|
||||
missing-font-path assertion. No asset or unrelated resource-handling change was made to
|
||||
hide this failure. A completely green release suite is therefore not claimed.
|
||||
@@ -1,173 +1,63 @@
|
||||
# Atomic filter and background corrections
|
||||
# Atomic node corrections
|
||||
|
||||
This is the first-pass record. The [exact-comparison follow-up](atomic-exact-parity.md)
|
||||
supersedes its Sharpen arithmetic, Shuffle selector and precision/backend conclusions.
|
||||
These changes correct filtering, channel selection and empty-content compositing in
|
||||
MaterialCraft. Catalog membership and bundled SBS assets are unchanged.
|
||||
|
||||
This clean-room follow-up corrects six existing atomic nodes: Blur, Directional Blur,
|
||||
Sharpen, Channels Shuffle, Text and SVG. It changes no catalog membership or bundled
|
||||
SBS assets. Numerical agreement applies only to the recorded cases, runtime and backend.
|
||||
## Behavior changes
|
||||
|
||||
## Solved behavior
|
||||
- Blur uses a separable box filter with fractional endpoint coverage and bounded running
|
||||
sums. Non-finite samples stop affecting a window after they leave it.
|
||||
- Directional Blur uses the full radius, weighted endpoints and image-space rotation.
|
||||
Its sampling budget is bounded for large strengths.
|
||||
- Sharpen uses a four-neighbor Laplacian, processes alpha, clamps negative lobes and retains
|
||||
HDR output. Explicit Float32 operation order preserves cancellation behavior on ramps.
|
||||
- All three filters scale from the shorter image dimension and honor horizontal and
|
||||
vertical tiling independently. Tiling changes invalidate the cook cache.
|
||||
- Channels Shuffle supplies a grayscale scalar through all ordinary channel selections,
|
||||
including alpha. Color inputs retain their alpha. Signed and oversized saved selectors
|
||||
remain intact until input kinds determine channel selection.
|
||||
- Empty Text/SVG content preserves background pixels, including hidden RGB under zero
|
||||
alpha. Incompatible background kinds produce empty pixels; matching gray backgrounds
|
||||
retain their scalar values.
|
||||
|
||||
- Blur now integrates a box footprint with fractional endpoint coverage. The previous
|
||||
Gaussian kernel spread a different amount of energy to neighboring pixels. Running
|
||||
sums keep each horizontal/vertical pass linear in image size.
|
||||
- Directional Blur now uses the measured full radius and endpoint coverage, and rotates
|
||||
in the measured image-space direction. Oblique kernels remain approximate.
|
||||
- Sharpen now uses the measured four-neighbor Laplacian, processes alpha, and clamps
|
||||
negative lobes while retaining HDR output. Rectangular images weight each axis separately.
|
||||
- All three filters use the shorter image side for their measured size scaling and honor
|
||||
horizontal and vertical tiling independently. Changing tiling invalidates the cook cache.
|
||||
- Channels Shuffle reads a grayscale input's scalar through every channel selector,
|
||||
including alpha. Color inputs retain their actual alpha channel.
|
||||
- Empty Text/SVG content preserves the background, including hidden RGB under zero alpha.
|
||||
A background of the wrong image kind supplies empty pixels instead of an implicit
|
||||
color conversion. Matching grayscale backgrounds retain their original scalar bits.
|
||||
Channels Shuffle now offers eight input-channel choices. Graphs using the former
|
||||
Black/White choices follow the corrected selector behavior. Use a Uniform Color input
|
||||
for constant channels.
|
||||
|
||||
The regressions in `crates/nodes/tests/atomic_filter_parity.rs` and
|
||||
`crates/eval/tests/filter_tiling.rs` were observed failing before their corrections.
|
||||
They cover fractional box footprints, full directional extent, sharpen gain and clipping,
|
||||
gray channel selection, transparent backgrounds, rectangular scaling, independent tiling
|
||||
and cache invalidation.
|
||||
The existing save/load fixtures now use a visible blur radius at their 32-pixel preview
|
||||
size and backgrounds with the same image kind as their target. Their live binding and
|
||||
connection-preservation assertions remain in place.
|
||||
## Regression coverage
|
||||
|
||||
## Measured improvement
|
||||
Local tests cover fractional filter footprints, directional extent, sharpen gain and
|
||||
Float32 cancellation, rectangular images, independent tiling and cache invalidation,
|
||||
gray/color channel selection, signed-selector round trips and transparent backgrounds:
|
||||
|
||||
The [per-case ledger](parity/atomic-improvement-results.csv) records all 1,817 rerun/new
|
||||
cases, including failures and unchanged processor/map cases. Its before columns use the
|
||||
implementation at `9f390d4` with corrected input encoding. There are 1,773 comparable
|
||||
before/after cases; the 44 additional precision/non-finite cases have no before claim.
|
||||
- [Filter and channel tests](../crates/nodes/tests/atomic_filter_parity.rs)
|
||||
- [Tiling and cache tests](../crates/eval/tests/filter_tiling.rs)
|
||||
- [SBS round-trip tests](../crates/formats/src/sbs/tests.rs)
|
||||
|
||||
For the 182 existing cases of the six changed nodes, exact images increase from 25 to
|
||||
125. Component mismatches decrease from 359,466 to 156,814. The table includes every
|
||||
existing case for each node, including remaining extension/boundary differences:
|
||||
|
||||
| Node | Cases | Exact before → after | Component mismatches before → after | Largest absolute error before → after |
|
||||
|---|---:|---:|---:|---:|
|
||||
| Blur | 27 | 2 → 10 | 81,836 → 53,048 | 0.398878 → 3.57628e-7 |
|
||||
| Directional Blur | 29 | 2 → 18 | 75,182 → 36,646 | 0.400680 → 0.00259686 |
|
||||
| Sharpen | 27 | 2 → 2 | 69,280 → 65,200 | 14.7046 → 0.0161290 |
|
||||
| Channels Shuffle | 33 | 17 → 29 | 20,992 → 1,920 | 1 → 1 |
|
||||
| Text, empty content | 37 | 1 → 37 | 29,067 → 0 | 0.990975 → 0 |
|
||||
| SVG, empty content | 29 | 1 → 29 | 83,109 → 0 | 1 → 0 |
|
||||
|
||||
The four remaining original Shuffle cases select its local White extension. All eight
|
||||
added grayscale source-channel selectors match exactly after the alpha correction.
|
||||
An unchanged maximum for that node does not negate the fixed alpha cases.
|
||||
|
||||
Of the 158 new kernel/background cases measured both before and after, exact results
|
||||
increase from 63 to 136. Across all 1,773 comparable cases, **173 additional cases become
|
||||
exact**, no previously exact case becomes inexact, and no recorded maximum finite error
|
||||
increases. This does not establish behavior outside those probes.
|
||||
|
||||
The final 202-case kernel group has 158 exact images and 44 image differences. Its 12
|
||||
isolated non-finite cases are exact. The oblique-angle group still reaches error 0.101213
|
||||
on an impulse at angle 0.333 and strength 2.75; the separate Sharpen detail group reaches
|
||||
0.0625 in some non-tiled impulse cases. These larger new cases are not hidden by
|
||||
the table of existing cases above.
|
||||
|
||||
The full 1,817-case ledger contains 575 exact images, 393 exact typed values, 611 image
|
||||
differences, 104 typed differences, 82 local errors, 32 size differences, 19 reference
|
||||
cooker errors and one unavailable numeric typed readback. Comparable images contain
|
||||
10,665,728 components, with 1,279,965 component mismatches across 689,232 pixels.
|
||||
There were no harness or renderer-process failures. Full catalog parity is unestablished.
|
||||
|
||||
## Measurement correction
|
||||
|
||||
The earlier runner exported every image input as RGBA. Grayscale input bridges in the
|
||||
reference therefore performed an extra conversion before the node ran. The runner now
|
||||
writes grayscale inputs as a single Float32 EXR Y channel and color inputs as RGBA.
|
||||
Its cache version changed so old captures cannot be reused with the new input encoding.
|
||||
|
||||
Both the before and after results in this follow-up use the corrected encoding. Gains
|
||||
caused solely by that correction are not counted as production fixes. For example, all
|
||||
25 existing Dot cases match with corrected inputs before any production edit. The
|
||||
[previous results](parity/case-results.csv) remain a historical record and must not be
|
||||
compared directly to the new totals to estimate the effect of these fixes.
|
||||
|
||||
## Reproduction and scope
|
||||
|
||||
The reference runtime remains 16.0.7, using its SSE2 renderer. Inputs are original impulses,
|
||||
coordinate ramps, checks, constant backgrounds and HDR/alpha patterns. No proprietary
|
||||
implementation, graph, font or image is included. The catalog inventory remains 29 main
|
||||
entries, 85 function operations, four measured map kinds and 954 loaded package functions.
|
||||
Those package function bodies remain untested by this work.
|
||||
|
||||
```powershell
|
||||
cargo run -p materialcraft-engine --release --example catalog_parity -- C:/parity/results C:/reference/tools
|
||||
cargo run -p materialcraft-engine --release --example catalog_parity -- C:/parity/kernels C:/reference/tools kernel_
|
||||
```
|
||||
|
||||
The second command selects the 202 added cases. They include 16, 32, 64 and 256 pixel sides,
|
||||
both rectangular orientations, centered and boundary impulses, fractional strengths,
|
||||
several angles, color/gray inputs, HDR and transparent RGB, U8/U16/F16/F32, and isolated
|
||||
NaN/positive-infinity/negative-infinity inputs. Literal non-finite values are supplied through
|
||||
original EXR inputs, not serialized as unsupported SBS constants. Existing probes retain
|
||||
unconnected inputs, four tiling flags, processors, nested maps, seeds and error cases.
|
||||
|
||||
Set `MC_PARITY_DUMP_PIXELS=1` for an additional `pixels.json` diagnostic beside each EXR.
|
||||
The JSON is not a substitute for raw non-finite bit comparison: JSON encodes those values
|
||||
as null. Raw image comparisons still use Float32 bits, with component/pixel mismatch counts,
|
||||
maximum finite error and a separate non-finite mismatch count. Typed comparisons retain
|
||||
the limitations described in [the catalog measurements](node-catalog-parity.md).
|
||||
|
||||
The original probe, transport SBS, raw EXR, renderer logs and report are retained in the
|
||||
chosen output directory. The existing two-field SBS version-header transport adjustment
|
||||
is still required. Unmodified cross-application file compatibility is not established.
|
||||
Save/load fixtures use explicit blur strengths and compatible background kinds so their
|
||||
binding and connection-preservation assertions retain their purpose.
|
||||
|
||||
## Remaining limits
|
||||
|
||||
Exact full-node parity is not claimed. Oblique Directional Blur still differs in its
|
||||
sampling footprint and subpixel rounding; its sample budget remains bounded for large
|
||||
strengths. Sharpen retains some boundary and floating-point arithmetic differences.
|
||||
Its additional native alpha-mode control is still absent; only the default mode was measured.
|
||||
Integer/half-float output quantization and bound-image format inheritance still differ;
|
||||
an error in those paths must not be attributed solely to the filter kernel.
|
||||
|
||||
Channels Shuffle's local Black/White selectors have no corresponding measured native
|
||||
selector in this transport; these extension cases remain different. Text uses empty text
|
||||
in the reference probes, so font rendering is untested. SVG corrections establish
|
||||
background handling, not complete SVG rasterization equivalence. Non-finite cases cover
|
||||
single exceptional samples; arbitrary payloads and interacting exceptional values are
|
||||
untested. The added filter probes use inputs with the same dimensions as their outputs;
|
||||
resizing mismatched inputs and mixed source/node tiling remain untested here.
|
||||
Filter widths beyond the recorded cases, arbitrary angles, backend equivalence,
|
||||
and other processors/maps retain the limitations in the catalog report.
|
||||
|
||||
Release timing is reproducible with:
|
||||
|
||||
```powershell
|
||||
cargo run -p materialcraft-nodes --release --example filter_timing
|
||||
```
|
||||
|
||||
It cooks original RGBA patterns at 512 and 1024 square pixels, three repetitions per
|
||||
filter, with Blur strength 32, Directional Blur strength 10 at one eighth turn, and
|
||||
Sharpen strength 10. These are timing measurements, not additional reference comparisons.
|
||||
|
||||
| Filter | 512×512 mean milliseconds/cook | 1024×1024 mean milliseconds/cook |
|
||||
|---|---:|---:|
|
||||
| Blur | 34.445 | 140.386 |
|
||||
| Directional Blur | 83.274 | 549.661 |
|
||||
| Sharpen | 3.367 | 9.425 |
|
||||
|
||||
These local release timings are environment-dependent. They establish neither a speed
|
||||
comparison with the reference nor worst-case performance at the maximum supported size.
|
||||
Full numerical compatibility remains unestablished. Open work includes oblique sampling,
|
||||
floating-point rounding and quantization, mixed input/output resolutions, non-default
|
||||
Sharpen alpha behavior and nonempty Text/SVG rasterization. Processor and map execution
|
||||
limits are summarized in the [catalog status](node-catalog-parity.md).
|
||||
|
||||
## Validation
|
||||
|
||||
- `cargo fmt --all -- --check`: passed.
|
||||
- `cargo clippy --workspace --all-targets -- -D warnings`: passed.
|
||||
- `cargo xtask layers`: passed for all 14 checked crates.
|
||||
- `cargo xtask wasm`: passed for all ten checked crates.
|
||||
- Release tests for `materialcraft-nodes`, `materialcraft-eval` and `materialcraft-engine`
|
||||
pass with `--skip byte_only_sbs_import_resolves_library_resource_substitutes`.
|
||||
All seven new regressions pass; each was observed failing before its correction.
|
||||
- The full release command was also run. Its remaining failure is the previously recorded
|
||||
missing-font resource round-trip assertion in `crates/engine/tests/package_resources.rs:32`.
|
||||
That unrelated test remains unresolved; it is not counted as passing. Existing ignored
|
||||
tests were not enabled.
|
||||
Recorded release tests for nodes, formats, eval and engine pass with the known resource
|
||||
failure below excluded, including `every_node_cooks` and `panic_hunt`. Formatting,
|
||||
workspace Clippy with `--all-targets -- -D warnings`, dependency layers and all ten wasm
|
||||
checks pass.
|
||||
|
||||
The final working changes were reviewed. No files under `assets/sbs` changed, and no Git
|
||||
write, commit, push or remote comment was performed for this follow-up.
|
||||
`byte_only_sbs_import_resolves_library_resource_substitutes` remains a known failure at
|
||||
`crates/engine/tests/package_resources.rs:32`, in the saved missing-font-path assertion.
|
||||
The complete release suite is not reported green.
|
||||
|
||||
The optional `filter_timing` example benchmarks MaterialCraft's Blur, Directional Blur
|
||||
and Sharpen on generated images at 512 and 1024 pixels. It uses no external application:
|
||||
|
||||
```sh
|
||||
cargo run -p materialcraft-nodes --release --example filter_timing
|
||||
```
|
||||
@@ -66,10 +66,9 @@ cargo +1.96.0 run -p materialcraft-engine --release --example atomic_sample -- e
|
||||
| FX-Map graph | Quadrant (`paramset`), Switch (`markov2`), Iterate (`addnode`), Dot (`passthrough`) |
|
||||
|
||||
The former count of 26 primitives included `motion_blur`, removed in commit `a0032d6`.
|
||||
It was a MaterialCraft wrapper around Directional Blur, without a separate counterpart in the
|
||||
enumerated reference atomic catalog. The count of 25 includes Dot/reroute.
|
||||
The [catalog audit](node-catalog-parity.md) records the current 25 primitives plus four
|
||||
input/output entries; it did not remove a node.
|
||||
It was a MaterialCraft wrapper around Directional Blur. The count of 25 includes Dot/reroute.
|
||||
The [catalog status](node-catalog-parity.md) records the current 25 primitives plus four
|
||||
input/output entries.
|
||||
|
||||
Image primitives have individual files in `crates/nodes/src/atomic/`. Function evaluation and
|
||||
pattern traversal have separate modules. Document types each live in their own file under
|
||||
@@ -88,10 +87,9 @@ SBS library reference resolution is outside this change.
|
||||
|
||||
## Current limits
|
||||
|
||||
- The reference rejects the generated SBS version header; the [catalog audit](node-catalog-parity.md)
|
||||
explains the separate header-normalized comparison and remaining interoperability gap
|
||||
- Native IDs, ports and types are mapped. The [catalog audit](node-catalog-parity.md) records
|
||||
measured numerical cases and remaining differences; broad rendering parity is unestablished
|
||||
- SBS version-header compatibility remains unresolved
|
||||
- Node IDs, ports and types are mapped. The [catalog status](node-catalog-parity.md) records
|
||||
remaining numerical and interoperability gaps; broad rendering parity is unestablished
|
||||
- Text renders the original built-in stroke font; external font references produce an explicit
|
||||
error. SVG supports vector geometry, without external images or font loading
|
||||
- Some native parameter variants and package/editor metadata remain unsupported; import reports
|
||||
|
||||
+4
-8
@@ -1,13 +1,9 @@
|
||||
# Gaps
|
||||
|
||||
The [native catalog audit](node-catalog-parity.md) records current measured differences and
|
||||
explicitly untested behavior, including all 954 loaded package functions. Prioritize its
|
||||
reproducible cases for primitive, processor, sampling, precision and map corrections.
|
||||
The [atomic corrections follow-up](atomic-parity-improvements.md) supersedes its Blur,
|
||||
Directional Blur, Sharpen, Channels Shuffle and empty Text/SVG background measurements;
|
||||
oblique sampling, precision, boundary behavior and the other recorded gaps remain open.
|
||||
The [second atomic pass](atomic-exact-parity.md) resolves Sharpen arithmetic and Shuffle
|
||||
selectors. Reference backend/thread differences prevent a blanket exact-parity claim.
|
||||
The [catalog status](node-catalog-parity.md) records implemented corrections and untested
|
||||
behavior, including all 954 loaded package function bodies. The
|
||||
[atomic corrections](atomic-parity-improvements.md) cover filters, channel selection and
|
||||
empty Text/SVG backgrounds. Sampling, precision, processor and map gaps remain open.
|
||||
|
||||
> The assessment below predates the 2026-11-05 primitive rewrite. Its old library counts and
|
||||
> compatibility claims are historical. See [atomic-workflow.md](atomic-workflow.md) and
|
||||
|
||||
+43
-215
@@ -1,231 +1,59 @@
|
||||
# Native catalog measurements
|
||||
# Node catalog status
|
||||
|
||||
The [atomic corrections follow-up](atomic-parity-improvements.md) records subsequent filter
|
||||
and background fixes. It also corrects grayscale probe input encoding; the figures below
|
||||
retain the original run and must not be used as the before baseline for those fixes.
|
||||
The [second atomic pass](atomic-exact-parity.md) fixes Sharpen arithmetic and Shuffle
|
||||
selectors, and separates backend/thread-dependent differences from local defects.
|
||||
|
||||
This is a clean-room audit of MaterialCraft's actual catalogs on 2026-11-15, based on
|
||||
`main` at `271890a`. Catalog coverage is not behavioral parity. Exact results apply only
|
||||
to the individual generated cases, reference runtime and backend recorded here.
|
||||
MaterialCraft is a clean-room implementation. This page summarizes available catalogs,
|
||||
implemented corrections and remaining compatibility work.
|
||||
|
||||
## Inventory
|
||||
|
||||
| Catalog | Actual entries | Evidence |
|
||||
|---|---:|---|
|
||||
| Main graph | 29: 25 primitives and four input/output items | MaterialCraft catalog and reference runtime definition enumeration |
|
||||
| Function graph | 85 | MaterialCraft function catalog and reference runtime definition enumeration |
|
||||
| FX-Map graph | 4 | MaterialCraft pattern definitions and original render probes for each kind |
|
||||
| Loaded package functions | 954, including 689 hidden entries | Actual loaded package inventory; behavior untested in this audit |
|
||||
|
||||
The earlier 26-primitives/30-total documentation count included `motion_blur`. Commit
|
||||
`a0032d6` removed that entry and its SBS mapping before the audited base, leaving 25 primitives
|
||||
and four input/output items. That former MaterialCraft entry was a wrapper around Directional
|
||||
Blur and had no separate counterpart in the enumerated reference atomic catalog. The current
|
||||
count includes Dot/reroute among the 25 primitives. This audit changed no catalog membership.
|
||||
|
||||
[Native entries](parity/native-catalog.csv), [default comparisons](parity/native-defaults.csv),
|
||||
[package function inventory](parity/packaged-functions.csv), and
|
||||
[per-case results](parity/case-results.csv) are machine-readable. Hidden package functions
|
||||
are included so the visible Library does not hide audit omissions. Package inventories
|
||||
establish presence only; they do not establish equivalence, provenance or redistribution rights.
|
||||
Earlier [SBS root assessments](sbs-root-nodes.md) and [parity corrections](parity-fixes.md)
|
||||
are separate measurements; their cases were not rerun or promoted by this audit.
|
||||
The reference SDK returned no definitions for its FX-Map graph resource, so the four-kind
|
||||
inventory is not claimed as a complete enumeration of that runtime's map definitions.
|
||||
|
||||
The [native coverage index](parity/native-coverage.csv) links all 118 native entries to their
|
||||
baseline cases, including failures. The default ledger has 91 equal observations and 45
|
||||
unmeasured entries after corrections; absence of a primitive default is not an equality claim.
|
||||
|
||||
## Recorded results
|
||||
|
||||
The SSE2 run contains 1,615 cases. There is no overall parity percentage: fixtures overlap,
|
||||
boundary/rejection probes are included, and most behavior combinations remain untested.
|
||||
|
||||
| Result | Cases |
|
||||
| Catalog | Entries |
|
||||
|---|---:|
|
||||
| Exact raw image components | 254 |
|
||||
| Exact typed values | 384 |
|
||||
| Image component differences | 730 |
|
||||
| Typed value differences | 113 |
|
||||
| Local cook/evaluation errors | 82 |
|
||||
| Output size differences | 32 |
|
||||
| Reference cooker errors | 19 |
|
||||
| Numeric typed readback unavailable | 1 |
|
||||
| Main graph | 29: 25 primitives and four input/output items |
|
||||
| Function graph | 85 operations |
|
||||
| FX-Map graph | Quadrant, Switch, Iterate and Dot |
|
||||
| Loaded package functions | 954, including 689 hidden entries |
|
||||
|
||||
Comparable images contain 4,184,576 measured components, with 1,565,349 component mismatches
|
||||
across 838,708 pixels. Typed reports describe 874 components, including one unavailable
|
||||
numeric component. Each case reports its
|
||||
own maximum error and mismatch count; mixing integer errors, normalized pixels and HDR errors
|
||||
into a single maximum would be misleading. All compared images had their required channels;
|
||||
none of the exact image cases relied on an invented alpha channel. No harness or renderer
|
||||
process failed in this run.
|
||||
The earlier count of 26 primitives included the removed `motion_blur` wrapper around
|
||||
Directional Blur. The current count of 25 includes Dot/reroute. These corrections change
|
||||
no catalog membership.
|
||||
|
||||
Five cooker errors are the two constant-string output probes, two string-get output probes
|
||||
and unconnected passthrough. Fourteen more reject Pixel Processor outputs of Float2, Float3,
|
||||
Boolean or integer types in gray/color mode. Their local errors are recorded independently;
|
||||
Float2/Float3 are accepted locally, while the reference transport is rejected. Strings are
|
||||
also tested through original equality graphs that
|
||||
produce a legal material value; rejection of a string material output does not demonstrate
|
||||
that a string operation is unsupported. The unavailable numeric readback is the nested
|
||||
function assignment case. Missing-resource output sizes account for part of the size group;
|
||||
for example, the missing Bitmap produces 16×16 locally versus 256×256 in its reference probe.
|
||||
Package counts describe availability. Function-body behavior and redistribution rights
|
||||
require separate verification; the 954 loaded package function bodies remain untested.
|
||||
|
||||
## Method and reproduction
|
||||
## Implemented corrections
|
||||
|
||||
The reference desktop runtime was 16.0.7 with MCP bridge 1.1.0. MCP opened original scratch
|
||||
packages and enumerated graph definitions. The public SDK inspected native port types and
|
||||
simple numeric/Boolean defaults. Nonempty product strings, descriptions and complex asset
|
||||
defaults were excluded. The bridge cannot author function bodies or return raw pixels;
|
||||
original SBS probes were therefore cooked and rendered with the installed command-line tools.
|
||||
An original SDK-authored loop also isolated the loop-limit serialization failure.
|
||||
- Missing function operands use their input types, including vectors, casts, Boolean
|
||||
operations and sampler coordinates. Partially connected vectors retain connected lanes.
|
||||
- Missing textures produce appropriate zero pixels and image kinds in Channels Shuffle,
|
||||
HSL, Emboss and Dynamic Gradient.
|
||||
- Fresh-node defaults are corrected for Uniform Color, function constants, loop limits
|
||||
and several image and pattern nodes.
|
||||
- Grayscale image-input defaults serialize as scalars. Function loop limits use the scalar
|
||||
integer tag. Channel selector values survive signed SBS save/load.
|
||||
- Filter kernels, rectangular scaling, independent tiling, channel selection and empty
|
||||
Text/SVG backgrounds are covered in [atomic node corrections](atomic-parity-improvements.md).
|
||||
|
||||
Run from the repository root, with an absolute writable output directory and the directory
|
||||
containing the reference `sbscooker.exe` and `sbsrender.exe` tools:
|
||||
Regression coverage lives in the nodes, formats and eval test suites. These tests execute
|
||||
MaterialCraft code and use original procedural fixtures.
|
||||
|
||||
```powershell
|
||||
cargo run -p materialcraft-engine --release --example catalog_parity -- C:/parity/results C:/reference/tools
|
||||
```
|
||||
## Remaining work
|
||||
|
||||
An optional final argument selects case names by substring, for example `function_dot_`,
|
||||
`control_loop_`, `pixel_sample_`, `fx_iterate_` or `precision_`. Omitting the reference-tool
|
||||
directory inventories the catalogs and cooks the original probes locally, marking comparisons
|
||||
untested. `MC_PARITY_REFERENCE_ENGINE` selects a different installed backend; the recorded
|
||||
baseline uses `sse2`. Backend equivalence is untested.
|
||||
Full behavioral parity is unestablished. Outstanding areas include:
|
||||
|
||||
The example is in [catalog_parity.rs](../crates/engine/examples/catalog_parity.rs). Each case
|
||||
retains `probe.sbs`, the transport copy `reference.sbs`, any original procedural resources,
|
||||
reference EXR, cooker/renderer logs and exit status. `inventory.json`, `library-inventory.json`
|
||||
and `report.json` record catalogs and results. Reference results are reused only when the probe,
|
||||
input pixels and selected backend have the same SHA-256 key; local cooking runs again.
|
||||
Use a new directory when changing the installed runtime. No installed library graph, preset,
|
||||
font, image or other proprietary asset is used as a probe input. Image inputs are generated
|
||||
coordinate ramps, a checker and an alpha ramp; resource probes use original PGM and SVG data.
|
||||
Text probes use empty text, so reference glyph/font rendering is untested.
|
||||
- Filter sampling, image boundaries and output sizing.
|
||||
- Scalar/vector conversions, invalid-input handling, overflow and precision policy.
|
||||
- Function execution order, shared state, loop behavior and variable scope.
|
||||
- Random sequences, sampler coordinates and explicit addressing modes.
|
||||
- FX-Map shape rasterization, roughness/depth weighting and assignment scope.
|
||||
- Nonempty text/vector rendering, arbitrary SBS round trips and version-header compatibility.
|
||||
|
||||
**Transport limitation:** MaterialCraft writes its application version `0.4.1` into the SBS
|
||||
format/updater headers. The reference rejects that header. The runner preserves the original
|
||||
file and changes only those two fields in a separate transport copy to `1.1.0.202502`, measured
|
||||
from an empty reference package. Numerical results therefore do not establish that an
|
||||
unmodified MaterialCraft file opens in the reference app. This remains a separate format gap.
|
||||
Exhaustive parameter combinations, deeply nested processors/maps, arbitrary non-finite
|
||||
payloads, dynamic resource selection and every resolution/aspect ratio remain untested.
|
||||
Local safety tests cover cycles, allocation limits and execution budgets.
|
||||
|
||||
Reference images are exported as Float32 EXR without display transforms and compared with the
|
||||
actual CPU cook, before any preview or texture export. Only channels present in the reference
|
||||
EXR are compared. Gray compares its one scalar channel; color compares available RGBA channels.
|
||||
Missing alpha is explicitly unmeasured. Image components use Float32 bit equality, including
|
||||
signed zero and NaN payloads. The report records component and pixel mismatch counts, sample
|
||||
counts and maximum finite absolute error. A non-finite mismatch makes the overall maximum
|
||||
error unavailable. Size/kind mismatches and cook errors are recorded before numerical comparison;
|
||||
error-placeholder images never count as numerical evidence.
|
||||
## Validation limits
|
||||
|
||||
Typed reference results use the renderer's typed JSON values. Integers retain exact 32-bit
|
||||
comparisons; floats compare numeric Float32 values because JSON loses signed zero. Boolean
|
||||
and string comparisons have no numerical error metric. A numeric JSON `null` cannot identify
|
||||
the non-finite value or its bits: it is marked `unmeasurable_value`, with no invented mismatch
|
||||
count or maximum error. Type matches are recorded independently.
|
||||
|
||||
## Measured scope
|
||||
|
||||
Every native main-graph entry has a default/unconnected probe; every function operation has
|
||||
nominal and unconnected probes. Not every nominal fixture is within every reference port's
|
||||
accepted type: deliberately invalid scalar dot products, mixed comparisons, conversions and
|
||||
integer vector operations test rejection/default behavior. These cases do not establish
|
||||
support for those types. `function_dot_nominal` uses valid Float2 operands.
|
||||
|
||||
The additional cases cover scalar and vector arithmetic, 32-bit integer boundaries and values
|
||||
above Float32's exact-integer range, casts, swizzles, comparison types, strings, Boolean logic,
|
||||
division by zero, negative roots and logarithms, overflow, underflow and signed zero. Finite
|
||||
original inputs generate the non-finite intermediates; literal non-finite SBS constants are
|
||||
not validated.
|
||||
|
||||
Connected image cases use 16×16, 32×16 and 64×64, gray/color inputs, all four tiling flags,
|
||||
parameter endpoints and every catalog blend mode. Processor cases include pixel position,
|
||||
scope variables, nine numeric/Boolean output types in gray/color mode, scalar/vector random
|
||||
values, seeds 0/1/7/−1, nearest/bilinear samplers at
|
||||
interior, origin, unit and outside coordinates, and both Value Processor and Pixel Processor.
|
||||
Precision cases cover U8, U16, F16 and F32, negative/HDR values and a 256×256 coordinate ramp.
|
||||
Local fallback regressions additionally use 3×5; that odd size is not a reference measurement.
|
||||
|
||||
Execution probes cover lazy branches, sequences, shared variable reads with and without an
|
||||
observable snapshot, constant and stateful loops with zero/positive/negative limits, original
|
||||
reusable function calls, assignments crossing calls, Value Processor feeding Pixel Processor,
|
||||
nested material processors, and FX-Map sampling a Pixel Processor. Map cases cover all four
|
||||
node kinds, shapes 2–18, nested quadrants, depth/roughness, switch branches, iteration counts,
|
||||
assignment state, scope variables, seeds and three additional precisions.
|
||||
|
||||
## Narrow corrections
|
||||
|
||||
The regression groups failed before their respective corrections. Existing tests that intended
|
||||
mid-gray Uniform Color or neutral FX-Map weighting now set those fixture parameters explicitly.
|
||||
|
||||
| Correction | Measured behavior and regression |
|
||||
|---|---|
|
||||
| Fresh defaults | Uniform black/opaque; Blur 10; Distance combine true; Emboss angle zero and transparent black shadow; map roughness 1 and color mode; dynamic gradient position zero; grayscale matte 1; Normal flags false/true; Text size 0.25 and empty string; Float/Float4 constants zero; loop limit 32. `fresh_catalog_defaults_match_runtime_inspection` |
|
||||
| Missing textures | Channels Shuffle and HSL transparent black; Emboss and missing dynamic gradient gray black, with measured image kinds. `absent_textures_match_measured_zero_pixels_and_kinds` |
|
||||
| Unwired function operands | Zero values use operand types rather than result types, including casts, logic, samplers, Cartesian construction, swizzles and missing vector lanes. `function/unconnected.test.rs` |
|
||||
| Grayscale image-input defaults | Write scalar native defaults, preserving the first channel of legacy color authoring values. `parity_input_defaults.rs` |
|
||||
| Loop-limit serialization | Write the function's scalar integer tag (`constantValueInt1`); the enum-style tag caused a reference cooker error. `parity_function_loop.rs` |
|
||||
|
||||
The Normal default mapping was additionally measured with a vertical height ramp for each
|
||||
Boolean setting; residual errors of up to 5.960464477539063e−8 remain, so this is not exact
|
||||
normal-kernel parity. Defaults aligning does not imply kernel equivalence.
|
||||
|
||||
## Remaining differences and untested behavior
|
||||
|
||||
The per-case CSV is the authoritative numerical ledger. Remaining differences include filter
|
||||
kernels and boundary handling, scalar/vector/type conversions and invalid-input behavior,
|
||||
overflow policy, scope availability, random sequences outside the measured FX context, sampler
|
||||
coordinates/addressing, precision/quantization, node output sizing, map shape rasterization,
|
||||
roughness/depth weighting and assignment scope. These need independent minimal investigations;
|
||||
a render mismatch alone does not identify which layer is responsible.
|
||||
|
||||
Concrete examples: `control_observable_snapshot_pixelfalse` returns 0 locally and 0.75 in the
|
||||
reference (one value mismatch, maximum error 0.75); the corresponding Pixel Processor differs
|
||||
at all 256 pixels. An immediately true constant loop returns its initial 0.25 locally and zero
|
||||
in the reference. Stateful loop limits −1/0/1/3 match the recorded cases in both processor
|
||||
contexts after the serialization fix. The F16 constant 0.1 differs by 2.4415552616119385e−5;
|
||||
F32 constant probes match. Those results warrant separate execution/precision investigations,
|
||||
without overriding the existing shared-node caching invariants from one graph alone.
|
||||
|
||||
In particular, the four measured FX scalar random seeds match exactly; this does not generalize
|
||||
to Value Processor or Pixel Processor random streams. Relative-to-input tiling differs when
|
||||
the graph has no image input. Sampler addressing is separate from node tiling in the reference;
|
||||
the current model uses the evaluation context's tiling flag. Explicit sampler address modes
|
||||
and their serialized settings remain untested. Integer readback above 2²⁴ can differ even
|
||||
with a corrected native scalar constant tag; backend computation versus readback precision
|
||||
has not been isolated, so changing the local integer representation is not justified.
|
||||
|
||||
Untested: all 954 loaded package function bodies; other runtime versions and rendering backends;
|
||||
font/glyph equivalence; every curve/gradient knot or complex default; exhaustive enum/parameter
|
||||
combinations; explicit address modes; literal NaN/Infinity input serialization; all resolutions
|
||||
and aspect ratios beyond the listed fixtures; deeply nested processors/maps, nested loops,
|
||||
execution-budget equivalence, malformed-package/error-message equivalence, dynamic resource
|
||||
selection, and arbitrary SBS round trips. Local cycle, allocation and execution guards are
|
||||
covered by repository safety tests, without a reference error-semantics parity claim.
|
||||
|
||||
The raw captures live in the caller's chosen output directory and are intentionally not bundled
|
||||
as repository assets. Re-running the example reconstructs every tracked result case from
|
||||
original source. Broad parity remains unestablished.
|
||||
|
||||
## Validation
|
||||
|
||||
Passed: `cargo fmt --all --check`; `cargo test -p materialcraft-nodes --release`;
|
||||
`cargo test -p materialcraft-formats --release`;
|
||||
`cargo clippy --workspace --all-targets -- -D warnings`; `cargo xtask layers` (14 crates);
|
||||
and `cargo xtask wasm` (all ten packages). The example builds in release and completed all
|
||||
1,615 recorded cases. Existing manifest-level unused dependency/package-field warnings remain.
|
||||
|
||||
The engine release suite passes with
|
||||
`-- --skip byte_only_sbs_import_resolves_library_resource_substitutes`, including `panic_hunt`.
|
||||
The unfiltered run fails that resource/font test: the normal resource root exposes a font-byte
|
||||
expectation mismatch; an isolated root with an original generated EXR and no font also fails
|
||||
its saved-path expectation at `package_resources.rs:32`. Neither resource resolution nor those
|
||||
existing local assets were changed. This is an unresolved validation failure, so the full
|
||||
required release run is not reported green. Repository-ignored tests otherwise remain ignored.
|
||||
|
||||
Two ignored UI snapshot cases were explicitly run in release and their images inspected:
|
||||
`function_nodes_show_their_values_and_symbols` and
|
||||
`fresh_embedded_graphs_open_only_after_explicit_editing`. They show the zero function constants
|
||||
and the fresh processor/map editing workflow. Other UI snapshot cases were not rerun.
|
||||
Release suites for nodes, formats, eval and engine pass with the existing resource/font
|
||||
failure excluded. The known failure is
|
||||
`byte_only_sbs_import_resolves_library_resource_substitutes` at
|
||||
`crates/engine/tests/package_resources.rs:32`. Formatting, workspace Clippy, dependency
|
||||
layers and wasm checks pass. A fully green release suite is not claimed.
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -1,119 +0,0 @@
|
||||
catalog,id,inputs,parameters,reference_definition,reference_inventory
|
||||
atomic,bitmap,,resource|colour_space|color_mode,sbs::compositing::bitmap,runtime enumerated
|
||||
atomic,blend,foreground|background|mask,opacity|mode|alpha|color_blending,sbs::compositing::blend,runtime enumerated
|
||||
atomic,blur,input,intensity,sbs::compositing::blur,runtime enumerated
|
||||
atomic,channels_shuffle,input1|input2,red|green|blue|alpha,sbs::compositing::shuffle,runtime enumerated
|
||||
atomic,curve,input,curve,sbs::compositing::curve,runtime enumerated
|
||||
atomic,directional_blur,input,intensity|angle,sbs::compositing::dirmotionblur,runtime enumerated
|
||||
atomic,directional_warp,input|intensity_input,intensity|angle,sbs::compositing::directionalwarp,runtime enumerated
|
||||
atomic,distance,mask|source,distance|combine,sbs::compositing::distance,runtime enumerated
|
||||
atomic,emboss,input|height,intensity|light_angle|highlight|shadow,sbs::compositing::emboss,runtime enumerated
|
||||
atomic,fx_map,background|pattern0,pattern|roughness|opacity|color_mode|background|render_region|tiling_region,sbs::compositing::fxmaps,runtime enumerated
|
||||
atomic,gradient_dynamic,input|gradient,position|orientation,sbs::compositing::dyngradient,runtime enumerated
|
||||
atomic,gradient_map,input,gradient|color_mode,sbs::compositing::gradient,runtime enumerated
|
||||
atomic,grayscale_conversion,input,red|green|blue|alpha|flatten_alpha|matte,sbs::compositing::grayscaleconversion,runtime enumerated
|
||||
atomic,hsl,input,hue|saturation|lightness,sbs::compositing::hsl,runtime enumerated
|
||||
atomic,levels,input,in_low|in_mid|in_high|out_low|out_high,sbs::compositing::levels,runtime enumerated
|
||||
atomic,normal,input,intensity|opengl|height_alpha,sbs::compositing::normal,runtime enumerated
|
||||
atomic,pixel_processor,input0,function|color_mode,sbs::compositing::pixelprocessor,runtime enumerated
|
||||
atomic,svg,background,resource|color_mode|background,sbs::compositing::svg,runtime enumerated
|
||||
atomic,sharpen,input,intensity,sbs::compositing::sharpen,runtime enumerated
|
||||
atomic,text,background,color_mode|background|text|fontdata|fontsize|position|matrix|alignment,sbs::compositing::text,runtime enumerated
|
||||
atomic,transformation,input,offset|matrix|filtering|matte,sbs::compositing::transformation,runtime enumerated
|
||||
atomic,uniform,,color|color_mode,sbs::compositing::uniform,runtime enumerated
|
||||
atomic,value_processor,input0,function,sbs::compositing::valueprocessor,runtime enumerated
|
||||
atomic,warp,input|gradient,intensity,sbs::compositing::warp,runtime enumerated
|
||||
atomic,input_color,,identifier|usage|default,sbs::compositing::input_color,runtime enumerated
|
||||
atomic,input_grayscale,,identifier|usage|default,sbs::compositing::input_grayscale,runtime enumerated
|
||||
atomic,input_value,,identifier|usage|default,sbs::compositing::input_value,runtime enumerated
|
||||
atomic,output,input,identifier|usage,sbs::compositing::output,runtime enumerated
|
||||
atomic,dot,input,,sbs::compositing::passthrough,runtime enumerated
|
||||
function,const_float1,,,sbs::function::const_float1,runtime enumerated
|
||||
function,const_float2,,,sbs::function::const_float2,runtime enumerated
|
||||
function,const_float3,,,sbs::function::const_float3,runtime enumerated
|
||||
function,const_float4,,,sbs::function::const_float4,runtime enumerated
|
||||
function,const_int1,,,sbs::function::const_int1,runtime enumerated
|
||||
function,const_int2,,,sbs::function::const_int2,runtime enumerated
|
||||
function,const_int3,,,sbs::function::const_int3,runtime enumerated
|
||||
function,const_int4,,,sbs::function::const_int4,runtime enumerated
|
||||
function,const_bool,,,sbs::function::const_bool,runtime enumerated
|
||||
function,const_string,,,sbs::function::const_string,runtime enumerated
|
||||
function,vector2,componentsin|componentslast,,sbs::function::vector2,runtime enumerated
|
||||
function,vector3,componentsin|componentslast,,sbs::function::vector3,runtime enumerated
|
||||
function,vector4,componentsin|componentslast,,sbs::function::vector4,runtime enumerated
|
||||
function,swizzle1,vector,,sbs::function::swizzle1,runtime enumerated
|
||||
function,swizzle2,vector,,sbs::function::swizzle2,runtime enumerated
|
||||
function,swizzle3,vector,,sbs::function::swizzle3,runtime enumerated
|
||||
function,swizzle4,vector,,sbs::function::swizzle4,runtime enumerated
|
||||
function,ivector2,componentsin|componentslast,,sbs::function::ivector2,runtime enumerated
|
||||
function,ivector3,componentsin|componentslast,,sbs::function::ivector3,runtime enumerated
|
||||
function,ivector4,componentsin|componentslast,,sbs::function::ivector4,runtime enumerated
|
||||
function,iswizzle1,vector,,sbs::function::iswizzle1,runtime enumerated
|
||||
function,iswizzle2,vector,,sbs::function::iswizzle2,runtime enumerated
|
||||
function,iswizzle3,vector,,sbs::function::iswizzle3,runtime enumerated
|
||||
function,iswizzle4,vector,,sbs::function::iswizzle4,runtime enumerated
|
||||
function,set,value,,sbs::function::set,runtime enumerated
|
||||
function,get_float1,,,sbs::function::get_float1,runtime enumerated
|
||||
function,get_float2,,,sbs::function::get_float2,runtime enumerated
|
||||
function,get_float3,,,sbs::function::get_float3,runtime enumerated
|
||||
function,get_float4,,,sbs::function::get_float4,runtime enumerated
|
||||
function,get_integer1,,,sbs::function::get_integer1,runtime enumerated
|
||||
function,get_integer2,,,sbs::function::get_integer2,runtime enumerated
|
||||
function,get_integer3,,,sbs::function::get_integer3,runtime enumerated
|
||||
function,get_integer4,,,sbs::function::get_integer4,runtime enumerated
|
||||
function,get_bool,,,sbs::function::get_bool,runtime enumerated
|
||||
function,get_string,,,sbs::function::get_string,runtime enumerated
|
||||
function,isdefined,,,sbs::function::isdefined,runtime enumerated
|
||||
function,samplelum,pos,,sbs::function::samplelum,runtime enumerated
|
||||
function,samplecol,pos,,sbs::function::samplecol,runtime enumerated
|
||||
function,tofloat,value,,sbs::function::tofloat,runtime enumerated
|
||||
function,tofloat2,value,,sbs::function::tofloat2,runtime enumerated
|
||||
function,tofloat3,value,,sbs::function::tofloat3,runtime enumerated
|
||||
function,tofloat4,value,,sbs::function::tofloat4,runtime enumerated
|
||||
function,toint1,value,,sbs::function::toint1,runtime enumerated
|
||||
function,toint2,value,,sbs::function::toint2,runtime enumerated
|
||||
function,toint3,value,,sbs::function::toint3,runtime enumerated
|
||||
function,toint4,value,,sbs::function::toint4,runtime enumerated
|
||||
function,add,a|b,,sbs::function::add,runtime enumerated
|
||||
function,sub,a|b,,sbs::function::sub,runtime enumerated
|
||||
function,mul,a|b,,sbs::function::mul,runtime enumerated
|
||||
function,mulscalar,a|scalar,,sbs::function::mulscalar,runtime enumerated
|
||||
function,div,a|b,,sbs::function::div,runtime enumerated
|
||||
function,neg,a,,sbs::function::neg,runtime enumerated
|
||||
function,mod,a|b,,sbs::function::mod,runtime enumerated
|
||||
function,dot,a|b,,sbs::function::passthrough,runtime enumerated
|
||||
function,and,a|b,,sbs::function::and,runtime enumerated
|
||||
function,or,a|b,,sbs::function::or,runtime enumerated
|
||||
function,not,a,,sbs::function::not,runtime enumerated
|
||||
function,eq,a|b,,sbs::function::eq,runtime enumerated
|
||||
function,noteq,a|b,,sbs::function::noteq,runtime enumerated
|
||||
function,gt,a|b,,sbs::function::gt,runtime enumerated
|
||||
function,gteq,a|b,,sbs::function::gteq,runtime enumerated
|
||||
function,lr,a|b,,sbs::function::lr,runtime enumerated
|
||||
function,lreq,a|b,,sbs::function::lreq,runtime enumerated
|
||||
function,abs,a,,sbs::function::abs,runtime enumerated
|
||||
function,floor,a,,sbs::function::floor,runtime enumerated
|
||||
function,ceil,a,,sbs::function::ceil,runtime enumerated
|
||||
function,cos,a,,sbs::function::cos,runtime enumerated
|
||||
function,sin,a,,sbs::function::sin,runtime enumerated
|
||||
function,tan,a,,sbs::function::tan,runtime enumerated
|
||||
function,atan2,a,,sbs::function::atan2,runtime enumerated
|
||||
function,cartesian,rho|theta,,sbs::function::cartesian,runtime enumerated
|
||||
function,sqrt,a,,sbs::function::sqrt,runtime enumerated
|
||||
function,log,a,,sbs::function::log,runtime enumerated
|
||||
function,exp,a,,sbs::function::exp,runtime enumerated
|
||||
function,log2,a,,sbs::function::log2,runtime enumerated
|
||||
function,pow2,a,,sbs::function::pow2,runtime enumerated
|
||||
function,pow,a|b,,sbs::function::pow,runtime enumerated
|
||||
function,lerp,a|b|x,,sbs::function::lerp,runtime enumerated
|
||||
function,min,a|b,,sbs::function::min,runtime enumerated
|
||||
function,max,a|b,,sbs::function::max,runtime enumerated
|
||||
function,rand,a,,sbs::function::rand,runtime enumerated
|
||||
function,sequence,seqin|seqlast,,sbs::function::sequence,runtime enumerated
|
||||
function,ifelse,condition|ifpath|elsepath,,sbs::function::ifelse,runtime enumerated
|
||||
function,while,init|cond|loop,,sbs::function::while,runtime enumerated
|
||||
function,passthrough,input,,sbs::function::passthrough,runtime enumerated
|
||||
pattern,passthrough,,,passthrough,runtime enumerated
|
||||
pattern,paramset,,patterntype|opacity|branchoffset|frameoffset|patternsize|patternrotation|patternsuppl|blendingmode|imagefiltering|imagepremul|imageindex|randomseed|randominherited,paramset,model inventory; original render probe
|
||||
pattern,markov2,,switch|randomseed|randominherited,markov2,model inventory; original render probe
|
||||
pattern,addnode,,numberadded|randomseed|randominherited,addnode,model inventory; original render probe
|
||||
|
@@ -1,119 +0,0 @@
|
||||
catalog,id,baseline_cases,baseline_statuses,remaining_behavior
|
||||
atomic,bitmap,atomic_bitmap_unconnected,size_mismatch,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,blend,atomic_blend_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,blur,atomic_blur_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,channels_shuffle,atomic_channels_shuffle_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,curve,atomic_curve_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,directional_blur,atomic_directional_blur_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,directional_warp,atomic_directional_warp_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,distance,atomic_distance_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,emboss,atomic_emboss_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,fx_map,atomic_fx_map_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,gradient_dynamic,atomic_gradient_dynamic_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,gradient_map,atomic_gradient_map_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,grayscale_conversion,atomic_grayscale_conversion_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,hsl,atomic_hsl_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,levels,atomic_levels_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,normal,atomic_normal_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,pixel_processor,atomic_pixel_processor_unconnected,local_error,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,svg,atomic_svg_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,sharpen,atomic_sharpen_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,text,atomic_text_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,transformation,atomic_transformation_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,uniform,atomic_uniform_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,value_processor,atomic_value_processor_unconnected,local_error,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,warp,atomic_warp_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,input_color,atomic_input_color_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,input_grayscale,atomic_input_grayscale_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,input_value,atomic_input_value_unconnected,exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,output,atomic_output_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
atomic,dot,atomic_dot_unconnected,exact,not exhaustive; see case ledger and explicit untested scope
|
||||
function,const_float1,function_const_float1_nominal|function_const_float1_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,const_float2,function_const_float2_nominal|function_const_float2_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,const_float3,function_const_float3_nominal|function_const_float3_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,const_float4,function_const_float4_nominal|function_const_float4_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,const_int1,function_const_int1_nominal|function_const_int1_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,const_int2,function_const_int2_nominal|function_const_int2_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,const_int3,function_const_int3_nominal|function_const_int3_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,const_int4,function_const_int4_nominal|function_const_int4_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,const_bool,function_const_bool_nominal|function_const_bool_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,const_string,function_const_string_nominal|function_const_string_unconnected,reference_cook_error|reference_cook_error,not exhaustive; see case ledger and explicit untested scope
|
||||
function,vector2,function_vector2_nominal|function_vector2_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,vector3,function_vector3_nominal|function_vector3_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,vector4,function_vector4_nominal|function_vector4_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,swizzle1,function_swizzle1_nominal|function_swizzle1_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,swizzle2,function_swizzle2_nominal|function_swizzle2_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,swizzle3,function_swizzle3_nominal|function_swizzle3_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,swizzle4,function_swizzle4_nominal|function_swizzle4_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,ivector2,function_ivector2_nominal|function_ivector2_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,ivector3,function_ivector3_nominal|function_ivector3_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,ivector4,function_ivector4_nominal|function_ivector4_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,iswizzle1,function_iswizzle1_nominal|function_iswizzle1_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,iswizzle2,function_iswizzle2_nominal|function_iswizzle2_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,iswizzle3,function_iswizzle3_nominal|function_iswizzle3_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,iswizzle4,function_iswizzle4_nominal|function_iswizzle4_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,set,function_set_nominal|function_set_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,get_float1,function_get_float1_nominal|function_get_float1_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,get_float2,function_get_float2_nominal|function_get_float2_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,get_float3,function_get_float3_nominal|function_get_float3_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,get_float4,function_get_float4_nominal|function_get_float4_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,get_integer1,function_get_integer1_nominal|function_get_integer1_unconnected,value_mismatch|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,get_integer2,function_get_integer2_nominal|function_get_integer2_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,get_integer3,function_get_integer3_nominal|function_get_integer3_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,get_integer4,function_get_integer4_nominal|function_get_integer4_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,get_bool,function_get_bool_nominal|function_get_bool_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,get_string,function_get_string_nominal|function_get_string_unconnected,reference_cook_error|reference_cook_error,not exhaustive; see case ledger and explicit untested scope
|
||||
function,isdefined,function_isdefined_nominal|function_isdefined_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,samplelum,function_samplelum_nominal|function_samplelum_unconnected,value_mismatch|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,samplecol,function_samplecol_nominal|function_samplecol_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,tofloat,function_tofloat_nominal|function_tofloat_unconnected,value_mismatch|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,tofloat2,function_tofloat2_nominal|function_tofloat2_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,tofloat3,function_tofloat3_nominal|function_tofloat3_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,tofloat4,function_tofloat4_nominal|function_tofloat4_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,toint1,function_toint1_nominal|function_toint1_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,toint2,function_toint2_nominal|function_toint2_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,toint3,function_toint3_nominal|function_toint3_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,toint4,function_toint4_nominal|function_toint4_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,add,function_add_nominal|function_add_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,sub,function_sub_nominal|function_sub_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,mul,function_mul_nominal|function_mul_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,mulscalar,function_mulscalar_nominal|function_mulscalar_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,div,function_div_nominal|function_div_unconnected,exact_value|local_error,not exhaustive; see case ledger and explicit untested scope
|
||||
function,neg,function_neg_nominal|function_neg_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,mod,function_mod_nominal|function_mod_unconnected,exact_value|local_error,not exhaustive; see case ledger and explicit untested scope
|
||||
function,dot,function_dot_nominal|function_dot_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,and,function_and_nominal|function_and_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,or,function_or_nominal|function_or_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,not,function_not_nominal|function_not_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,eq,function_eq_nominal|function_eq_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,noteq,function_noteq_nominal|function_noteq_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,gt,function_gt_nominal|function_gt_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,gteq,function_gteq_nominal|function_gteq_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,lr,function_lr_nominal|function_lr_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,lreq,function_lreq_nominal|function_lreq_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,abs,function_abs_nominal|function_abs_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,floor,function_floor_nominal|function_floor_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,ceil,function_ceil_nominal|function_ceil_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,cos,function_cos_nominal|function_cos_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,sin,function_sin_nominal|function_sin_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,tan,function_tan_nominal|function_tan_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,atan2,function_atan2_nominal|function_atan2_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,cartesian,function_cartesian_nominal|function_cartesian_unconnected,value_mismatch|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,sqrt,function_sqrt_nominal|function_sqrt_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,log,function_log_nominal|function_log_unconnected,exact_value|local_error,not exhaustive; see case ledger and explicit untested scope
|
||||
function,exp,function_exp_nominal|function_exp_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,log2,function_log2_nominal|function_log2_unconnected,exact_value|local_error,not exhaustive; see case ledger and explicit untested scope
|
||||
function,pow2,function_pow2_nominal|function_pow2_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,pow,function_pow_nominal|function_pow_unconnected,exact_value|value_mismatch,not exhaustive; see case ledger and explicit untested scope
|
||||
function,lerp,function_lerp_nominal|function_lerp_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,min,function_min_nominal|function_min_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,max,function_max_nominal|function_max_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,rand,function_rand_nominal|function_rand_unconnected,value_mismatch|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,sequence,function_sequence_nominal|function_sequence_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,ifelse,function_ifelse_nominal|function_ifelse_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,while,function_while_nominal|function_while_unconnected,exact_value|exact_value,not exhaustive; see case ledger and explicit untested scope
|
||||
function,passthrough,function_passthrough_nominal|function_passthrough_unconnected,exact_value|reference_cook_error,not exhaustive; see case ledger and explicit untested scope
|
||||
pattern,passthrough,pattern_passthrough_4x4|pattern_passthrough_5x4|pattern_passthrough_6x6,exact|exact|exact,not exhaustive; see case ledger and explicit untested scope
|
||||
pattern,paramset,pattern_paramset_4x4|pattern_paramset_5x4|pattern_paramset_6x6,exact|exact|exact,not exhaustive; see case ledger and explicit untested scope
|
||||
pattern,markov2,pattern_markov2_4x4|pattern_markov2_5x4|pattern_markov2_6x6,exact|exact|exact,not exhaustive; see case ledger and explicit untested scope
|
||||
pattern,addnode,pattern_addnode_4x4|pattern_addnode_5x4|pattern_addnode_6x6,pixel_mismatch|pixel_mismatch|pixel_mismatch,not exhaustive; see case ledger and explicit untested scope
|
||||
|
@@ -1,137 +0,0 @@
|
||||
catalog,node,parameter,local_type,local_value,reference_parameter,reference_type,reference_value,status
|
||||
atomic,bitmap,resource,text,"""""",resource,,,unmeasured
|
||||
atomic,bitmap,colour_space,enum,0,colorspace,,,unmeasured
|
||||
atomic,bitmap,color_mode,bool,true,colorswitch,bool,true,equal
|
||||
atomic,blend,opacity,float,1.0,opacitymult,float,1.0,equal
|
||||
atomic,blend,mode,enum,0,blendingmode,sbs::compositing::blendingmode,0,equal
|
||||
atomic,blend,alpha,bool,true,alphablending,bool,true,equal
|
||||
atomic,blend,color_blending,enum,0,colorblending,sbs::compositing::colorblending,0,equal
|
||||
atomic,blur,intensity,float,10.0,intensity,float,10.0,equal
|
||||
atomic,channels_shuffle,red,enum,0,channelred,sbs::compositing::channelred,0,equal
|
||||
atomic,channels_shuffle,green,enum,1,channelgreen,sbs::compositing::channelgreen,1,equal
|
||||
atomic,channels_shuffle,blue,enum,2,channelblue,sbs::compositing::channelblue,2,equal
|
||||
atomic,channels_shuffle,alpha,enum,3,channelalpha,sbs::compositing::channelalpha,3,equal
|
||||
atomic,curve,curve,curve,"{""points"":[{""x"":0.0,""y"":0.0},{""x"":1.0,""y"":1.0}]}",curve,,,unmeasured
|
||||
atomic,directional_blur,intensity,float,10.0,intensity,float,10.0,equal
|
||||
atomic,directional_blur,angle,float,0.0,mblurangle,float,0.0,equal
|
||||
atomic,directional_warp,intensity,float,10.0,intensity,float,10.0,equal
|
||||
atomic,directional_warp,angle,float,0.0,warpangle,float,0.0,equal
|
||||
atomic,distance,distance,float,10.0,distance,float,10.0,equal
|
||||
atomic,distance,combine,bool,true,combinedistance,bool,true,equal
|
||||
atomic,emboss,intensity,float,5.0,intensity,float,5.0,equal
|
||||
atomic,emboss,light_angle,float,0.0,lightangle,float,0.0,equal
|
||||
atomic,emboss,highlight,color,"[1.0,1.0,1.0,1.0]",highlightcolor,ColorRGBA,"[1.0,1.0,1.0,1.0]",equal
|
||||
atomic,emboss,shadow,color,"[0.0,0.0,0.0,0.0]",shadowcolor,ColorRGBA,"[0.0,0.0,0.0,0.0]",equal
|
||||
atomic,fx_map,pattern,patternGraph,"{""nodes"":[{""children"":[null,null,null,null],""id"":1,""kind"":""paramset"",""parameters"":{},""position"":[0.0,0.0]}],""root"":1}",pattern,,,unmeasured
|
||||
atomic,fx_map,roughness,float,1.0,hurst,float,1.0,equal
|
||||
atomic,fx_map,opacity,float,1.0,opacitymult,float,1.0,equal
|
||||
atomic,fx_map,color_mode,bool,true,colorswitch,bool,true,equal
|
||||
atomic,fx_map,background,color,"[0.0,0.0,0.0,0.0]",background,ColorRGBA,,unmeasured
|
||||
atomic,fx_map,render_region,float4,"[0.0,1.0,0.0,1.0]",renderroi,float4,"[0.0,1.0,0.0,1.0]",equal
|
||||
atomic,fx_map,tiling_region,float4,"[0.0,1.0,0.0,1.0]",tilingroi,float4,"[0.0,1.0,0.0,1.0]",equal
|
||||
atomic,gradient_dynamic,position,float,0.0,coordinate,float,0.0,equal
|
||||
atomic,gradient_dynamic,orientation,enum,0,uvselector,sbs::compositing::uvselector,0,equal
|
||||
atomic,gradient_map,gradient,gradient,"{""keys"":[{""color"":[0.0,0.0,0.0,1.0],""midpoint"":0.5,""pos"":0.0},{""color"":[1.0,1.0,1.0,1.0],""midpoint"":0.5,""pos"":1.0}]}",gradient,,,unmeasured
|
||||
atomic,gradient_map,color_mode,bool,true,colorswitch,bool,true,equal
|
||||
atomic,grayscale_conversion,red,float,0.3333333432674408,red,,,unmeasured
|
||||
atomic,grayscale_conversion,green,float,0.3333333432674408,green,,,unmeasured
|
||||
atomic,grayscale_conversion,blue,float,0.3333333432674408,blue,,,unmeasured
|
||||
atomic,grayscale_conversion,alpha,float,0.0,alpha,,,unmeasured
|
||||
atomic,grayscale_conversion,flatten_alpha,bool,false,alphamult,bool,false,equal
|
||||
atomic,grayscale_conversion,matte,float,1.0,mattelevel,float,1.0,equal
|
||||
atomic,hsl,hue,float,0.5,hue,float,0.5,equal
|
||||
atomic,hsl,saturation,float,0.5,saturation,float,0.5,equal
|
||||
atomic,hsl,lightness,float,0.5,luminosity,float,0.5,equal
|
||||
atomic,levels,in_low,float4,"[0.0,0.0,0.0,0.0]",levelinlow,float4,"[0.0,0.0,0.0,0.0]",equal
|
||||
atomic,levels,in_mid,float4,"[0.5,0.5,0.5,0.5]",levelinmid,float4,"[0.5,0.5,0.5,0.5]",equal
|
||||
atomic,levels,in_high,float4,"[1.0,1.0,1.0,1.0]",levelinhigh,float4,"[1.0,1.0,1.0,1.0]",equal
|
||||
atomic,levels,out_low,float4,"[0.0,0.0,0.0,0.0]",leveloutlow,float4,"[0.0,0.0,0.0,0.0]",equal
|
||||
atomic,levels,out_high,float4,"[1.0,1.0,1.0,1.0]",levelouthigh,float4,"[1.0,1.0,1.0,1.0]",equal
|
||||
atomic,normal,intensity,float,1.0,intensity,float,1.0,equal
|
||||
atomic,normal,opengl,bool,false,inversedy,bool,false,equal
|
||||
atomic,normal,height_alpha,bool,true,input2alpha,bool,true,equal
|
||||
atomic,pixel_processor,function,function,"{""nodes"":[],""output"":null}",perpixel,float4,,unmeasured
|
||||
atomic,pixel_processor,color_mode,bool,true,colorswitch,bool,true,equal
|
||||
atomic,svg,resource,text,"""""",resource,,,unmeasured
|
||||
atomic,svg,color_mode,bool,true,colorswitch,bool,true,equal
|
||||
atomic,svg,background,color,"[0.0,0.0,0.0,0.0]",background,ColorRGBA,,unmeasured
|
||||
atomic,sharpen,intensity,float,1.0,intensity,float,1.0,equal
|
||||
atomic,text,color_mode,bool,false,colorswitch,bool,false,equal
|
||||
atomic,text,background,color,"[0.0,0.0,0.0,1.0]",background,ColorRGBA,,unmeasured
|
||||
atomic,text,text,text,"""""",text,string,"""""",equal
|
||||
atomic,text,fontdata,text,"""""",fontdata,string,"""""",equal
|
||||
atomic,text,fontsize,float,0.25,fontsize,float,0.25,equal
|
||||
atomic,text,position,float2,"[0.0,0.0]",position,float2,"[0.0,0.0]",equal
|
||||
atomic,text,matrix,float4,"[1.0,0.0,0.0,1.0]",matrix22,float4,"[1.0,0.0,0.0,1.0]",equal
|
||||
atomic,text,alignment,enum,1,alignment,sbs::compositing::alignment,1,equal
|
||||
atomic,transformation,offset,float2,"[0.0,0.0]",offset,float2,"[0.0,0.0]",equal
|
||||
atomic,transformation,matrix,float4,"[1.0,0.0,0.0,1.0]",matrix22,float4,"[1.0,0.0,0.0,1.0]",equal
|
||||
atomic,transformation,filtering,enum,0,filtering,sbs::compositing::filtering,0,equal
|
||||
atomic,transformation,matte,color,"[0.0,0.0,0.0,0.0]",mattecolor,ColorRGBA,"[0.0,0.0,0.0,0.0]",equal
|
||||
atomic,uniform,color,color,"[0.0,0.0,0.0,1.0]",outputcolor,ColorRGBA,"[0.0,0.0,0.0,1.0]",equal
|
||||
atomic,uniform,color_mode,bool,true,colorswitch,bool,true,equal
|
||||
atomic,value_processor,function,function,"{""nodes"":[],""output"":null}",function,bool,,unmeasured
|
||||
atomic,warp,intensity,float,1.0,intensity,float,1.0,equal
|
||||
atomic,input_color,identifier,text,"""input""",identifier,string,,unmeasured
|
||||
atomic,input_color,usage,enum,9,usage,,,unmeasured
|
||||
atomic,input_color,default,color,"[0.5,0.5,0.5,1.0]",default,,,unmeasured
|
||||
atomic,input_grayscale,identifier,text,"""input""",identifier,string,,unmeasured
|
||||
atomic,input_grayscale,usage,enum,9,usage,,,unmeasured
|
||||
atomic,input_grayscale,default,color,"[0.5,0.5,0.5,1.0]",default,,,unmeasured
|
||||
atomic,input_value,identifier,text,"""value""",identifier,string,,unmeasured
|
||||
atomic,input_value,usage,enum,9,usage,,,unmeasured
|
||||
atomic,input_value,default,float,0.0,default,,,unmeasured
|
||||
atomic,output,identifier,text,"""output""",identifier,string,,unmeasured
|
||||
atomic,output,usage,enum,0,usage,,,unmeasured
|
||||
function,const_float1,setting,float,0.0,__constant__,float,0.0,equal
|
||||
function,const_float2,setting,float2,"[0.0,0.0]",__constant__,float2,"[0.0,0.0]",equal
|
||||
function,const_float3,setting,float3,"[0.0,0.0,0.0]",__constant__,float3,"[0.0,0.0,0.0]",equal
|
||||
function,const_float4,setting,float4,"[0.0,0.0,0.0,0.0]",__constant__,float4,"[0.0,0.0,0.0,0.0]",equal
|
||||
function,const_int1,setting,int,0,__constant__,int,0,equal
|
||||
function,const_int2,setting,int2,"[0,0]",__constant__,int2,"[0,0]",equal
|
||||
function,const_int3,setting,int3,"[0,0,0]",__constant__,int3,"[0,0,0]",equal
|
||||
function,const_int4,setting,int4,"[0,0,0,0]",__constant__,int4,"[0,0,0,0]",equal
|
||||
function,const_bool,setting,bool,false,__constant__,bool,false,equal
|
||||
function,const_string,setting,text,"""""",__constant__,string,"""""",equal
|
||||
function,swizzle1,setting,int,0,__constant__,int,0,equal
|
||||
function,swizzle2,setting,int2,"[0,1]",__constant__,int2,"[0,1]",equal
|
||||
function,swizzle3,setting,int3,"[0,1,2]",__constant__,int3,"[0,1,2]",equal
|
||||
function,swizzle4,setting,int4,"[0,1,2,3]",__constant__,int4,"[0,1,2,3]",equal
|
||||
function,iswizzle1,setting,int,0,__constant__,int,0,equal
|
||||
function,iswizzle2,setting,int2,"[0,1]",__constant__,int2,"[0,1]",equal
|
||||
function,iswizzle3,setting,int3,"[0,1,2]",__constant__,int3,"[0,1,2]",equal
|
||||
function,iswizzle4,setting,int4,"[0,1,2,3]",__constant__,int4,"[0,1,2,3]",equal
|
||||
function,set,setting,text,"""""",__constant__,string,"""""",equal
|
||||
function,get_float1,setting,text,"""""",__constant__,string,"""""",equal
|
||||
function,get_float2,setting,text,"""""",__constant__,string,"""""",equal
|
||||
function,get_float3,setting,text,"""""",__constant__,string,"""""",equal
|
||||
function,get_float4,setting,text,"""""",__constant__,string,"""""",equal
|
||||
function,get_integer1,setting,text,"""""",__constant__,string,"""""",equal
|
||||
function,get_integer2,setting,text,"""""",__constant__,string,"""""",equal
|
||||
function,get_integer3,setting,text,"""""",__constant__,string,"""""",equal
|
||||
function,get_integer4,setting,text,"""""",__constant__,string,"""""",equal
|
||||
function,get_bool,setting,text,"""""",__constant__,string,"""""",equal
|
||||
function,get_string,setting,text,"""""",__constant__,string,"""""",equal
|
||||
function,isdefined,setting,text,"""""",__constant__,string,"""""",equal
|
||||
function,samplelum,setting,int2,"[0,0]",__constant__,int2,"[0,0]",equal
|
||||
function,samplecol,setting,int2,"[0,0]",__constant__,int2,"[0,0]",equal
|
||||
function,while,setting,int,32,__constant__,int,32,equal
|
||||
pattern,paramset,patterntype,int,0,patterntype,,,unmeasured
|
||||
pattern,paramset,opacity,float4,"[1.0,1.0,1.0,1.0]",opacity,,,unmeasured
|
||||
pattern,paramset,branchoffset,float2,"[0.0,0.0]",branchoffset,,,unmeasured
|
||||
pattern,paramset,frameoffset,float2,"[0.0,0.0]",frameoffset,,,unmeasured
|
||||
pattern,paramset,patternsize,float2,"[1.0,1.0]",patternsize,,,unmeasured
|
||||
pattern,paramset,patternrotation,float,0.0,patternrotation,,,unmeasured
|
||||
pattern,paramset,patternsuppl,float,0.0,patternsuppl,,,unmeasured
|
||||
pattern,paramset,blendingmode,int,0,blendingmode,,,unmeasured
|
||||
pattern,paramset,imagefiltering,int,1,imagefiltering,,,unmeasured
|
||||
pattern,paramset,imagepremul,bool,false,imagepremul,,,unmeasured
|
||||
pattern,paramset,imageindex,int,1,imageindex,,,unmeasured
|
||||
pattern,paramset,randomseed,int,0,randomseed,,,unmeasured
|
||||
pattern,paramset,randominherited,bool,true,randominherited,,,unmeasured
|
||||
pattern,markov2,switch,bool,false,switch,,,unmeasured
|
||||
pattern,markov2,randomseed,int,0,randomseed,,,unmeasured
|
||||
pattern,markov2,randominherited,bool,true,randominherited,,,unmeasured
|
||||
pattern,addnode,numberadded,int,1,numberadded,,,unmeasured
|
||||
pattern,addnode,randomseed,int,0,randomseed,,,unmeasured
|
||||
pattern,addnode,randominherited,bool,true,randominherited,,,unmeasured
|
||||
|
@@ -1,955 +0,0 @@
|
||||
package,path,nodes,hidden,status
|
||||
sbs://3d_functions.sbs,maths/vec3_multiply_mat3,8,True,untested
|
||||
sbs://3d_functions.sbs,maths/mat3_multiply_vector,32,True,untested
|
||||
sbs://3d_functions.sbs,maths/quaternion_to_mat3,64,False,untested
|
||||
sbs://3d_functions.sbs,maths/quaternion_axis_angle,10,False,untested
|
||||
sbs://3d_functions.sbs,maths/quaternion_multiply,22,False,untested
|
||||
sbs://3d_functions.sbs,maths/vec3_rotate_by_quaternion,11,False,untested
|
||||
sbs://3d_functions.sbs,maths/vec3_rotation,16,True,untested
|
||||
sbs://3d_functions.sbs,maths/fibonacci_sphere,22,False,untested
|
||||
sbs://3d_functions.sbs,materials/set_id,5,False,untested
|
||||
sbs://3d_functions.sbs,materials/set_color,7,False,untested
|
||||
sbs://3d_functions.sbs,materials/set_roughness,5,False,untested
|
||||
sbs://3d_functions.sbs,materials/set_ior,5,True,untested
|
||||
sbs://3d_functions.sbs,materials/set_metalness,5,False,untested
|
||||
sbs://3d_functions.sbs,materials/set_default_material,23,True,untested
|
||||
sbs://3d_functions.sbs,materials/get_material,7,True,untested
|
||||
sbs://3d_functions.sbs,materials/set_material,7,False,untested
|
||||
sbs://3d_functions.sbs,materials/set_helper_color,5,True,untested
|
||||
sbs://3d_functions.sbs,materials/isoline_color,30,True,untested
|
||||
sbs://3d_functions.sbs,utilities/xyzab,19,True,untested
|
||||
sbs://3d_functions.sbs,utilities/compute_tangent,18,True,untested
|
||||
sbs://3d_functions.sbs,utilities/compute_position,5,True,untested
|
||||
sbs://3d_functions.sbs,utilities/sdf_compute_normal,38,True,untested
|
||||
sbs://3d_functions.sbs,utilities/wrap_PI,10,True,untested
|
||||
sbs://3d_functions.sbs,utilities/gate_arc,16,True,untested
|
||||
sbs://3d_functions.sbs,utilities/implicit_compute_normal,38,True,untested
|
||||
sbs://3d_functions.sbs,utilities/compute_tangent_frisvad,19,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_operators/intersect_union,110,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_operators/intersect_union_simple,18,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_operators/helper_union,32,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_operators/intersect_transform_quaternion,78,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_operators/intersect_transform_matrix,73,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_operators/is_closest,17,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_plane,78,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_plane_infinite,59,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_sphere,87,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_cube,111,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_cylinder,143,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_cylinder_z,165,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_cone,150,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_arrow,35,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_horizontal_grid,41,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_box_frame,150,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_box_frame_2,142,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_is_closest,11,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_axis_helper,40,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_patch,198,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_flat_arc,97,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_axis,33,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_plane_frame,93,True,untested
|
||||
sbs://3d_functions.sbs,3d_intersection_primitives/intersect_symmetry_helper,34,True,untested
|
||||
sbs://3d_functions.sbs,2d_sdf_primitives/2d_sdf_circle,11,True,untested
|
||||
sbs://3d_functions.sbs,2d_sdf_primitives/2d_sdf_segment,12,True,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_transform/3d_sdf_transform_elongate,39,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_transform/3d_sdf_transform_rotate,30,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_transform/3d_sdf_transform_repeat,22,True,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_transform/3d_sdf_transform_bend,33,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_transform/3d_sdf_transform_twist,46,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_transform/3d_sdf_transform_scale,26,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_transform/3d_sdf_transform_offset,15,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_transform/3d_sdf_transform_flip,33,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_transform/3d_sdf_transform_rotate_p,25,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_transform/3d_sdf_transform_offset_p,7,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_shell,7,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_rounding,8,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_morph,35,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_mobius_transform,48,True,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_subtraction_smooth,50,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_subtraction,31,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_intersection_surface,22,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_intersection,3,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_intersection_smooth,54,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_union_stairs,51,True,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_union_chamfer,28,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_union,30,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_union_smooth,50,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_symmetry,84,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/3d_sdf_op_repeat_mirror,59,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/sdf_repeat_mirror_range,32,True,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/sdf_infinite_grid_coord_q,18,True,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_operators/sdf_infinite_grid_coord_p,12,True,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_ground_plane,8,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_cube,46,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_sphere,16,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_capsule,43,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_cylinder,53,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_cylinder_2_points,45,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_ellipsoid,20,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_elongated_cylinder,28,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_hexagonal_prism,60,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_torus,27,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_infinite_plane,18,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_plane,62,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_pyramid,94,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_pyramid_square,79,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_cone,42,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_capped_cone,70,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_capped_cone_2_points,56,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_helix,51,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_capped_torus,43,False,untested
|
||||
sbs://3d_functions.sbs,3d_sdf_primitives/3d_sdf_rock,67,False,untested
|
||||
sbs://3d_perlin_noise.sbs,perlin_noise_modulo,44,True,untested
|
||||
sbs://3d_perlin_noise.sbs,perlin_noise_function,42,False,untested
|
||||
sbs://3d_perlin_noise.sbs,level_factor,20,True,untested
|
||||
sbs://3d_perlin_noise.sbs,perlin/rescale,9,True,untested
|
||||
sbs://3d_perlin_noise.sbs,perlin/trilinear_interp,24,True,untested
|
||||
sbs://3d_perlin_noise.sbs,perlin/linear_func,10,True,untested
|
||||
sbs://3d_perlin_noise.sbs,perlin/linear_func_modulo,14,True,untested
|
||||
sbs://3d_perlin_noise.sbs,perlin/corner_to_pos,3,True,untested
|
||||
sbs://3d_perlin_noise.sbs,perlin/vec3,5,True,untested
|
||||
sbs://3d_perlin_noise.sbs,perlin/poly_fade,11,True,untested
|
||||
sbs://3d_perlin_noise.sbs,perlin/grad,78,True,untested
|
||||
sbs://3d_perlin_noise.sbs,perlin/permutation3D,9,True,untested
|
||||
sbs://3d_perlin_noise.sbs,perlin/permutation1D,7,True,untested
|
||||
sbs://3d_simplex_noise.sbs,simplex_noise_function,104,False,untested
|
||||
sbs://3d_simplex_noise.sbs,simplex/mod289,8,True,untested
|
||||
sbs://3d_simplex_noise.sbs,simplex/permute,7,True,untested
|
||||
sbs://3d_simplex_noise.sbs,simplex/chaoticGradient,66,True,untested
|
||||
sbs://3d_simplex_noise.sbs,simplex/computeContribution,15,True,untested
|
||||
sbs://3d_texture_jump_flood.sbs,functions/3d_texture_jump_flood_distance,19,True,untested
|
||||
sbs://3d_texture_jump_flood.sbs,functions/3d_texture_jump_flood_check,11,True,untested
|
||||
sbs://3d_texture_jump_flood.sbs,functions/3d_texture_offset_uvw,36,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/3d_texture_ibl_irradiance_iteration,82,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/3d_texture_light_irradiance_iteration,93,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/3d_texture_light_shadow,91,False,untested
|
||||
sbs://3d_texture_render.sbs,functions/3d_texture_light_shadow_iteration,70,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/box_intersect,30,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/sphere_tracing_iteration,20,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/camera_dir_from_xy,32,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/camera_ray_direction_perspective,26,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/offset_uvw,31,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/sample_3d_texture_uv_256,17,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/position_out_of_bound_256,11,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/compute_irradiance,138,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/pos_3d,17,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/position_out_of_bound_mult,14,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/position_out_of_bound_bool,12,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/compute_normal_sample,10,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/beer_lambert,5,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/light_visibility,57,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/light_visibility_iteration,32,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/density_function,6,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/image_size_factor,12,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/ray_march_cube,20,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/cosine_weighted_samples,29,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/plane_intersect,44,True,untested
|
||||
sbs://3d_texture_render.sbs,functions/shape_merge_id,12,True,untested
|
||||
sbs://3d_viewer.sbs,3d_rotation,38,True,untested
|
||||
sbs://3d_viewer.sbs,cosine_weighted_random_direction,18,True,untested
|
||||
sbs://3d_viewer.sbs,polar_to_carthesian,17,True,untested
|
||||
sbs://3d_viewer.sbs,fermat_function,11,True,untested
|
||||
sbs://3d_viewer.sbs,camera_dir_from_xy,33,True,untested
|
||||
sbs://3d_viewer.sbs,R2,8,True,untested
|
||||
sbs://3d_viewer.sbs,R2_disc,10,True,untested
|
||||
sbs://3d_viewer.sbs,fibonacci2D,10,True,untested
|
||||
sbs://3d_viewer.sbs,increment,3,True,untested
|
||||
sbs://3d_viewer.sbs,image_size_factor,11,True,untested
|
||||
sbs://3d_viewer.sbs,image_size_factor2,13,True,untested
|
||||
sbs://3d_viewer.sbs,ray_direction,22,True,untested
|
||||
sbs://3d_viewer.sbs,camera_ray_direction_ortho,16,True,untested
|
||||
sbs://3d_viewer.sbs,random_unit_vector,18,True,untested
|
||||
sbs://3d_viewer.sbs,fresnel_schlick,37,True,untested
|
||||
sbs://3d_viewer.sbs,compute_tangent_x,13,True,untested
|
||||
sbs://3d_viewer.sbs,compute_tangent_y,19,True,untested
|
||||
sbs://3d_viewer.sbs,compute_tangent_z,12,True,untested
|
||||
sbs://3d_viewer.sbs,safe_inverse,7,True,untested
|
||||
sbs://3d_viewer.sbs,boolean_to_float4,4,True,untested
|
||||
sbs://3d_viewer.sbs,intersect_sphere_simple,36,True,untested
|
||||
sbs://3d_viewer.sbs,sphere_solid_angle,21,True,untested
|
||||
sbs://3d_viewer.sbs,refract,23,True,untested
|
||||
sbs://3d_viewer.sbs,uniform_disc_sampling,42,True,untested
|
||||
sbs://3d_viewer.sbs,thin_lens_ray_direction,24,True,untested
|
||||
sbs://3d_viewer.sbs,palette,12,True,untested
|
||||
sbs://3d_viewer.sbs,sdf/sdf_intersect,21,True,untested
|
||||
sbs://3d_viewer.sbs,lds/lds,47,True,untested
|
||||
sbs://3d_viewer.sbs,lds/XOR,7,True,untested
|
||||
sbs://3d_viewer.sbs,lds/XOR_float,101,True,untested
|
||||
sbs://3d_viewer.sbs,lds/AND_float,36,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/importance_sample_GGX,19,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/normal_distrib,18,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/probabilityGGX,11,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/compute_LOD,39,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/distortion,6,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/lod_uv,25,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/microfacets_contrib,14,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/cook_torrance_contrib,15,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/fresnel,12,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/fresnel_ASM,37,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/fresnel_float,12,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/vsibility,6,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/G1,12,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/3d_rotation,21,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/horizon_fading,9,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/generateAnisotropicRoughnessASM,10,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/sample_aniso_ggx_smith_vndf,64,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/eval_aniso_ggx,21,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/eval_aniso_smith_g2,6,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/eval_aniso_smith_g1,23,True,untested
|
||||
sbs://3d_viewer.sbs,ibl_specular_contrib_anisotropic/carthesian_to_polar_y_flipped,22,True,untested
|
||||
sbs://3d_viewer.sbs,importance_2D/importance_point_warping,69,True,untested
|
||||
sbs://3d_viewer.sbs,importance_2D/importance_point_warping_iteration,93,True,untested
|
||||
sbs://3d_viewer.sbs,importance_2D/sat_compute_rectangle_area,49,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/position_clamp,10,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/position3_clamp,10,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/3D_position_to_index,33,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/color_from_index,9,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/index_to_uvcoord,7,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/uvcoord_debug,23,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/block_size,4,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/3D_block_center_position,24,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/3D_block_corner_position,17,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/distance_vec3_A_B,52,True,untested
|
||||
sbs://3d_worley_noise.sbs,"functions/worldposition_to_local_[-1,1]",19,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/subblock_direction,21,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/modulo_vec3,10,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/modulo_vec2,7,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/min_float_float_float,5,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/C1,5,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/C2,8,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/3D_sample_random_position,12,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/3D_random_position_perblock,7,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/2D_position_to_index,61,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/2D_block_corner_position,12,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/distance_vec2_A_B,33,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/2D_random_position_perblock,7,True,untested
|
||||
sbs://3d_worley_noise.sbs,functions/2D_block_center_position,18,True,untested
|
||||
sbs://anisotropic_kuwahara.sbs,functions/gaussian,15,True,untested
|
||||
sbs://anisotropic_kuwahara.sbs,functions/mul_mat22_vec2,9,True,untested
|
||||
sbs://anisotropic_kuwahara.sbs,functions/mul_mat22_mat22,25,True,untested
|
||||
sbs://anisotropic_kuwahara.sbs,functions/wrap_uv,27,True,untested
|
||||
sbs://atlas_scatter.sbs,function/sample_neighboor,13,True,untested
|
||||
sbs://atlas_scatter.sbs,function/atlas_splatter_step_setget,275,True,untested
|
||||
sbs://atlas_spliter.sbs,pow2_safe,22,True,untested
|
||||
sbs://bevel_smooth.sbs,functions/scale_fn,19,False,untested
|
||||
sbs://bevel_smooth.sbs,functions/segment_distance,26,True,untested
|
||||
sbs://bevel_smooth.sbs,functions/pos_is_out_of_tile,21,True,untested
|
||||
sbs://bevel_smooth.sbs,functions/nullify_if_out_of_tile,5,True,untested
|
||||
sbs://bevel_smooth.sbs,functions/sample_at_pos_with_offset_grey,7,True,untested
|
||||
sbs://brick_generator.sbs,resources/Smallest_Brick,44,True,untested
|
||||
sbs://brick_generator.sbs,resources/EvenSize,22,True,untested
|
||||
sbs://brick_generator.sbs,resources/OddSize,11,True,untested
|
||||
sbs://cartesian_polar_transformation.sbs,cartesian_to_polar_function,16,True,untested
|
||||
sbs://cartesian_polar_transformation.sbs,polar_to_cartesian_function,17,True,untested
|
||||
sbs://clone_patch.sbs,out_of_bounds_float2,7,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_distance/color_distance_Lab_DeltaE2000,68,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_distance/color_distance_RGB,5,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_distance/color_distance_luminance,13,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_distance/angle_distance_XYZ,12,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_distance/helpers/dist_compute_C,6,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_distance/helpers/dist_compute_G,16,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_distance/helpers/dist_compute_h_,14,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_distance/helpers/dist_compute_H,13,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_distance/helpers/dist_compute_T,30,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_distance/helpers/dist_compute_DH,24,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_distance/helpers/dist_compute_SL_SC_SH,22,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_distance/helpers/dist_compute_RT,31,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_conversions/Rgb2LabConversionFct1,16,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_conversions/Rgb2LabConversionFct2,14,True,untested
|
||||
sbs://color_to_mask_v2.sbs,functions/color_conversions/convert_RGB_to_Lab_fct,48,True,untested
|
||||
sbs://crop.sbs,out_of_bounds,7,True,untested
|
||||
sbs://crop.sbs,rotate_2d,24,True,untested
|
||||
sbs://crop.sbs,inverse_transform_position,90,True,untested
|
||||
sbs://crop.sbs,transform_position,29,True,untested
|
||||
sbs://curvature_smooth_v2.sbs,intensity_function,19,True,untested
|
||||
sbs://diffusion.sbs,impl/manage_tiling,17,True,untested
|
||||
sbs://diffusion.sbs,impl/manage_tiling_nearest,14,True,untested
|
||||
sbs://diffusion.sbs,impl/average_4UV_components,56,True,untested
|
||||
sbs://diffusion.sbs,impl/sampling_law,19,True,untested
|
||||
sbs://flood_fill_2.sbs,flood_fill_impl/choose_best,16,True,untested
|
||||
sbs://floodfill_to_index.sbs,functions/reorder,20,True,untested
|
||||
sbs://floodfill_to_index.sbs,functions/scanline_sample,13,True,untested
|
||||
sbs://functions.sbs,Functions/Math/Ln,5,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Pi,1,False,untested
|
||||
sbs://functions.sbs,Functions/Math/2Pi,1,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Pow,11,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Roughness,24,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Equality_Float2,9,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Equality_Float3,9,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Equality_Boolean,7,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Equality_Float4,9,False,untested
|
||||
sbs://functions.sbs,Functions/Math/NotEqual_Float2,4,False,untested
|
||||
sbs://functions.sbs,Functions/Math/NotEqual_Float3,4,False,untested
|
||||
sbs://functions.sbs,Functions/Math/NotEqual_Float4,4,False,untested
|
||||
sbs://functions.sbs,Functions/Math/NotEqual_Boolean,4,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Curve_Function,29,False,untested
|
||||
sbs://functions.sbs,Functions/Math/merge_float4,7,False,untested
|
||||
sbs://functions.sbs,Functions/Math/merge_float3,5,False,untested
|
||||
sbs://functions.sbs,Functions/Math/distance_vec3,4,False,untested
|
||||
sbs://functions.sbs,Functions/Math/distance_vec2,4,False,untested
|
||||
sbs://functions.sbs,Functions/Math/length_vec2,3,False,untested
|
||||
sbs://functions.sbs,Functions/Math/length_vec3,3,False,untested
|
||||
sbs://functions.sbs,Functions/Math/sign,6,False,untested
|
||||
sbs://functions.sbs,Functions/Math/reflect,7,False,untested
|
||||
sbs://functions.sbs,Functions/Math/oneminus,3,False,untested
|
||||
sbs://functions.sbs,Functions/Math/fmod,11,False,untested
|
||||
sbs://functions.sbs,Functions/Math/frac,3,False,untested
|
||||
sbs://functions.sbs,Functions/Math/cross_product,9,False,untested
|
||||
sbs://functions.sbs,Functions/Math/cross_product_vec2,11,False,untested
|
||||
sbs://functions.sbs,Functions/Math/step,6,False,untested
|
||||
sbs://functions.sbs,Functions/Math/divide_float4,13,False,untested
|
||||
sbs://functions.sbs,Functions/Math/divide_float3,10,False,untested
|
||||
sbs://functions.sbs,Functions/Math/divide_float2,7,False,untested
|
||||
sbs://functions.sbs,Functions/Math/clamp,5,False,untested
|
||||
sbs://functions.sbs,Functions/Math/normalize_vec2,6,False,untested
|
||||
sbs://functions.sbs,Functions/Math/normalize_vec3,6,False,untested
|
||||
sbs://functions.sbs,Functions/Math/normalize_vec4,6,False,untested
|
||||
sbs://functions.sbs,Functions/Math/smoothstep,13,False,untested
|
||||
sbs://functions.sbs,Functions/Math/saturate_float2,6,False,untested
|
||||
sbs://functions.sbs,Functions/Math/average_float1,5,False,untested
|
||||
sbs://functions.sbs,Functions/Math/average_float2,5,False,untested
|
||||
sbs://functions.sbs,Functions/Math/average_float3,5,False,untested
|
||||
sbs://functions.sbs,Functions/Math/average_float4,5,False,untested
|
||||
sbs://functions.sbs,Functions/Math/orthogonal_vec2,4,False,untested
|
||||
sbs://functions.sbs,Functions/Math/saturate,5,False,untested
|
||||
sbs://functions.sbs,Functions/Math/truncate_float1_decimals,11,False,untested
|
||||
sbs://functions.sbs,Functions/Math/round_float1,4,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Trigo/deg_to_rad,5,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Trigo/asin,22,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Trigo/acos,6,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Parity/EvenCount,5,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Parity/OddCount,5,False,untested
|
||||
sbs://functions.sbs,Functions/Math/Parity/ParityTest,10,False,untested
|
||||
sbs://functions.sbs,"Functions/Random/Uniform_[A,B[",5,False,untested
|
||||
sbs://functions.sbs,"Functions/Random/Discrete_[A,B]",7,False,untested
|
||||
sbs://functions.sbs,"Functions/Random/Uniform_[-1,1[",4,False,untested
|
||||
sbs://functions.sbs,"Functions/Random/Uniform_F2_[A,B[",9,False,untested
|
||||
sbs://functions.sbs,"Functions/Random/Uniform_F3_[A,B[",12,False,untested
|
||||
sbs://functions.sbs,"Functions/Random/Uniform_F4_[A,B[",15,False,untested
|
||||
sbs://functions.sbs,Functions/Random/Degrees_to_Turn,3,False,untested
|
||||
sbs://functions.sbs,Functions/Random/GlobalRandom,136,False,untested
|
||||
sbs://functions.sbs,Functions/Random/normal_distribution,16,False,untested
|
||||
sbs://functions.sbs,Functions/Transforms/Directional_Offset,9,False,untested
|
||||
sbs://functions.sbs,Functions/Transforms/MatrixMultiply,25,False,untested
|
||||
sbs://functions.sbs,Functions/Transforms/RotationMatrix,10,False,untested
|
||||
sbs://functions.sbs,Functions/Transforms/ScaleMatrix,10,False,untested
|
||||
sbs://functions.sbs,Functions/Transforms/TileMatrix,7,False,untested
|
||||
sbs://functions.sbs,Functions/Transforms/rotate_vec2,17,False,untested
|
||||
sbs://functions.sbs,Functions/Transforms/rotate_vec2_rad,10,False,untested
|
||||
sbs://functions.sbs,Functions/Transforms/matrix_invert,13,False,untested
|
||||
sbs://functions.sbs,Functions/Transforms/polar_to_carthesian,18,False,untested
|
||||
sbs://functions.sbs,Functions/Transforms/carthesian_to_polar,20,False,untested
|
||||
sbs://functions.sbs,Functions/Cycles/Wave,9,False,untested
|
||||
sbs://functions.sbs,Functions/Ranges/[-1_1]_to_[0_1],5,False,untested
|
||||
sbs://functions.sbs,Functions/Ranges/[0_1]_to_[-1_1],5,False,untested
|
||||
sbs://functions.sbs,Functions/Ranges/[0_1]_to_[1_0],5,False,untested
|
||||
sbs://functions.sbs,Functions/Ranges/negateFloat,3,False,untested
|
||||
sbs://functions.sbs,Functions/Ranges/Height_Balance_Fn,16,False,untested
|
||||
sbs://functions.sbs,"Functions/Ranges/[0,1]_to_[0,1,0]",7,False,untested
|
||||
sbs://functions.sbs,"Functions/Ranges/[a,b]_to_[0,1]",9,False,untested
|
||||
sbs://functions.sbs,Functions/Ranges/triangle_wave,7,False,untested
|
||||
sbs://functions.sbs,Functions/Ranges/sawtooth_wave,11,False,untested
|
||||
sbs://functions.sbs,Functions/typeConverters/booleanToFloat1,4,False,untested
|
||||
sbs://functions.sbs,Functions/typeConverters/turnsToDegrees,3,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/directionToNormal,25,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGBtoHSL,47,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/HSLtoRGB,43,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/Random_Color,29,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/Random_Luminosity,16,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGBtoHSV,6,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGBtoHSI,6,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGBtoHCL,6,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGB_lightness_average,8,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGB_lightness_hexcone,6,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGB_lightness_bihexcone,11,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGB_lightness_luma_rec601,12,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGB_lightness_luma_rec709,12,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGB_chroma_hexagonal,9,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGB_chroma_2_polar,20,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGB_hue_hexagonal,36,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGB_hue_2_polar,28,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGB_saturation_HSV,8,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGB_saturation_HSL,15,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/RGB_saturation_HSI,14,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/HSItoRGB,71,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/HSVtoRGB,64,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/HCLtoRGB,64,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/linear_to_sRGB_luminance,14,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/linear_to_sRGB_rgb,9,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/sRGB_to_linear_rgb,9,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/sRGB_to_linear_luminance,14,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/temperature_to_rgb,22,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/temperature_to_rgb_fit,11,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/acescg_to_linear_srgb,8,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/linear_srgb_to_acescg,8,False,untested
|
||||
sbs://functions.sbs,Functions/colorValues/hsl_offset,16,False,untested
|
||||
sbs://functions.sbs,Functions/Various/disorder,12,False,untested
|
||||
sbs://functions.sbs,Functions/Various/disorder_v2,10,False,untested
|
||||
sbs://functions.sbs,Functions/Various/disorder_anim,15,False,untested
|
||||
sbs://functions.sbs,Functions/Various/non_square_output_size,70,False,untested
|
||||
sbs://functions.sbs,Functions/Various/non_square_output_size_v2,99,False,untested
|
||||
sbs://functions.sbs,Functions/Various/non_square_expansion_uv_scale,21,False,untested
|
||||
sbs://functions.sbs,Functions/Various/compute_total_number,33,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Float1/switch_float1_2_inputs,6,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Float1/switch_float1_4_inputs,11,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Float1/switch_float1_8_inputs,15,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Float2/switch_float2_2_inputs,6,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Float2/switch_float2_4_inputs,11,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Float2/switch_float2_8_inputs,15,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Float3/switch_float3_2_inputs,6,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Float3/switch_float3_4_inputs,11,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Float3/switch_float3_8_inputs,15,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Float4/switch_float4_2_inputs,6,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Float4/switch_float4_4_inputs,11,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Float4/switch_float4_8_inputs,15,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Integer1/switch_integer1_2_inputs,6,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Integer1/switch_integer1_4_inputs,11,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Integer1/switch_integer1_8_inputs,15,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Integer2/switch_integer2_2_inputs,6,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Integer2/switch_integer2_4_inputs,11,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Integer2/switch_integer2_8_inputs,15,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Integer3/switch_integer3_2_inputs,6,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Integer3/switch_integer3_4_inputs,11,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Integer3/switch_integer3_8_inputs,15,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Integer4/switch_integer4_2_inputs,6,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Integer4/switch_integer4_4_inputs,11,False,untested
|
||||
sbs://functions.sbs,Functions/switch/Integer4/switch_integer4_8_inputs,15,False,untested
|
||||
sbs://functions.sbs,Functions/easings/sine/ease_in_sine,7,False,untested
|
||||
sbs://functions.sbs,Functions/easings/sine/ease_out_sine,6,False,untested
|
||||
sbs://functions.sbs,Functions/easings/sine/ease_in_out_sine,9,False,untested
|
||||
sbs://functions.sbs,Functions/easings/quad/ease_in_quad,2,False,untested
|
||||
sbs://functions.sbs,Functions/easings/quad/ease_out_quad,4,False,untested
|
||||
sbs://functions.sbs,Functions/easings/quad/ease_in_out_quad,13,False,untested
|
||||
sbs://functions.sbs,Functions/easings/cubic/ease_in_cubic,3,False,untested
|
||||
sbs://functions.sbs,Functions/easings/cubic/ease_out_cubic,5,False,untested
|
||||
sbs://functions.sbs,Functions/easings/cubic/ease_in_out_cubic,17,False,untested
|
||||
sbs://functions.sbs,Functions/easings/quart/ease_in_quart,4,False,untested
|
||||
sbs://functions.sbs,Functions/easings/quart/ease_out_quart,6,False,untested
|
||||
sbs://functions.sbs,Functions/easings/quart/ease_in_out_quart,19,False,untested
|
||||
sbs://functions.sbs,Functions/easings/quint/ease_in_quint,5,False,untested
|
||||
sbs://functions.sbs,Functions/easings/quint/ease_out_quint,7,False,untested
|
||||
sbs://functions.sbs,Functions/easings/quint/ease_in_out_quint,21,False,untested
|
||||
sbs://functions.sbs,Functions/easings/expo/ease_in_expo,8,False,untested
|
||||
sbs://functions.sbs,Functions/easings/expo/ease_out_expo,8,False,untested
|
||||
sbs://functions.sbs,Functions/easings/expo/ease_in_out_expo,25,False,untested
|
||||
sbs://functions.sbs,Functions/easings/circ/ease_in_circ,5,False,untested
|
||||
sbs://functions.sbs,Functions/easings/circ/ease_out_circ,6,False,untested
|
||||
sbs://functions.sbs,Functions/easings/circ/ease_in_out_circ,22,False,untested
|
||||
sbs://functions.sbs,Functions/Tonemappers/tonemap_Hejl,35,False,untested
|
||||
sbs://functions.sbs,Functions/Tonemappers/tonemap_ACES,29,False,untested
|
||||
sbs://functions.sbs,Functions/Tonemappers/tonemap_AgX,44,False,untested
|
||||
sbs://functions.sbs,Functions/Tonemappers/tonemap_AgX_look,14,False,untested
|
||||
sbs://functions.sbs,Functions/Tonemappers/tonemap_AgX_approx,25,False,untested
|
||||
sbs://functions_hash.sbs,hash11,12,False,untested
|
||||
sbs://functions_hash.sbs,hash14,19,False,untested
|
||||
sbs://functions_hash.sbs,hash21,19,False,untested
|
||||
sbs://functions_hash.sbs,hash22,20,False,untested
|
||||
sbs://functions_hash.sbs,hash32,19,False,untested
|
||||
sbs://functions_hash.sbs,hash24,20,False,untested
|
||||
sbs://functions_hash.sbs,hash31,18,False,untested
|
||||
sbs://fxaa.sbs,pixel_offset,5,True,untested
|
||||
sbs://fxaa.sbs,fxaa_iteration,57,True,untested
|
||||
sbs://hbao.sbs,hbao_cone_sample,131,True,untested
|
||||
sbs://hbao.sbs,hbao_radius_function,17,True,untested
|
||||
sbs://hbao_2.sbs,hbao_cone_sample,169,True,untested
|
||||
sbs://hbao_2.sbs,hbao_radius_function,15,True,untested
|
||||
sbs://hdr_merge.sbs,weight_2,21,True,untested
|
||||
sbs://hdr_merge.sbs,weight,19,True,untested
|
||||
sbs://hdr_merge.sbs,exposure_multiplier,11,True,untested
|
||||
sbs://hdr_merge.sbs,srgb_to_linear_float4,12,True,untested
|
||||
sbs://hdr_merge.sbs,gaussian,16,True,untested
|
||||
sbs://hdr_merge.sbs,weight_hcl,25,True,untested
|
||||
sbs://hdr_merge.sbs,color_space_conversion,20,True,untested
|
||||
sbs://hdr_merge.sbs,mult_hcl,8,True,untested
|
||||
sbs://height_extrude.sbs,impl/dichotomic_search_by_column_impl,24,True,untested
|
||||
sbs://height_extrude.sbs,impl/project_pos,9,True,untested
|
||||
sbs://median_filter.sbs,median_functions/median_9,39,False,untested
|
||||
sbs://median_filter.sbs,median_functions/median_25,203,False,untested
|
||||
sbs://median_filter.sbs,median_functions/geometric_median_9,141,False,untested
|
||||
sbs://median_filter.sbs,median_functions/geometric_median_25,997,False,untested
|
||||
sbs://noise_anisotropic_noise_v2.sbs,functions/smoothness,17,True,untested
|
||||
sbs://noise_anisotropic_noise_v2.sbs,functions/disorder,21,True,untested
|
||||
sbs://noise_fractal_sum_base_v2.sbs,inverse_error_function,33,True,untested
|
||||
sbs://noise_fractal_sum_base_v2.sbs,roughness,22,True,untested
|
||||
sbs://noise_voronoi.sbs,functions/voronoi_3d_function,159,False,untested
|
||||
sbs://noise_voronoi.sbs,functions/voronoi_3d_function_iteration,60,True,untested
|
||||
sbs://noise_voronoi.sbs,functions/hash_33,18,True,untested
|
||||
sbs://noise_voronoi.sbs,functions/distance_vec3_A_B,35,True,untested
|
||||
sbs://noise_voronoi.sbs,functions/level_factor,29,True,untested
|
||||
sbs://non_uniform_blur.sbs,ellipse,41,True,untested
|
||||
sbs://non_uniform_blur.sbs,samples,9,True,untested
|
||||
sbs://non_uniform_directional_warp.sbs,functions/sample_color,39,True,untested
|
||||
sbs://non_uniform_directional_warp.sbs,functions/sample_grayscale,40,True,untested
|
||||
sbs://normal_to_height_hq.sbs,base_algorithm_size_weight,14,True,untested
|
||||
sbs://normal_uncombine.sbs,functions/normal_sample,47,True,untested
|
||||
sbs://normal_uncombine.sbs,functions/normal_normalize,10,True,untested
|
||||
sbs://normal_uncombine.sbs,functions/C1,8,True,untested
|
||||
sbs://normal_uncombine.sbs,functions/C2,15,True,untested
|
||||
sbs://panorama_nadir_patch.sbs,smooth_square,38,True,untested
|
||||
sbs://panorama_nadir_patch.sbs,gaussian,30,True,untested
|
||||
sbs://panorama_physical_sun_sky.sbs,Impl/EvalParam,17,True,untested
|
||||
sbs://panorama_physical_sun_sky.sbs,Impl/SampleBezierCoef,17,True,untested
|
||||
sbs://panorama_physical_sun_sky.sbs,Impl/EvalBezier,17,True,untested
|
||||
sbs://panorama_physical_sun_sky.sbs,Impl/EvalSunWl,40,True,untested
|
||||
sbs://panorama_shape.sbs,EulerAnglesToVector,15,True,untested
|
||||
sbs://panorama_shape.sbs,polar_to_carthesian,18,True,untested
|
||||
sbs://panorama_shape.sbs,carthesian_to_polar,20,True,untested
|
||||
sbs://panorama_shape.sbs,3d_rotation,21,True,untested
|
||||
sbs://panorama_shape.sbs,vec3_rotation,16,True,untested
|
||||
sbs://panorama_shape.sbs,smooth_square,25,True,untested
|
||||
sbs://panorama_shape.sbs,sphere_intersect,43,True,untested
|
||||
sbs://panorama_shape.sbs,sphere_position_to_uv,16,True,untested
|
||||
sbs://panorama_straighten_horizon.sbs,PolarToCarthesian,17,True,untested
|
||||
sbs://paths_tools.sbs,Utils/next_pixel_pos,15,True,untested
|
||||
sbs://paths_tools.sbs,Utils/next_pixel_pos_n,14,True,untested
|
||||
sbs://paths_tools.sbs,Utils/sample_at_pos_with_offset_grey,7,True,untested
|
||||
sbs://paths_tools.sbs,Utils/sample_at_pos_with_offset_color,9,True,untested
|
||||
sbs://paths_tools.sbs,Utils/nullify_if_out_of_tile,5,True,untested
|
||||
sbs://paths_tools.sbs,Utils/pos_is_out_of_tile,21,True,untested
|
||||
sbs://paths_tools.sbs,Utils/position_to_pixel_index,11,True,untested
|
||||
sbs://paths_tools.sbs,Utils/pixel_index_to_position,12,True,untested
|
||||
sbs://paths_tools.sbs,Utils/isSamePixel,14,True,untested
|
||||
sbs://paths_tools.sbs,Utils/count_to_size,8,False,untested
|
||||
sbs://paths_tools.sbs,Utils/lexicographic_greater_than_vec2,11,False,untested
|
||||
sbs://paths_tools.sbs,Write/document_header,9,True,untested
|
||||
sbs://paths_tools.sbs,Write/path_header,12,True,untested
|
||||
sbs://paths_tools.sbs,Write/document_last_vertex_spec,3,True,untested
|
||||
sbs://paths_tools.sbs,Write/mid_vertex,14,True,untested
|
||||
sbs://paths_tools.sbs,Write/start_vertex,10,True,untested
|
||||
sbs://paths_tools.sbs,Write/end_vertex,10,True,untested
|
||||
sbs://paths_tools.sbs,Read/is_mid_vertex,5,True,untested
|
||||
sbs://paths_tools.sbs,Read/is_end_vertex,5,True,untested
|
||||
sbs://paths_tools.sbs,Read/is_segment_start,5,True,untested
|
||||
sbs://paths_tools.sbs,Read/has_trivial_links,5,True,untested
|
||||
sbs://paths_tools.sbs,Read/is_start_vertex,5,True,untested
|
||||
sbs://paths_tools.sbs,Read/is_vertex,5,True,untested
|
||||
sbs://paths_tools.sbs,Read/is_corner,4,True,untested
|
||||
sbs://paths_tools.sbs,Read/is_header,4,True,untested
|
||||
sbs://paths_tools.sbs,Read/sample_next,20,True,untested
|
||||
sbs://paths_tools.sbs,Read/sample_prev,20,True,untested
|
||||
sbs://paths_tools.sbs,Read/path_is_closed,4,True,untested
|
||||
sbs://paths_tools.sbs,Read/current_pixel_is_document_header,17,True,untested
|
||||
sbs://paths_tools.sbs,Read/sample_next_advanced,19,True,untested
|
||||
sbs://paths_tools.sbs,Read/sample_prev_advanced,19,True,untested
|
||||
sbs://pattern_brick_generator.sbs,resources/Smallest_Brick,11,True,untested
|
||||
sbs://pattern_brick_generator.sbs,resources/EvenSize,22,True,untested
|
||||
sbs://pattern_brick_generator.sbs,resources/OddSize,11,True,untested
|
||||
sbs://pattern_cube_3d.sbs,safe_max,12,True,untested
|
||||
sbs://pattern_scratches_generator.sbs,rotate_position,15,True,untested
|
||||
sbs://pattern_tile_random.sbs,tile_random_current_position,22,True,untested
|
||||
sbs://pattern_tile_random.sbs,tile_random_grayscale_function,113,True,untested
|
||||
sbs://pattern_tile_random.sbs,tile_random_color_function,108,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/get_point_coords,19,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/random_tile_split,60,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/hash22,20,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/generate_point_position,24,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/compute_distance_to_line,12,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/compute_distance_to_segment,40,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/compute_distance_to_polygon,22,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/checker_function,8,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/flip_vec2,4,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/hash24,20,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/line_line_intersection,48,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/draw_point,8,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/find_cell_function,25,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/find_cell_intersection,22,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/local_pos_to_uv,11,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/segment_segment_intersection,17,False,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/compute_half_vector,8,True,untested
|
||||
sbs://pattern_tile_random_2.sbs,functions/rescale_segment,8,True,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/distance_line,12,True,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/triangulate,351,True,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/flip_distance,13,True,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/signed_distance_line,10,True,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/line_aa,148,True,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/inside_quad_1,113,True,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/inside_tri,48,True,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/barycentric_coordinates,51,True,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/hash22,20,True,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/hash24,20,True,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/hash41,19,True,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/hash11,12,True,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/tiling_fn,18,False,untested
|
||||
sbs://pattern_triangle_grid.sbs,functions/clamp_float2,5,False,untested
|
||||
sbs://pbr_render.sbs,common_functions/normal_tangent_to_world,21,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/normal_unpack,5,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/camera_dir_from_2d_pos,32,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/camera_dir_from_xy,32,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/camera_ray_direction_perspective,26,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/camera_ray_direction_ortho,28,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/tiling_clamp_to_edge,6,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/carthesian_to_polar,21,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/carthesian_to_polar_y_flipped,22,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/polar_to_carthesian,18,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/sample_mip_panoramic,49,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/refract,22,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/3d_rotation,21,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/vec3_rotation,16,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/rotation_matrix,95,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/rotate_vec3_matrix,8,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/image_size_factor,12,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/matrix_3x3_multiply,23,True,untested
|
||||
sbs://pbr_render.sbs,common_functions/irradiance_env_sample_pos,26,True,untested
|
||||
sbs://pbr_render.sbs,cylinder_function/cylinder_intersect,123,True,untested
|
||||
sbs://pbr_render.sbs,cylinder_function/cylinder_intersect_base,34,True,untested
|
||||
sbs://pbr_render.sbs,cylinder_function/cylinder_uvs_from_pos,21,True,untested
|
||||
sbs://pbr_render.sbs,cylinder_function/cylinder_ray_pos_linear_search,30,True,untested
|
||||
sbs://pbr_render.sbs,cylinder_function/cylinder_ray_pos_binary_search,30,True,untested
|
||||
sbs://pbr_render.sbs,cylinder_function/cylinder_raytraced_irradiance,157,True,untested
|
||||
sbs://pbr_render.sbs,cylinder_function/cylinder_ray_shadow,31,True,untested
|
||||
sbs://pbr_render.sbs,cylinder_function/cylinder_raytraced_specular,177,True,untested
|
||||
sbs://pbr_render.sbs,plane_functions/box_intersect,153,True,untested
|
||||
sbs://pbr_render.sbs,plane_functions/box_intersect3,137,True,untested
|
||||
sbs://pbr_render.sbs,plane_functions/plane_ray_shadow,36,True,untested
|
||||
sbs://pbr_render.sbs,plane_functions/plane_raytraced_specular,170,True,untested
|
||||
sbs://pbr_render.sbs,plane_functions/plane_intersect,36,True,untested
|
||||
sbs://pbr_render.sbs,plane_functions/plane_ray_pos_linear_search,32,True,untested
|
||||
sbs://pbr_render.sbs,plane_functions/plane_ray_pos_binary_search,31,True,untested
|
||||
sbs://pbr_render.sbs,plane_functions/plane_uvs_from_pos,12,True,untested
|
||||
sbs://pbr_render.sbs,plane_functions/plane_raytraced_irradiance,199,True,untested
|
||||
sbs://pbr_render.sbs,plane_functions/plane_ray_shadow_2,35,True,untested
|
||||
sbs://pbr_render.sbs,sphere_functions/sphere_intersect,44,True,untested
|
||||
sbs://pbr_render.sbs,sphere_functions/sphere_ray_pos_binary_search,28,True,untested
|
||||
sbs://pbr_render.sbs,sphere_functions/sphere_ray_pos_linear_search,29,True,untested
|
||||
sbs://pbr_render.sbs,sphere_functions/sphere_raytraced_irradiance,157,True,untested
|
||||
sbs://pbr_render.sbs,sphere_functions/sphere_ray_shadow,29,True,untested
|
||||
sbs://pbr_render.sbs,sphere_functions/sphere_raytraced_specular,169,True,untested
|
||||
sbs://pbr_render.sbs,sphere_functions/sphere_uvs_from_position,25,True,untested
|
||||
sbs://pbr_render.sbs,sphere_functions/sphere_uv_transform,25,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/IBLSpecularContribution,56,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/IBLSpecularContribution_iteration,62,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/fibonacci2D,12,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/importance_sample_GGX,18,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/normal_distrib,16,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/probabilityGGX,9,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/compute_LOD,20,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/distortion,6,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/samplePanoramicLOD,21,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/lod_uv,25,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/microfacets_contrib,14,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/fresnel,12,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/fresnel_float,12,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/vsibility,6,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/G1,12,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/3d_rotation,21,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/vec3_multiply_mat3,8,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/mat3_multiply_vector,32,True,untested
|
||||
sbs://pbr_render.sbs,ibl_specular_contrib_anisotropic/horizon_fading,9,True,untested
|
||||
sbs://pbr_render.sbs,post_effects_functions/lensflare_ghost,57,True,untested
|
||||
sbs://pbr_render.sbs,post_effects_functions/tonemap_ACES,29,True,untested
|
||||
sbs://pbr_render.sbs,post_effects_functions/dof_convolution_iteration,63,True,untested
|
||||
sbs://pbr_render.sbs,post_effects_functions/dof_convo_fermat_iteration,59,True,untested
|
||||
sbs://pbr_render.sbs,post_effects_functions/fermat_function,11,True,untested
|
||||
sbs://pbr_render.sbs,post_effects_functions/tonemap_Hejl,35,True,untested
|
||||
sbs://pbr_render.sbs,get_max_coords/max_function,49,True,untested
|
||||
sbs://pbr_render2.sbs,lod_uv,28,True,untested
|
||||
sbs://pbr_render2.sbs,compute_emissive_lod,29,True,untested
|
||||
sbs://pbr_render2.sbs,subsurface_scattering/alg_sssConvolve,66,True,untested
|
||||
sbs://pbr_render2.sbs,subsurface_scattering/alg_convertSSSCoefficients,55,True,untested
|
||||
sbs://pbr_render2.sbs,subsurface_scattering/alg_samples_icdf,8,True,untested
|
||||
sbs://pbr_render2.sbs,subsurface_scattering/alg_sss_pdf,20,True,untested
|
||||
sbs://pbr_render2.sbs,subsurface_scattering/alg_samples_pdf,17,True,untested
|
||||
sbs://pbr_render2.sbs,subsurface_scattering/sssConvolve_sample,15,False,untested
|
||||
sbs://pbr_render2.sbs,subsurface_scattering/sssConvolve_sample_R,15,False,untested
|
||||
sbs://pbr_render2.sbs,subsurface_scattering/sssConvolve_sample_G,15,False,untested
|
||||
sbs://pbr_render2.sbs,subsurface_scattering/sssConvolve_sample_B,15,False,untested
|
||||
sbs://pbr_render2.sbs,importance_2D/importance_point_warping,69,True,untested
|
||||
sbs://pbr_render2.sbs,importance_2D/importance_point_warping_iteration,88,True,untested
|
||||
sbs://pbr_render2.sbs,sat/sat_compute_rectangle_area,49,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/normal_tangent_to_world,21,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/normal_unpack,5,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/camera_dir_from_2d_pos,32,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/camera_dir_from_xy,32,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/camera_ray_direction_perspective,27,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/camera_ray_direction_ortho,28,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/tiling_clamp_to_edge,6,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/carthesian_to_polar,21,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/carthesian_to_polar_y_flipped,22,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/polar_to_carthesian,18,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/sample_mip_panoramic,49,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/refract,22,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/3d_rotation,21,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/vec3_rotation,16,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/rotation_matrix,95,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/rotate_vec3_matrix,8,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/image_size_factor,12,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/matrix_3x3_multiply,23,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/irradiance_env_sample_pos,26,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/cosine_weighted_random_direction,13,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/compute_tangent,10,True,untested
|
||||
sbs://pbr_render2.sbs,common_functions/fibonacci2D,10,True,untested
|
||||
sbs://pbr_render2.sbs,cylinder_function/cylinder_intersect,123,True,untested
|
||||
sbs://pbr_render2.sbs,cylinder_function/cylinder_intersect_base,34,True,untested
|
||||
sbs://pbr_render2.sbs,cylinder_function/cylinder_uvs_from_pos,21,True,untested
|
||||
sbs://pbr_render2.sbs,cylinder_function/cylinder_ray_pos_linear_search,30,True,untested
|
||||
sbs://pbr_render2.sbs,cylinder_function/cylinder_ray_pos_binary_search,30,True,untested
|
||||
sbs://pbr_render2.sbs,cylinder_function/cylinder_raytraced_irradiance,164,True,untested
|
||||
sbs://pbr_render2.sbs,cylinder_function/cylinder_ray_shadow,31,True,untested
|
||||
sbs://pbr_render2.sbs,cylinder_function/cylinder_raytraced_specular,178,True,untested
|
||||
sbs://pbr_render2.sbs,plane_functions/box_intersect,153,True,untested
|
||||
sbs://pbr_render2.sbs,plane_functions/box_intersect3,137,True,untested
|
||||
sbs://pbr_render2.sbs,plane_functions/plane_ray_shadow,36,True,untested
|
||||
sbs://pbr_render2.sbs,plane_functions/plane_raytraced_specular,173,True,untested
|
||||
sbs://pbr_render2.sbs,plane_functions/plane_intersect,36,True,untested
|
||||
sbs://pbr_render2.sbs,plane_functions/plane_ray_pos_linear_search,32,True,untested
|
||||
sbs://pbr_render2.sbs,plane_functions/plane_ray_pos_binary_search,31,True,untested
|
||||
sbs://pbr_render2.sbs,plane_functions/plane_uvs_from_pos,12,True,untested
|
||||
sbs://pbr_render2.sbs,plane_functions/plane_raytraced_irradiance,200,True,untested
|
||||
sbs://pbr_render2.sbs,plane_functions/plane_ray_shadow_2,35,True,untested
|
||||
sbs://pbr_render2.sbs,sphere_functions/sphere_intersect,44,True,untested
|
||||
sbs://pbr_render2.sbs,sphere_functions/sphere_ray_pos_binary_search,31,True,untested
|
||||
sbs://pbr_render2.sbs,sphere_functions/sphere_ray_pos_linear_search,32,True,untested
|
||||
sbs://pbr_render2.sbs,sphere_functions/sphere_raytraced_irradiance,171,True,untested
|
||||
sbs://pbr_render2.sbs,sphere_functions/sphere_ray_shadow,32,True,untested
|
||||
sbs://pbr_render2.sbs,sphere_functions/sphere_raytraced_specular,174,True,untested
|
||||
sbs://pbr_render2.sbs,sphere_functions/sphere_uvs_from_position,25,True,untested
|
||||
sbs://pbr_render2.sbs,sphere_functions/sphere_cubic_uvs_from_position,79,True,untested
|
||||
sbs://pbr_render2.sbs,sphere_functions/sphere_cubic_tangents_from_position,80,True,untested
|
||||
sbs://pbr_render2.sbs,sphere_functions/sphere_cubic_bitangents_from_position,34,True,untested
|
||||
sbs://pbr_render2.sbs,sphere_functions/sphere_cubic_normal_from_position,32,True,untested
|
||||
sbs://pbr_render2.sbs,sphere_functions/sphere_cubic_normal_from_position_1,29,True,untested
|
||||
sbs://pbr_render2.sbs,sphere_functions/sphere_uv_transform,25,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/IBLSpecularContribution,56,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/IBLSpecularContribution_iteration,64,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/importance_sample_GGX,19,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/normal_distrib,16,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/probabilityGGX,9,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/compute_LOD,19,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/distortion,6,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/samplePanoramicLOD,21,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/lod_uv,25,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/microfacets_contrib,14,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/cook_torrance_contrib,15,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/fresnel,12,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/fresnel_ASM,37,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/fresnel_float,12,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/vsibility,6,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/G1,12,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/3d_rotation,21,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/vec3_multiply_mat3,8,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/mat3_multiply_vector,32,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/horizon_fading,9,True,untested
|
||||
sbs://pbr_render2.sbs,ibl_specular_contrib_anisotropic/generateAnisotropicRoughnessASM,10,True,untested
|
||||
sbs://pbr_render2.sbs,post_effects_functions/lensflare_ghost,57,True,untested
|
||||
sbs://pbr_render2.sbs,post_effects_functions/tonemap_ACES,29,True,untested
|
||||
sbs://pbr_render2.sbs,post_effects_functions/dof_convolution_iteration,63,True,untested
|
||||
sbs://pbr_render2.sbs,post_effects_functions/dof_convo_fermat_iteration,59,True,untested
|
||||
sbs://pbr_render2.sbs,post_effects_functions/fermat_function,11,True,untested
|
||||
sbs://pbr_render2.sbs,post_effects_functions/tonemap_Hejl,35,True,untested
|
||||
sbs://pbr_render2.sbs,get_max_coords/max_function,49,True,untested
|
||||
sbs://pbr_render_ortho.sbs,sphere_displace_function_2,113,True,untested
|
||||
sbs://pbr_render_ortho.sbs,sphere_displace_uv_to_normal,18,True,untested
|
||||
sbs://pbr_render_ortho.sbs,sphere_displace_function,115,True,untested
|
||||
sbs://pbr_render_ortho.sbs,ibl_shadow_sample_panoramic,34,True,untested
|
||||
sbs://pbr_render_ortho.sbs,ibl_shadow_pass_pixelsize,7,True,untested
|
||||
sbs://pbr_render_ortho.sbs,ibl_shadow_pass_bypass,8,True,untested
|
||||
sbs://pbr_render_ortho.sbs,ibl_shadow_mix,20,True,untested
|
||||
sbs://pbr_render_ortho.sbs,ibl_irradiance_sample,21,True,untested
|
||||
sbs://pbr_render_ortho.sbs,ibl_sample_panoramic,33,True,untested
|
||||
sbs://pbr_render_ortho.sbs,reflect_vec3,7,True,untested
|
||||
sbs://pbr_render_ortho.sbs,fresnel,12,True,untested
|
||||
sbs://pbr_render_ortho.sbs,normal_distrib,16,True,untested
|
||||
sbs://pbr_render_ortho.sbs,G1,8,True,untested
|
||||
sbs://pbr_render_ortho.sbs,visibility,9,True,untested
|
||||
sbs://pbr_render_ortho.sbs,microfacet_brdf,31,True,untested
|
||||
sbs://pbr_render_ortho.sbs,microfacets_contrib,14,True,untested
|
||||
sbs://pbr_render_ortho.sbs,importanceSampleGGX,36,True,untested
|
||||
sbs://pbr_render_ortho.sbs,compute_sampling_frame_Tp,6,True,untested
|
||||
sbs://pbr_render_ortho.sbs,compute_sampling_frame_Bp,10,True,untested
|
||||
sbs://pbr_render_ortho.sbs,fibonacci2D,12,True,untested
|
||||
sbs://pbr_render_ortho.sbs,index_to_uvcoord,11,True,untested
|
||||
sbs://pbr_render_ortho.sbs,rotate_env,19,True,untested
|
||||
sbs://pbr_render_ortho.sbs,samplePanoramic,62,True,untested
|
||||
sbs://pbr_render_ortho.sbs,compute_LOD,19,True,untested
|
||||
sbs://pbr_render_ortho.sbs,distortion,6,True,untested
|
||||
sbs://pbr_render_ortho.sbs,probabilityGGX,10,True,untested
|
||||
sbs://pbr_render_ortho.sbs,samplePanoramic_uv,37,True,untested
|
||||
sbs://pbr_render_ortho.sbs,fibbonacci_vec3,46,True,untested
|
||||
sbs://pbr_render_ortho.sbs,fibbonacci_vec3_uniform,28,True,untested
|
||||
sbs://pbr_render_ortho.sbs,irradiance_sample_2,109,True,untested
|
||||
sbs://pbr_render_ortho.sbs,IBLSpecularContributionSample,51,True,untested
|
||||
sbs://pbr_render_ortho.sbs,latlong_uv_to_vector,15,True,untested
|
||||
sbs://pbr_render_ortho.sbs,MaxFunction,49,True,untested
|
||||
sbs://pbr_render_ortho.sbs,tiling_clamp,25,True,untested
|
||||
sbs://pbr_render_ortho.sbs,camera_dir_from_2d_pos,32,True,untested
|
||||
sbs://quad_transform.sbs,outer_product,9,True,untested
|
||||
sbs://quad_transform.sbs,solvePoly2,29,True,untested
|
||||
sbs://quad_transform.sbs,solvePoly2_stable,43,True,untested
|
||||
sbs://quad_transform.sbs,isIn01,12,True,untested
|
||||
sbs://quad_transform.sbs,sqrt,6,True,untested
|
||||
sbs://quantize_color.sbs,bitonic_sort/functions/flip_sort,19,True,untested
|
||||
sbs://quantize_color.sbs,bitonic_sort/functions/disperse_sort,19,True,untested
|
||||
sbs://quantize_color.sbs,bitonic_sort/functions/disperse_sort_dual,15,True,untested
|
||||
sbs://quantize_color.sbs,bitonic_sort/functions/internal_sort,5,True,untested
|
||||
sbs://quantize_color.sbs,bitonic_sort/functions/argmax_float2,9,True,untested
|
||||
sbs://quantize_color.sbs,bitonic_sort/functions/argmax_float2_mask,10,True,untested
|
||||
sbs://quantize_color.sbs,anisotropic_blur_fct/gaussian,15,True,untested
|
||||
sbs://quantize_color.sbs,anisotropic_blur_fct/mul_mat22_vec2,9,True,untested
|
||||
sbs://quantize_color.sbs,anisotropic_blur_fct/mul_mat22_mat22,25,True,untested
|
||||
sbs://quantize_color.sbs,anisotropic_blur_fct/wrap_uv,27,True,untested
|
||||
sbs://quantize_color.sbs,color_conversions/convert_RGB_to_Lab_fct,48,True,untested
|
||||
sbs://quantize_color.sbs,color_conversions/convert_Lab_to_RGB_fct,65,True,untested
|
||||
sbs://quantize_color.sbs,color_conversions/helpers/Rgb2LabConversionFct2,14,True,untested
|
||||
sbs://quantize_color.sbs,color_conversions/helpers/Rgb2LabConversionFct1,16,True,untested
|
||||
sbs://quantize_color.sbs,color_conversions/helpers/Lab2RgbConversionFct1,14,True,untested
|
||||
sbs://quantize_color.sbs,color_conversions/helpers/Lab2RgbConversionFct2,14,True,untested
|
||||
sbs://quantize_color.sbs,color_properties/color_distance_Lab,30,True,untested
|
||||
sbs://quantize_color.sbs,color_properties/distance_falloff,13,True,untested
|
||||
sbs://quantize_color.sbs,get_min_max/MaxFunctionFromAlpha,49,True,untested
|
||||
sbs://radial_blur.sbs,rotate_position,15,True,untested
|
||||
sbs://rt_ao.sbs,functions/fibonacci_sequence,8,True,untested
|
||||
sbs://rt_ao.sbs,functions/fibonacci2D,12,True,untested
|
||||
sbs://rt_ao.sbs,functions/rtao_iteration,26,True,untested
|
||||
sbs://rt_ao_v2.sbs,functions/fibonacci_sequence,8,True,untested
|
||||
sbs://rt_ao_v2.sbs,functions/fibonacci2D,10,True,untested
|
||||
sbs://rt_ao_v2.sbs,functions/lod_uv,29,True,untested
|
||||
sbs://rt_ao_v2.sbs,functions/infinite_box_intersect,28,True,untested
|
||||
sbs://rt_bent_normal.sbs,functions/bent_normal_iteration,26,True,untested
|
||||
sbs://rt_bent_normal.sbs,functions/fibonacci2D,12,True,untested
|
||||
sbs://rt_bent_normal.sbs,functions/fibonacci_sequence,8,True,untested
|
||||
sbs://rt_bent_normal_v2.sbs,functions/fibonacci_sequence,8,True,untested
|
||||
sbs://rt_bent_normal_v2.sbs,functions/fibonacci2D,10,True,untested
|
||||
sbs://rt_bent_normal_v2.sbs,functions/lod_uv,29,True,untested
|
||||
sbs://rt_bent_normal_v2.sbs,functions/infinite_box_intersect,28,True,untested
|
||||
sbs://rt_caustics.sbs,functions/refract,22,True,untested
|
||||
sbs://rt_caustics.sbs,functions/plane_infinite_intersect,9,True,untested
|
||||
sbs://rt_irradiance.sbs,functions/camera_dir_from_xy,32,True,untested
|
||||
sbs://rt_irradiance.sbs,functions/sample_mip,49,True,untested
|
||||
sbs://rt_irradiance.sbs,functions/emissive_lod_uv,31,True,untested
|
||||
sbs://rt_irradiance.sbs,functions/box_intersect,41,True,untested
|
||||
sbs://rt_irradiance.sbs,functions/plane_infinite_intersect,9,True,untested
|
||||
sbs://rt_irradiance.sbs,functions/fibonacci2D,10,True,untested
|
||||
sbs://rt_irradiance.sbs,functions/panoramic_lod_uv,36,True,untested
|
||||
sbs://rt_irradiance.sbs,functions/compute_panoramic_lod,22,True,untested
|
||||
sbs://rt_irradiance.sbs,functions/compute_ray_direction_fn,43,True,untested
|
||||
sbs://rt_irradiance.sbs,functions/compute_emissive_lod,35,True,untested
|
||||
sbs://rt_irradiance.sbs,functions/lod_uv,28,True,untested
|
||||
sbs://rt_irradiance.sbs,functions/compute_emissive_sample_uvs,8,True,untested
|
||||
sbs://rt_shadows.sbs,functions/camera_dir_from_xy,32,True,untested
|
||||
sbs://rt_shadows.sbs,functions/sample_mip,49,True,untested
|
||||
sbs://rt_shadows.sbs,functions/lod_uv,28,True,untested
|
||||
sbs://rt_shadows.sbs,functions/box_intersect,41,True,untested
|
||||
sbs://rt_shadows.sbs,functions/plane_infinite_intersect,9,True,untested
|
||||
sbs://rt_shadows.sbs,functions/fibonacci2D,12,True,untested
|
||||
sbs://rt_shadows_v2.sbs,functions/lod_uv,28,True,untested
|
||||
sbs://rt_shadows_v2.sbs,functions/infinite_box_intersect,28,True,untested
|
||||
sbs://rt_shadows_v2.sbs,functions/fibonacci2D,10,True,untested
|
||||
sbs://shape_extrude.sbs,extrude_profile,72,True,untested
|
||||
sbs://shape_mapper.sbs,cartesian_to_polar_function,16,True,untested
|
||||
sbs://shape_splatter.sbs,functions/tile_sample_blend,339,True,untested
|
||||
sbs://shape_splatter.sbs,functions/unpack_floatXY,6,True,untested
|
||||
sbs://shape_splatter.sbs,functions/pack_float_X_Y,5,True,untested
|
||||
sbs://shape_splatter.sbs,functions/random_offset,5,True,untested
|
||||
sbs://shape_splatter.sbs,functions/normal_combine_detail_oriented,41,True,untested
|
||||
sbs://shape_splatter.sbs,functions/tile_sample_blend_2,214,True,untested
|
||||
sbs://shape_splatter.sbs,functions/max_xy,4,True,untested
|
||||
sbs://shape_splatter.sbs,functions/C1,5,True,untested
|
||||
sbs://shape_splatter.sbs,functions/C2,8,True,untested
|
||||
sbs://shape_splatter.sbs,functions/distance_neighboor,7,True,untested
|
||||
sbs://shape_splatter.sbs,functions/sample_neighboor,13,True,untested
|
||||
sbs://shape_splatter_v2.sbs,compute_size_ratio,12,True,untested
|
||||
sbs://shape_splatter_v2.sbs,output_size_constants,93,True,untested
|
||||
sbs://shape_splatter_v2.sbs,euclidian_division,24,True,untested
|
||||
sbs://shape_splatter_v2.sbs,compute_cube_2d_bbox,18,True,untested
|
||||
sbs://shape_splatter_v2.sbs,box_uvs,49,False,untested
|
||||
sbs://shape_splatter_v2.sbs,normal_reconstruct_z,16,True,untested
|
||||
sbs://shape_splatter_v2.sbs,polar_to_carthesian,18,False,untested
|
||||
sbs://shape_splatter_v2.sbs,vec3_to_angle,11,False,untested
|
||||
sbs://shape_splatter_v2.sbs,lerp_vec3,8,True,untested
|
||||
sbs://shape_splatter_v2.sbs,compute_atlas_uv,23,False,untested
|
||||
sbs://shape_splatter_v2.sbs,compute_grid_atlas_size,8,True,untested
|
||||
sbs://shape_splatter_v2.sbs,decode_atlas_ID,5,True,untested
|
||||
sbs://shape_splatter_v2.sbs,mirror,7,False,untested
|
||||
sbs://shape_splatter_v2.sbs,debug/pattern_outline,54,True,untested
|
||||
sbs://shape_splatter_v2.sbs,bitonic_sort/functions/flip_sort,19,False,untested
|
||||
sbs://shape_splatter_v2.sbs,bitonic_sort/functions/disperse_sort,19,False,untested
|
||||
sbs://shape_splatter_v2.sbs,bitonic_sort/functions/disperse_sort_dual,15,False,untested
|
||||
sbs://shape_splatter_v2.sbs,bitonic_sort/functions/internal_sort,5,False,untested
|
||||
sbs://shape_splatter_v2.sbs,bitonic_sort/functions/argmax_float2,9,False,untested
|
||||
sbs://shape_splatter_v2.sbs,bitonic_sort/functions/argmax_float2_mask,10,False,untested
|
||||
sbs://shape_splatter_v2.sbs,sdf/sdf_intersect,20,True,untested
|
||||
sbs://shape_splatter_v2.sbs,pattern_functions/pattern_disc,7,True,untested
|
||||
sbs://shape_splatter_v2.sbs,distribution_functions/R2,8,True,untested
|
||||
sbs://shape_splatter_v2.sbs,distribution_functions/halton,33,True,untested
|
||||
sbs://shape_splatter_v2.sbs,distribution_functions/fibonacci2D,10,True,untested
|
||||
sbs://shape_splatter_v2.sbs,distribution_functions/weyl,9,True,untested
|
||||
sbs://shape_splatter_v2.sbs,sample_warping/warping_function,92,True,untested
|
||||
sbs://shape_splatter_v2.sbs,sample_warping/sat_compute_rectangle_integral,49,True,untested
|
||||
sbs://shape_splatter_v2.sbs,sample_warping/sat_2d_compute_integral,37,True,untested
|
||||
sbs://shape_splatter_v2.sbs,sample_warping/vec2_axis_select,7,True,untested
|
||||
sbs://shape_splatter_v2.sbs,sample_warping/out_of_bound,6,True,untested
|
||||
sbs://shape_splatter_v2.sbs,sample_warping/vec2_axis_select_bool,5,True,untested
|
||||
sbs://shape_splatter_v2.sbs,bbox_tools/EmptyBBox,1,True,untested
|
||||
sbs://shape_splatter_v2.sbs,bbox_tools/TriangleBBox,20,True,untested
|
||||
sbs://shape_splatter_v2.sbs,bbox_tools/BlendBBox,9,True,untested
|
||||
sbs://shape_splatter_v2.sbs,bbox_tools/BBoxIntersectBBox,69,True,untested
|
||||
sbs://shape_splatter_v2.sbs,bit_tools/LShift16,27,True,untested
|
||||
sbs://shape_splatter_v2.sbs,bit_tools/RShift16,27,True,untested
|
||||
sbs://shape_splatter_v2.sbs,bit_tools/MSB16,34,True,untested
|
||||
sbs://shape_splatter_v2.sbs,loop_tools/Scanline++Auto,7,True,untested
|
||||
sbs://shape_splatter_v2.sbs,loop_tools/Scanline++,14,True,untested
|
||||
sbs://shape_splatter_v2.sbs,mipmap_tools/LvlInfos,10,True,untested
|
||||
sbs://shape_splatter_v2.sbs,mipmap_tools/posFromLvlInfos,7,True,untested
|
||||
sbs://shape_splatter_v2.sbs,mipmap_tools/posFromLvl,4,True,untested
|
||||
sbs://shape_splatter_v2_companion.sbs,blend_overlay,32,False,untested
|
||||
sbs://shape_splatter_v2_companion.sbs,compute_frame_cube,17,False,untested
|
||||
sbs://shape_splatter_v2_companion.sbs,compute_frame_cylinder,23,False,untested
|
||||
sbs://shape_splatter_v2_companion.sbs,uv_out_of_bounds,21,True,untested
|
||||
sbs://shape_splatter_v2_companion.sbs,functions/switch_input_grayscale_8,72,True,untested
|
||||
sbs://shape_splatter_v2_companion.sbs,functions/switch_input_color_8,68,True,untested
|
||||
sbs://shape_splatter_v2_companion.sbs,functions/blend_overlay,30,True,untested
|
||||
sbs://shape_splatter_v2_companion.sbs,functions/adjustments_grayscale,11,True,untested
|
||||
sbs://shape_splatter_v2_companion.sbs,functions/adjustments_color,42,True,untested
|
||||
sbs://smart_auto_tile.sbs,normal_to_cos_sin,30,True,untested
|
||||
sbs://spline_tools.sbs,internal_tools/sample_blending_mode,21,True,untested
|
||||
sbs://spline_tools.sbs,internal_tools/non_square_uv_scale,15,True,untested
|
||||
sbs://spline_tools.sbs,functions/clamp_u,7,True,untested
|
||||
sbs://spline_tools.sbs,functions/hash_11,10,True,untested
|
||||
sbs://spline_tools.sbs,functions/hash_41,19,True,untested
|
||||
sbs://spline_tools.sbs,functions/compute_spline_data_parent_size,11,True,untested
|
||||
sbs://spline_tools.sbs,functions/compute_spline_data_size,9,True,untested
|
||||
sbs://spline_tools.sbs,functions/quad_vertex_sample_uv,18,True,untested
|
||||
sbs://spline_tools.sbs,functions/get_spline_point_uv,14,True,untested
|
||||
sbs://spline_tools.sbs,functions/quadratic_b-spline_3d_derivative,49,True,untested
|
||||
sbs://spline_tools.sbs,functions/quadratic_b-spline_4d,50,True,untested
|
||||
sbs://spline_tools.sbs,functions/cubic_bezier_interpolation_function,28,True,untested
|
||||
sbs://spline_tools.sbs,functions/cubic_bezier_derivative_function,34,True,untested
|
||||
sbs://spline_tools.sbs,functions/cubic_bezier_4d,28,True,untested
|
||||
sbs://spline_tools.sbs,functions/cubic_bezier_3d,28,True,untested
|
||||
sbs://spline_tools.sbs,functions/cubic_bezier_3d_derivative,37,True,untested
|
||||
sbs://spline_tools.sbs,functions/start_end_attenuation,18,True,untested
|
||||
sbs://spline_tools.sbs,functions/inverse_function_iteration,26,True,untested
|
||||
sbs://spline_tools.sbs,functions/sampling_mode_function,32,True,untested
|
||||
sbs://spline_tools.sbs,functions/is_closed,4,True,untested
|
||||
sbs://spline_tools.sbs,functions/compute_spline_enveloppe,29,True,untested
|
||||
sbs://spline_tools.sbs,functions/decode_thickness,7,True,untested
|
||||
sbs://spline_tools.sbs,functions/non_square_data,8,True,untested
|
||||
sbs://spline_tools.sbs,functions/non_square_coords,24,True,untested
|
||||
sbs://spline_tools.sbs,functions/solvePoly2_stable,43,True,untested
|
||||
sbs://spline_tools.sbs,functions/point_list_size_log2,11,True,untested
|
||||
sbs://spline_tools.sbs,functions/point_properties_decode_thickness,6,True,untested
|
||||
sbs://spline_tools.sbs,functions/point_properties_encode,23,True,untested
|
||||
sbs://spline_tools.sbs,functions/circle_spline_function,77,True,untested
|
||||
sbs://spline_tools.sbs,functions/point_smoothness_function,6,True,untested
|
||||
sbs://spline_tools.sbs,functions/point_list_point_uv,11,True,untested
|
||||
sbs://spline_tools.sbs,functions/posInQuad,17,True,untested
|
||||
sbs://spline_tools.sbs,functions/segment_hit,21,True,untested
|
||||
sbs://spline_tools.sbs,functions/scatter_splines_on_splines_fn,410,False,untested
|
||||
sbs://spline_tools.sbs,functions/scatter_splines_on_splines_v2_fn,425,False,untested
|
||||
sbs://spline_tools.sbs,functions/non_square_xy_ratio,12,False,untested
|
||||
sbs://spline_tools.sbs,functions/vec3_rotation,16,True,untested
|
||||
sbs://spline_tools.sbs,functions/euclidian_division,27,True,untested
|
||||
sbs://spline_tools.sbs,functions/spline_bridge_list_fn,199,True,untested
|
||||
sbs://swirl.sbs,transformPosition,13,True,untested
|
||||
sbs://swirl.sbs,inverseTransformPosition,7,True,untested
|
||||
sbs://swirl.sbs,matrixInvert,13,True,untested
|
||||
sbs://tile_random.sbs,tile_random_current_position,22,True,untested
|
||||
sbs://tile_random.sbs,tile_random_grayscale_function,148,True,untested
|
||||
sbs://tile_random.sbs,tile_random_color_function,109,True,untested
|
||||
sbs://triplanar.sbs,functions/rotate_position,17,True,untested
|
||||
sbs://triplanar.sbs,functions/grayscale_convert,8,True,untested
|
||||
sbs://triplanar.sbs,functions/division_float4,17,True,untested
|
||||
sbs://waveform_01_v2.sbs,functions/level_factor,20,True,untested
|
||||
sbs://waveform_01_v2.sbs,functions/value_noise_2D,51,True,untested
|
||||
sbs://waveform_01_v2.sbs,functions/noise,22,True,untested
|
||||
sbs://white_noise_v2.sbs,functions/disorder,21,True,untested
|
||||
|
@@ -1,12 +1,10 @@
|
||||
# Parity with the reference workflow
|
||||
|
||||
The [2026-11-15 catalog audit](node-catalog-parity.md) inventories 29 main-graph entries,
|
||||
85 function operations, four map kinds and 954 loaded package functions. Original probe
|
||||
results establish only the recorded cases; full numerical parity remains unestablished.
|
||||
The [atomic corrections follow-up](atomic-parity-improvements.md) covers six corrected nodes,
|
||||
with a corrected input transport, reproducible regressions and explicit remaining differences.
|
||||
The [second atomic pass](atomic-exact-parity.md) records further Sharpen and Shuffle fixes,
|
||||
with separate measurements for reference backend and CPU-count differences.
|
||||
The [catalog status](node-catalog-parity.md) covers 29 main-graph entries, 85 function
|
||||
operations, four map kinds and 954 loaded package functions. The
|
||||
[atomic corrections](atomic-parity-improvements.md) describe filter, channel-selection
|
||||
and background fixes with local regression coverage. Full numerical parity remains
|
||||
unestablished.
|
||||
|
||||
> The assessment below predates the 2026-11-05 primitive rewrite. Its old library counts and
|
||||
> compatibility claims are historical. See [atomic-workflow.md](atomic-workflow.md) and
|
||||
|
||||
Reference in new issue
Block a user