From 97f2e06ed52fae280ebfe4ace12f566375249e42 Mon Sep 17 00:00:00 2001 From: chasse20 Date: Tue, 17 Nov 2026 23:45:47 -0500 Subject: [PATCH] Filter bilinear transforms at the selected mip level Keep automatic and manual mip settings across SBS round trips and store each filtered reduction at the destination precision. Record the panorama, volume mask and Worley measurements that complete the 3D inventory section. --- Cargo.lock | 2 +- crates/eval/Cargo.toml | 1 - crates/eval/src/lib.rs | 2 +- crates/formats/src/sbs/filter_map.rs | 9 ++++- crates/formats/tests/library_native_ports.rs | 17 ++++++++ crates/nodes/Cargo.toml | 1 + crates/nodes/src/atomic/transformation.rs | 30 ++++++++++---- crates/nodes/src/function/mod.rs | 1 - crates/nodes/src/function/operation.rs | 2 +- .../src/{function => }/integer_sampler.rs | 12 +++--- crates/nodes/src/lib.rs | 2 + .../{eval => nodes}/src/output_precision.rs | 5 ++- crates/nodes/src/tests.rs | 25 ++++++++++++ docs/parity-fixes.md | 39 ++++++++++++++++++- docs/sbs-root-nodes.md | 8 ++-- 15 files changed, 130 insertions(+), 26 deletions(-) rename crates/nodes/src/{function => }/integer_sampler.rs (88%) rename crates/{eval => nodes}/src/output_precision.rs (92%) diff --git a/Cargo.lock b/Cargo.lock index 8239580..553e349 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2869,7 +2869,6 @@ name = "materialcraft-eval" version = "0.4.1" dependencies = [ "craft-texture", - "half", "materialcraft-core", "materialcraft-nodes", "serde", @@ -2919,6 +2918,7 @@ name = "materialcraft-nodes" version = "0.4.1" dependencies = [ "craft-texture", + "half", "materialcraft-core", "rayon", ] diff --git a/crates/eval/Cargo.toml b/crates/eval/Cargo.toml index a5ddc9f..54e97be 100644 --- a/crates/eval/Cargo.toml +++ b/crates/eval/Cargo.toml @@ -12,6 +12,5 @@ workspace = true materialcraft-core = { workspace = true } craft-texture = { workspace = true } materialcraft-nodes = { workspace = true } -half = { workspace = true } serde_json = { workspace = true } serde = { workspace = true } diff --git a/crates/eval/src/lib.rs b/crates/eval/src/lib.rs index 780a9d0..8fced75 100644 --- a/crates/eval/src/lib.rs +++ b/crates/eval/src/lib.rs @@ -13,7 +13,7 @@ mod node_output; mod node_result; mod node_size; mod options; -mod output_precision; +use materialcraft_nodes::output_precision; mod parameter; mod parameter_function; mod port; diff --git a/crates/formats/src/sbs/filter_map.rs b/crates/formats/src/sbs/filter_map.rs index add01aa..052b705 100644 --- a/crates/formats/src/sbs/filter_map.rs +++ b/crates/formats/src/sbs/filter_map.rs @@ -79,7 +79,14 @@ pub(super) const FILTERS: &[FilterMap] = &[ sbs: "transformation", def: "transformation", inputs: &[("input1", "input")], - params: &[("offset", "offset"), ("mattecolor", "matte"), ("matrix22", "matrix"), ("filtering", "filtering")], + params: &[ + ("offset", "offset"), + ("mattecolor", "matte"), + ("matrix22", "matrix"), + ("filtering", "filtering"), + ("mipmapmode", "mip_mode"), + ("manualmiplevel", "mip_level"), + ], }, FilterMap { sbs: "warp", def: "warp", inputs: &[("input1", "input"), ("inputgradient", "gradient")], params: &[("intensity", "intensity")] }, FilterMap { sbs: "passthrough", def: "dot", inputs: &[("input", "input"), ("input1", "input")], params: &[] }, diff --git a/crates/formats/tests/library_native_ports.rs b/crates/formats/tests/library_native_ports.rs index 1805584..2b4c9a6 100644 --- a/crates/formats/tests/library_native_ports.rs +++ b/crates/formats/tests/library_native_ports.rs @@ -122,3 +122,20 @@ fn native_pattern_inputs_and_hsl_luminosity_round_trip() { assert_eq!(legacy.pkg.graphs[0].connections.len(), 1); assert_eq!(legacy.pkg.graphs[0].nodes.iter().find(|node| node.def == "hsl").unwrap().params["lightness"], materialcraft_core::Value::Float(0.75)); } +#[test] +fn transform_mip_settings_survive_sbs_round_trip() { + let xml = br#" + + + + "#; + let mut read = read_sbs(xml, "mip.sbs", &|_| None).unwrap(); + for _ in 0..2 { + assert!(read.warnings.is_empty(), "{:?}", read.warnings); + let params = &read.pkg.graphs[0].nodes[0].params; + assert_eq!(params.get("mip_mode"), Some(&materialcraft_core::Value::Enum(1))); + assert_eq!(params.get("mip_level"), Some(&materialcraft_core::Value::Int(3))); + let bytes = write_sbs(&read.pkg).unwrap(); + read = read_sbs(&bytes, "saved.sbs", &|_| None).unwrap(); + } +} diff --git a/crates/nodes/Cargo.toml b/crates/nodes/Cargo.toml index daf743e..51e0ce0 100644 --- a/crates/nodes/Cargo.toml +++ b/crates/nodes/Cargo.toml @@ -11,4 +11,5 @@ workspace = true [dependencies] materialcraft-core = { workspace = true } craft-texture = { workspace = true } +half = { workspace = true } rayon = { workspace = true } diff --git a/crates/nodes/src/atomic/transformation.rs b/crates/nodes/src/atomic/transformation.rs index 3d4eabd..d32c40a 100644 --- a/crates/nodes/src/atomic/transformation.rs +++ b/crates/nodes/src/atomic/transformation.rs @@ -11,6 +11,8 @@ pub(super) fn definition() -> NodeDefinition { .float2("offset", "Offset", [0.0; 2], -1.0, 1.0) .float4("matrix", "Transform matrix", [1.0, 0.0, 0.0, 1.0], -10.0, 10.0) .choice("filtering", "Filtering", &["Bilinear", "Nearest"], 0) + .choice("mip_mode", "Mipmap mode", &["Automatic", "Manual"], 0) + .int("mip_level", "Mipmap level", 0, 0, 13) .color("matte", "Matte color", [0.0; 4]) .any_out() .cook(transformation) @@ -28,11 +30,12 @@ fn transformation(context: &CookContext) -> CookResult { } let nearest = context.i("filtering") == 1; - let input = if nearest { nearest_mip(input, matrix, context) } else { input }; + let levels = mip_level(&input, matrix, context); + let input = reduce_mip(input, levels, nearest, context.format); let matte = context.v4("matte"); // Keep independent wrap axes for panoramic images - let tiling = context.vars.get("$tiling").and_then(materialcraft_core::Value::as_i32).map_or([context.tile; 2], |mask| [mask & 1 != 0, mask & 2 != 0]); + let tiling = context.tiling_axes(); Ok(vec![Image::generate_uv(context.w, context.h, input.kind(), |u, v| { let x = u - 0.5; @@ -45,21 +48,29 @@ fn transformation(context: &CookContext) -> CookResult { matte } else if nearest { input.sample_nearest_axes(source_u, source_v, tiling) + } else if input.integer_sampling() { + crate::integer_sampler::sample(&input, [source_u, source_v], tiling) } else { input.sample_axes(source_u, source_v, tiling) } })]) } -fn nearest_mip(mut input: Image, matrix: [f32; 4], context: &CookContext) -> Image { +fn mip_level(input: &Image, matrix: [f32; 4], context: &CookContext) -> u32 { + // Thirteen reductions cover the maximum supported side of 8192 texels. + if context.i("mip_mode") == 1 { + return context.i("mip_level").clamp(0, 13) as u32; + } let width = context.w.max(1) as f32; let height = context.h.max(1) as f32; let dx = (matrix[0] * input.width() as f32 / width).hypot(matrix[1] * input.height() as f32 / width); let dy = (matrix[2] * input.width() as f32 / height).hypot(matrix[3] * input.height() as f32 / height); - // Thirteen reductions cover the maximum supported side of 8192 texels - let levels = dx.max(dy).max(1.0).log2().round().clamp(0.0, 13.0) as u32; - let maximum = match context.format { + dx.max(dy).max(1.0).log2().round().clamp(0.0, 13.0) as u32 +} + +fn reduce_mip(mut input: Image, levels: u32, nearest: bool, format: OutputFormat) -> Image { + let nearest_maximum = match format { OutputFormat::U8 => Some(255.0), OutputFormat::Inherit | OutputFormat::U16 => Some(65535.0), OutputFormat::F16 | OutputFormat::F32 => None, @@ -70,7 +81,8 @@ fn nearest_mip(mut input: Image, matrix: [f32; 4], context: &CookContext) -> Ima break; } - // Integer mip levels round four-texel averages halfway up + // Bilinear samples of either normalized source depth return a 16-bit value. + let maximum = if nearest { nearest_maximum } else { input.integer_sampling().then_some(65535.0) }; input = Image::generate(input.width().div_ceil(2), input.height().div_ceil(2), input.kind(), |x, y| { let (x, y) = (i64::from(x) * 2, i64::from(y) * 2); let pixels = [input.get(x, y, false), input.get(x + 1, y, false), input.get(x, y + 1, false), input.get(x + 1, y + 1, false)]; @@ -84,6 +96,10 @@ fn nearest_mip(mut input: Image, matrix: [f32; 4], context: &CookContext) -> Ima } }) }); + if !nearest { + // Each reduction is stored at the transform's output precision before the next read. + input = crate::output_precision::apply(input, format); + } } input diff --git a/crates/nodes/src/function/mod.rs b/crates/nodes/src/function/mod.rs index 2868ea7..6d163b8 100644 --- a/crates/nodes/src/function/mod.rs +++ b/crates/nodes/src/function/mod.rs @@ -19,7 +19,6 @@ mod function_definition; mod function_scope; mod inferred_type; mod instruction; -mod integer_sampler; mod node_interface; mod node_types; mod operation; diff --git a/crates/nodes/src/function/operation.rs b/crates/nodes/src/function/operation.rs index 48c492d..f509c40 100644 --- a/crates/nodes/src/function/operation.rs +++ b/crates/nodes/src/function/operation.rs @@ -126,7 +126,7 @@ pub(crate) fn evaluate( image.get((position[0] * image.width() as f32).floor() as i64, (position[1] * image.height() as f32).floor() as i64, context.tile) } Some(image) if context.scope == super::FunctionScope::PixelProcessor && image.integer_sampling() => { - super::integer_sampler::sample(image, [position[0], position[1]], context.tile) + crate::integer_sampler::sample(image, [position[0], position[1]], [context.tile; 2]) } Some(image) => image.sample_stored(position[0], position[1], context.tile), None => [0.0; 4], diff --git a/crates/nodes/src/function/integer_sampler.rs b/crates/nodes/src/integer_sampler.rs similarity index 88% rename from crates/nodes/src/function/integer_sampler.rs rename to crates/nodes/src/integer_sampler.rs index dfd9302..7eef369 100644 --- a/crates/nodes/src/function/integer_sampler.rs +++ b/crates/nodes/src/integer_sampler.rs @@ -1,12 +1,12 @@ use craft_texture::Image; -/// Bilinear reads from normalized integer textures in a Pixel Processor. -pub(super) fn sample(image: &Image, [u, v]: [f32; 2], tile: bool) -> [f32; 4] { +/// Bilinear reads from normalized integer textures with independent wrap axes. +pub(crate) fn sample(image: &Image, [u, v]: [f32; 2], tiling: [bool; 2]) -> [f32; 4] { if !u.is_finite() || !v.is_finite() { return [0.0, 0.0, 0.0, 1.0]; } - let (x, dx) = axis(u, image.width(), tile); - let (y, dy) = axis(v, image.height(), tile); + let (x, dx) = axis(u, image.width(), tiling[0]); + let (y, dy) = axis(v, image.height(), tiling[1]); // Round the diagonal coefficient first. The four tap weights must still sum to 256. let diagonal = (dx * dy + 128) / 256; let bottom = dy - diagonal; @@ -14,7 +14,7 @@ pub(super) fn sample(image: &Image, [u, v]: [f32; 2], tile: bool) -> [f32; 4] { let mut sum = [0.0; 4]; for (x, y, weight) in taps { if weight != 0 { - for (total, channel) in sum.iter_mut().zip(image.get(x, y, tile)) { + for (total, channel) in sum.iter_mut().zip(image.get_axes(x, y, tiling)) { // Stored 16-bit levels times the eight-bit weights sum exactly in f32. *total += (channel.clamp(0.0, 1.0) * 65535.0).round() * weight as f32; } @@ -60,7 +60,7 @@ mod tests { let pos = graph.add("get_float2", &[], Some(Value::Text("$pos".into()))); graph.output = Some(graph.add("samplecol", &[pos], Some(Value::Int2([0, 1])))); let program = compile(&graph, 0).unwrap(); - let pixel = |context: &EvaluationContext<'_>| program.evaluate_pixel(context, &mut EvaluationState::default()).unwrap(); + let pixel = |context: &EvaluationContext<'_>| program.evaluate(context, &mut EvaluationState::default()).unwrap(); let expected = Value::Float4([32768.0, 0.0, 32512.0, 256.0].map(|n| n / 65535.0)); assert_eq!(pixel(&context), expected); context.position[0] -= 1.0; diff --git a/crates/nodes/src/lib.rs b/crates/nodes/src/lib.rs index caca06f..277ad4e 100644 --- a/crates/nodes/src/lib.rs +++ b/crates/nodes/src/lib.rs @@ -5,12 +5,14 @@ pub mod atomic; pub mod catalog; pub mod function; pub mod ops; +pub mod output_precision; pub mod pattern; mod raster; mod cook_context; pub mod graph_interface; mod image_input; +mod integer_sampler; mod node_definition; mod node_definition_builder; mod output_value_type; diff --git a/crates/eval/src/output_precision.rs b/crates/nodes/src/output_precision.rs similarity index 92% rename from crates/eval/src/output_precision.rs rename to crates/nodes/src/output_precision.rs index 9b1a240..f7c24bd 100644 --- a/crates/eval/src/output_precision.rs +++ b/crates/nodes/src/output_precision.rs @@ -2,7 +2,8 @@ use craft_texture::{Image, Limits}; use materialcraft_core::OutputFormat; use std::sync::Arc; -pub(crate) fn apply(image: Image, format: OutputFormat) -> Image { +/// Store a cooked image at its destination precision, including intermediate mip levels. +pub fn apply(image: Image, format: OutputFormat) -> Image { const HALF_FLOAT_MAX: f32 = 65504.0; const U8_FIXED_SCALE: f64 = 4096.0; const U16_FIXED_SCALE: f64 = 1_048_576.0; @@ -34,7 +35,7 @@ pub(crate) fn apply(image: Image, format: OutputFormat) -> Image { }) } -pub(crate) fn integer_sampling(format: OutputFormat) -> bool { +fn integer_sampling(format: OutputFormat) -> bool { matches!(format, OutputFormat::Inherit | OutputFormat::U8 | OutputFormat::U16) } diff --git a/crates/nodes/src/tests.rs b/crates/nodes/src/tests.rs index 7cca901..88da149 100644 --- a/crates/nodes/src/tests.rs +++ b/crates/nodes/src/tests.rs @@ -24,6 +24,31 @@ fn cook(def: &NodeDefinition, inputs: &[Option], size: u32) -> CookResult (def.cook)(&ctx) } +#[test] +fn bilinear_transform_selects_and_stores_the_requested_mip_level() { + let definition = find("transformation").unwrap(); + let inputs = [Some(Image::gray(16, 16, |x, y| if x % 4 == 0 && y % 4 == 0 { 1.0 } else { 0.0 }).with_integer_sampling(true))]; + let variables = BTreeMap::new(); + let filtered = 4096.0 / 65535.0; + + for (size, mode, level, first, second) in [(4, 0, 0, filtered, filtered), (4, 1, 0, 0.0, 0.0), (16, 0, 0, 1.0, 0.0), (16, 1, 2, filtered, filtered)] { + let params = resolve_params(definition, &BTreeMap::from([("mip_mode".into(), Value::Enum(mode)), ("mip_level".into(), Value::Int(level))])); + let context = CookContext { + format: materialcraft_core::OutputFormat::U16, + w: size, + h: size, + seed: 0, + tile: true, + inputs: &inputs, + params: ¶ms, + resource: &|_| None, + vars: &variables, + }; + let result = (definition.cook)(&context).unwrap(); + assert_eq!([result[0].get_gray(0, 0, false), result[0].get_gray(1, 0, false)], [first, second], "size {size}, mode {mode}, level {level}"); + } +} + #[test] fn nearest_transform_mip_keeps_the_last_column_of_an_odd_width_input() { let definition = find("transformation").unwrap(); diff --git a/docs/parity-fixes.md b/docs/parity-fixes.md index 57d49bf..86e3ccc 100644 --- a/docs/parity-fixes.md +++ b/docs/parity-fixes.md @@ -158,9 +158,46 @@ Use a float32 parent, the RGBA8 position ramp above and an original signed-dista The plane uses `.55*X+.3*Y-.7*Z+.06`. The shifted sphere uses `sqrt((X-.125)²+(Y+.1)²+(Z-.125)²)-.36`. Both produced the same sparse marker as the centered sphere for the changed debug point. The 128² cases had zero colored texels. The parity mark covers these output images and settings. +### Panoramic LOD + +The panorama helper exposes one image input. For its first-pass fixtures, let `U=floor(255*x/(N-1))`, `V=floor(255*y/(N-1))` and `T=(17*x+31*y) mod 256`. Bind linear RGBA8 `(T,U,255-V,255)`. The alpha case uses `(7*x+13*y) mod 256` for A. The new reference outputs for all three first-pass cases match their archived raw pixels exactly. The fractional-alpha input and opaque input produce identical output here. The four 64² cases use the varying-alpha color texture from the planar projection comparison. + +| Input | Size | Seed | Format | Exact pixels / total | Maximum error | +|---|---:|---:|---|---:|---:| +| Opaque | 128² | 0 and 42 | RGBA8 | 15,883/16,384 each | 125 | +| Opaque | 256² | 0 | RGBA8 | 63,309/65,536 | 126 | +| Varying alpha | 128² | 0 | RGBA8 | 15,883/16,384 | 125 | +| Flat (23,139,211), alpha 75 or 255 | 128² | 0 | RGBA8 | 16,128/16,384 each | 116 | +| Varying alpha | 64² | 42 | RGBA8 / RGBA16 | 3,964/4,096 each | 1 / 257 | +| Same input | 64² | 42 | RGBA16F / RGBA32F | 3,964/4,096 each | .00439453125 / .0039215982 | + +MaterialCraft previously sampled the full-resolution input for every bilinear transform. The 128² and 256² opaque cases then matched 719 and 5,015 pixels. An isolated transform uses a 2048×1024 RGBA8 input `(T,x mod 256,(255-y) mod 256,255)`, a 128² output, matrix `diag(-1,1.99309003)`, offset `(0,.5)`, horizontal-only wrap and opaque black matte. Its input bridge matches all 2,097,152 texels. The transform improved from 8,216/16,384 (maximum 117) to 16,384/16,384 (0). Changing the vertical scale to 2 improved from 8,192/16,384 (103) to 16,384/16,384 (0). When the first-pass 128² input is resized to the same 2048×1024 bridge, 1,923,823/2,097,152 input texels match (maximum 2). The two transforms give 16,287 and 16,284 exact output pixels, both with maximum 1. The full graph still differs along rows 0 and 47 with a flat input. + +For an independent mip-level check, generate a 128² RGBA grid using the row-major unsigned hash from the gradient probe. Use the low 8 or 16 bits of the final hash for each integer channel. For a signed float input store `4*hash/2^32-2` in float32. Run an identity transform at 128², 64², 32² and 16². With automatic mip selection, both RGBA8-to-RGBA8 and RGBA16-to-RGBA16 match 21,760/21,760 pixels with zero error. For RGBA8 input and output, setting the manual mip level to 0, 1 or 2 also gives 21,760/21,760 at each level. An automatic uniform scale of 1.5 gives the same exact count. For the signed RGBA32F input and output, the four sizes match 16,384, 2,781, 308 and 29 pixels respectively, with maxima 0, 1.192093e-7, 5.960464e-8 and 2.980232e-8. Float filtering remains open. + +### 3D volume mask and Worley noise + +Use the first-pass linear position texture. For side `N`, store RGBA8 `(floor(255*x/(N-1)),floor(255*y/(N-1)),128,255)`. The mask's rotated case uses box shape 1, rotation `(.1,.2,.3)`, size `(.8,.6,1)` and feather width .1. The Worley border case sets style 1, border width .2 and roundness .1. For its 64² output-format sweep, round the two position channels to nearest instead of flooring. Each cell gives exact pixels / total (maximum error). + +| Case | Volume mask | Worley noise | +|---|---:|---:| +| 128², defaults, seed 0, LUM16 | 16,384/16,384 (0) | 1/16,384 (44,494) | +| 256², defaults, seed 0, LUM16 | 65,536/65,536 (0) | 3/65,536 (44,494) | +| 128², defaults, seed 42, LUM16 | 16,384/16,384 (0) | 1/16,384 (43,865) | +| 128², scale .4 for mask or 6 for Worley, seed 0, LUM16 | 16,384/16,384 (0) | 2/16,384 (40,476) | +| 128², rotated mask or Worley border, seed 0, LUM16 | 16,326/16,384 (1) | 1/16,384 (32,729) | +| Same settings, seed 42, LUM8 (mask 128², Worley 64²) | 16,383/16,384 (1) | 45/4,096 (138) | +| Same sizes and seed, LUM16 | 16,326/16,384 (1) | 0/4,096 (35,289) | +| Same sizes and seed, LUM16F | 16,349/16,384 (.0078125) | 4/4,096 (.53833008) | +| Same sizes and seed, LUM32F | 664/16,384 (.000015258789) | 0/4,096 (.53847277) | + +**Mask.** The 128² box with default rotation, size and feathering gives 16,379/16,384 exact LUM16 pixels, with maximum error 1. The RGBA16 position bridge matches all 16,384 pixels. In LUM32F, changing only box rotation gives 564/16,384 (1.907349e-6), only size gives 14,088/16,384 (9.536743e-7), and only feather width gives 13,716/16,384 (3.814697e-6). A sphere with `position_input=1` and `position_worldspace=(.375,.375,.5)` matches 16,384/16,384 float pixels exactly. + +**Worley.** With a constant input position of `(0,0,0,255)`, no LUM32F pixel matches in the 32² default case at seed 0 (maximum .02120566) or seed 42 (.07068205). The graph's internal random table uses four draws. A standalone Pixel Processor writing four successive `rand(1)` values to RGBA16 reproduces a discrepancy before any cell-distance calculation. It gives 0/1,024 exact pixels at 32², seed 0 (maximum 65,122), 0/16,384 at 128², seed 0 (65,136), and 0/16,384 at 128², seed 42 (65,348). At seed 0 the first reference pixel changes with resolution, from `(47238,35719,5497,27913)` to `(37730,56747,64327,4184)`. MaterialCraft returns `(42015,40251,56435,61318)` at both sizes. The random sequence and any residual differences in the distance calculation remain open. + ### November 17 validation -All four new regressions failed with the corresponding behavior disabled or absent. The full release node suite passed all 108 tests. Workspace formatting, strict all-target Clippy, dependency layers and WebAssembly checks passed. Raw captures and generated input images were kept outside the repository. +All six new regression tests failed with their corresponding fixes disabled or absent. The release suites for nodes, evaluation and formats passed 246 tests. Two opt-in format interoperability tests were skipped. Workspace formatting, strict all-target Clippy, dependency layers and WebAssembly checks passed. Raw captures and generated input images were kept outside the repository. ## Remaining differences diff --git a/docs/sbs-root-nodes.md b/docs/sbs-root-nodes.md index 340d57c..0ac9581 100644 --- a/docs/sbs-root-nodes.md +++ b/docs/sbs-root-nodes.md @@ -35,7 +35,7 @@ A graph may accept input pins and still be a root under the dependency criterion Statuses: **Not checked**, **In progress**, **Parity** (exact pixels or typed values for the linked measured cases), or **Too hard** (reason recorded). Function calls do not count as regular graph dependencies. -The first pass covered all **546 roots**, with **166 Parity** and **380 Too hard**. The current inventory has **167 Parity**, **9 In progress** and **370 Too hard**. Exact counts, output formats and remaining differences for the revisited roots are in the [November 17 comparisons](parity-fixes.md#2026-11-17-root-comparisons). +The first pass covered all **546 roots**, with **166 Parity** and **380 Too hard**. The current inventory has **167 Parity**, **12 In progress** and **367 Too hard**. The November 17 pass revisited every unresolved root through `3D_worley_noise`. The next unresolved root in inventory order is `alveolus.sbs/alveolus`. See the [November 17 comparisons](parity-fixes.md#2026-11-17-root-comparisons) for exact counts, output formats and remaining differences. ## Complete inventory @@ -57,9 +57,9 @@ The first pass covered all **546 roots**, with **166 Parity** and **380 Too hard | [3d_texture_render.sbs/position_debug](../assets/sbs/3d_texture_render.sbs) | 2 | Yes | [Parity · 14 sphere and plane cases](parity-fixes.md#position-debug) | | [3d_texture_transform.sbs/3d_texture_offset_color](../assets/sbs/3d_texture_transform.sbs) | 1 | No | [Parity: 5 cases](parity-fixes.md#verified-cases) | | [3d_texture_transform.sbs/3d_texture_offset_grayscale](../assets/sbs/3d_texture_transform.sbs) | 1 | No | [Parity: 4 cases](parity-fixes.md#verified-cases) | -| [3d_viewer.sbs/ibl_specular_contrib_anisotropic/panoramic_lod](../assets/sbs/3d_viewer.sbs) | 1 | Yes | [Too hard: transform filtering](parity-fixes.md#remaining-differences) | -| [3d_volume_mask.sbs/3d_volume_mask](../assets/sbs/3d_volume_mask.sbs) | 1 | No | [Too hard: 62 pixels remain](parity-fixes.md#remaining-differences) | -| [3d_worley_noise.sbs/3D_worley_noise](../assets/sbs/3d_worley_noise.sbs) | 1 | No | [Too hard: noise field mismatch](parity-fixes.md#remaining-differences) | +| [3d_viewer.sbs/ibl_specular_contrib_anisotropic/panoramic_lod](../assets/sbs/3d_viewer.sbs) | 1 | Yes | [In progress · input resizing and transform filtering measured](parity-fixes.md#panoramic-lod) | +| [3d_volume_mask.sbs/3d_volume_mask](../assets/sbs/3d_volume_mask.sbs) | 1 | No | [In progress · box rotation and feathering differ](parity-fixes.md#3d-volume-mask-and-worley-noise) | +| [3d_worley_noise.sbs/3D_worley_noise](../assets/sbs/3d_worley_noise.sbs) | 1 | No | [In progress · random sequence differs before distance evaluation](parity-fixes.md#3d-volume-mask-and-worley-noise) | | [alveolus.sbs/alveolus](../assets/sbs/alveolus.sbs) | 0 | Yes | [Too hard: cell field mismatch](parity-fixes.md#remaining-differences) | | [angle_to_vector.sbs/angle_to_vector](../assets/sbs/angle_to_vector.sbs) | 1 | No | [Parity: 4 cases](parity-fixes.md#verified-cases) | | [anisotropic_blur.sbs/anisotropic_blur](../assets/sbs/anisotropic_blur.sbs) | 1 | No | [Too hard: blur kernel](parity-fixes.md#remaining-differences) |