diff --git a/crates/formats/src/sbs/filter_map.rs b/crates/formats/src/sbs/filter_map.rs
index 052b705..15d2f1e 100644
--- a/crates/formats/src/sbs/filter_map.rs
+++ b/crates/formats/src/sbs/filter_map.rs
@@ -46,7 +46,12 @@ pub(super) const FILTERS: &[FilterMap] = &[
inputs: &[("input1", "input"), ("input2", "gradient"), ("inputgradient", "gradient")],
params: &[("coordinate", "position"), ("uvselector", "orientation")],
},
- FilterMap { sbs: "gradient", def: "gradient_map", inputs: &[("input1", "input")], params: &[("colorswitch", "color_mode")] },
+ FilterMap {
+ sbs: "gradient",
+ def: "gradient_map",
+ inputs: &[("input1", "input")],
+ params: &[("colorswitch", "color_mode"), ("interpmode", "interpolation")],
+ },
FilterMap {
sbs: "grayscaleconversion",
def: "grayscale_conversion",
diff --git a/crates/formats/src/sbs/parameter_array.rs b/crates/formats/src/sbs/parameter_array.rs
index e38f2f5..d7d1396 100644
--- a/crates/formats/src/sbs/parameter_array.rs
+++ b/crates/formats/src/sbs/parameter_array.rs
@@ -31,11 +31,9 @@ pub(super) fn read(node: &mut Node, implementation: XmlNode<'_, '_>) {
Some(value) => value.as_vec4().unwrap_or([0.0; 4]),
None => [0.0; 4],
};
- let midpoint = parameters.get("midpoint").and_then(Value::as_f32).unwrap_or(0.5);
-
- // Legacy gradient arrays use zero for their default linear segments
- // Treating it as a near-zero interpolation fraction clips successive ramps to white
- let midpoint = if midpoint == 0.0 { 0.5 } else { midpoint };
+ // SBS stores a signed bias. The document uses a centered 0..1 control.
+ let bias = parameters.get("midpoint").and_then(Value::as_f32).unwrap_or(0.0);
+ let midpoint = 0.5 + 0.5 * bias.clamp(-1.0, 1.0);
gradient.keys.push(GradientKey { pos: position, color, midpoint });
}
_ => {}
@@ -94,7 +92,7 @@ pub(super) fn write(value: &Value, color_mode: bool, writer: &mut SbsWriter) ->
Value::Gradient(gradient) => {
for key in &gradient.keys {
let color = if color_mode { Value::Color(key.color) } else { Value::Float(craft_texture::luminance(key.color)) };
- cell(vec![("position", Value::Float(key.pos)), ("midpoint", Value::Float(key.midpoint)), ("value", color)]);
+ cell(vec![("position", Value::Float(key.pos)), ("midpoint", Value::Float(2.0 * key.midpoint - 1.0)), ("value", color)]);
}
}
_ => {}
diff --git a/crates/formats/tests/gradient_values.rs b/crates/formats/tests/gradient_values.rs
index 14186ad..f1d85be 100644
--- a/crates/formats/tests/gradient_values.rs
+++ b/crates/formats/tests/gradient_values.rs
@@ -55,3 +55,24 @@ fn native_gradient_default_midpoints_are_linear_and_components_are_preserved() {
}
}
}
+
+#[test]
+fn smooth_gradient_signed_bias_survives_sbs_round_trip() {
+ let xml = br#"
+
+
+
+
+
+
+ "#;
+ let mut read = read_sbs(xml, "ramp.sbs", &|_| None).unwrap();
+ for _ in 0..2 {
+ let params = &read.pkg.graphs[0].nodes[0].params;
+ assert_eq!(params["interpolation"].as_i32(), Some(1));
+ let Value::Gradient(gradient) = ¶ms["gradient"] else { panic!("missing gradient") };
+ assert_eq!(gradient.keys[0].midpoint, 0.3125);
+ let saved = write_sbs(&read.pkg).unwrap();
+ read = read_sbs(&saved, "ramp.sbs", &|_| None).unwrap();
+ }
+}
diff --git a/crates/nodes/src/atomic/gradient_map.rs b/crates/nodes/src/atomic/gradient_map.rs
index 413047e..23398ef 100644
--- a/crates/nodes/src/atomic/gradient_map.rs
+++ b/crates/nodes/src/atomic/gradient_map.rs
@@ -1,6 +1,6 @@
use super::ATOMIC;
-use crate::{CookContext, CookResult, NodeDefinition, node};
-use craft_texture::{Kind, luminance};
+use crate::{CookContext, CookResult, NodeDefinition, node, texture_sampler};
+use craft_texture::{Image, Kind, Limits, luminance};
use materialcraft_core::{Gradient, OutputFormat};
pub(super) fn definition() -> NodeDefinition {
@@ -9,6 +9,7 @@ pub(super) fn definition() -> NodeDefinition {
.atomic()
.gray_in("input", "Input")
.gradient("gradient", "Gradient", Gradient::default())
+ .choice("interpolation", "Interpolation", &["Linear", "Smooth"], 0)
.boolean("color_mode", "Color output", true)
.any_out()
.cook(gradient_map)
@@ -16,39 +17,70 @@ pub(super) fn definition() -> NodeDefinition {
fn gradient_map(context: &CookContext) -> CookResult {
let input = context.gray_or(0, 0.0);
- let gradient = context.gradient("gradient");
- if matches!(context.format, OutputFormat::Inherit | OutputFormat::U16) {
- return Ok(vec![integer_map(&input, gradient, !context.b("color_mode"))]);
- }
-
- const LOOKUP_INTERVALS: usize = 512;
- let lookup_table: Vec<[f32; 4]> = (0..=LOOKUP_INTERVALS).map(|index| gradient.eval(index as f32 / LOOKUP_INTERVALS as f32)).collect();
+ let table = lookup_table(context.gradient("gradient"), context.i("interpolation") == 1, context.format)?;
+ let width = table.width() as f32;
let gray = !context.b("color_mode");
- let look = |v: f32| lookup_table.get((v.clamp(0.0, 1.0) * LOOKUP_INTERVALS as f32).round() as usize).copied().unwrap_or([0.0, 0.0, 0.0, 1.0]);
- Ok(vec![if gray { input.map(Kind::Gray, |p| [luminance(look(p[0])), 0.0, 0.0, 0.0]) } else { input.map(Kind::Color, |p| look(p[0])) }])
+ let kind = if gray { Kind::Gray } else { Kind::Color };
+ Ok(vec![input.map(kind, |p| {
+ let u = (p[0].clamp(0.0, 1.0) * (width - 1.0) + 0.5) / width;
+ let color = texture_sampler::sample(&table, [u, 0.5], [false; 2], OutputFormat::F32, None);
+ if gray && (color[0] != color[1] || color[1] != color[2]) { [luminance(color); 4] } else { color }
+ })])
}
-fn integer_map(input: &craft_texture::Image, mut gradient: Gradient, gray: bool) -> craft_texture::Image {
- // The 16-bit path evaluates a 256-entry table in integer position space
- // Coarse nearest sampling shifts transitions and downstream noise octaves
+fn lookup_table(mut gradient: Gradient, smooth: bool, format: OutputFormat) -> Result {
+ let levels = match format {
+ OutputFormat::U8 => Some(255.0),
+ OutputFormat::Inherit | OutputFormat::U16 => Some(65535.0),
+ OutputFormat::F16 | OutputFormat::F32 => None,
+ };
+ let width = if levels.is_some() { 256 } else { 1024 };
+ let last_index = (width - 1) as f32;
+ gradient.keys.retain(|key| key.pos.is_finite());
+ if gradient.keys.is_empty() {
+ gradient = Gradient::default();
+ }
+ gradient.sort();
for key in &mut gradient.keys {
- key.pos = (key.pos.clamp(0.0, 1.0) * 65535.0).round();
+ let position = key.pos.clamp(0.0, 1.0);
+ key.pos = if levels.is_some() { (position * 65535.0).round() / 257.0 } else { position * last_index };
+ if levels.is_some() {
+ // Integer ramp stops store byte colors even when the output uses 16 bits.
+ key.color = key.color.map(|v| (v.clamp(0.0, 1.0) * 255.0).round() / 255.0);
+ }
}
- let table: Vec<[u32; 4]> =
- (0..256).map(|index| gradient.eval(index as f32 * 257.0).map(|value| (value.clamp(0.0, 1.0) * 65535.0).round() as u32)).collect();
- let lookup = |value: f32| {
- let value = if value.is_finite() { value.clamp(0.0, 1.0) } else { 0.0 };
-
- // Half-texel conversion before eight-bit weights preserves ramp rounding
- let position = (value * 255.0 + 0.5) - 0.5;
- let fixed = (position * 256.0).round() as usize;
- let index = fixed / 256;
- let weight = (fixed % 256) as u32;
- let left = table.get(index).copied().unwrap_or([0; 4]);
- let right = table.get(index.saturating_add(1)).copied().unwrap_or(left);
- std::array::from_fn(|channel| ((left[channel] * (256 - weight) + right[channel] * weight + 128) >> 8) as f32 / 65535.0)
- };
-
- if gray { input.map(Kind::Gray, |pixel| [luminance(lookup(pixel[0])), 0.0, 0.0, 0.0]) } else { input.map(Kind::Color, |pixel| lookup(pixel[0])) }
+ let mut entries = vec![gradient.keys.last().map_or([0.0; 4], |key| key.color); width];
+ if let Some(first) = gradient.keys.first() {
+ entries.iter_mut().take(first.pos.ceil() as usize).for_each(|v| *v = first.color);
+ }
+ for pair in gradient.keys.windows(2) {
+ let [left, right] = pair else { continue };
+ let first = left.pos.ceil() as usize;
+ let end = right.pos.ceil() as usize;
+ let Some(segment) = entries.get_mut(first..end).filter(|s| !s.is_empty()) else { continue };
+ let step = (right.pos - left.pos).recip();
+ let mut t = (first as f32 - left.pos) * step;
+ let delta: [f32; 4] = std::array::from_fn(|c| right.color[c] - left.color[c]);
+ if smooth {
+ let bias = 2.0 * left.midpoint - 1.0;
+ for entry in segment {
+ let u = t * (1.0 - bias * (1.0 - t));
+ let weight = u * u * (3.0 - 2.0 * u);
+ *entry = std::array::from_fn(|c| left.color[c] + delta[c] * weight);
+ // Each addition rounds at the table's working precision.
+ t += step;
+ }
+ } else {
+ let base: [f32; 4] = std::array::from_fn(|c| left.color[c] + delta[c] * t);
+ let slope = delta.map(|d| d * step);
+ for (i, entry) in segment.iter_mut().enumerate() {
+ *entry = std::array::from_fn(|c| base[c] + slope[c] * i as f32);
+ }
+ }
+ }
+ let data: Vec = entries.into_iter().flatten().map(|v| levels.map_or(v, |max| (v * max).round() / max)).collect();
+ Image::from_data(width as u32, 1, Kind::Color, data, &Limits::default())
+ .map(|image| image.with_integer_sampling(levels.is_some()))
+ .map_err(|err| err.to_string())
}
diff --git a/crates/nodes/tests/atomic_filter_parity.rs b/crates/nodes/tests/atomic_filter_parity.rs
index 65dad3b..36b8fc7 100644
--- a/crates/nodes/tests/atomic_filter_parity.rs
+++ b/crates/nodes/tests/atomic_filter_parity.rs
@@ -1,5 +1,5 @@
use craft_texture::{Image, Kind};
-use materialcraft_core::{OutputFormat, Value};
+use materialcraft_core::{Gradient, GradientKey, OutputFormat, Value};
use materialcraft_nodes::{CookContext, find, resolve_params};
use std::collections::BTreeMap;
@@ -24,6 +24,26 @@ fn cook(id: &str, inputs: &[Option], values: &[(&str, Value)], size: [u32
(definition.cook)(&context).unwrap().remove(0)
}
+#[test]
+fn gradient_filter_preserves_linear_and_biased_smooth_segments() {
+ let input = Image::gray(1, 1, |_, _| f32::from_bits(0x3e414c15));
+ let keys = vec![
+ GradientKey::new(0.0625, [0.1875, 0.25, 0.4375, 0.8125]),
+ GradientKey::new(0.34375, [0.59375, 0.9375, 0.3125, 0.5625]),
+ GradientKey::new(0.890625, [0.8125, 0.125, 0.75, 0.375]),
+ ];
+ let params = [("gradient", Value::Gradient(Gradient { keys }))];
+ let output = cook("gradient_map", &[Some(input)], ¶ms, [1, 1], false);
+ assert_eq!(output.get(0, 0, false).map(f32::to_bits), [0x3ebd61ca, 0x3f0f03fb, 0x3ec34460, 0x3f334460]);
+
+ let mut gradient = Gradient::default();
+ gradient.keys[0].midpoint = 0.625;
+ let step = Image::gray(1, 1, |_, _| 64.0 / 255.0);
+ let params = [("gradient", Value::Gradient(gradient)), ("interpolation", Value::Enum(1))];
+ let output = cook("gradient_map", &[Some(step)], ¶ms, [1, 1], false);
+ assert_eq!(output.get(0, 0, false).map(f32::to_bits), [0x3ddce217, 0x3ddce217, 0x3ddce217, 0x3f800000]);
+}
+
#[test]
fn shuffle_reads_grayscale_from_every_selected_channel() {
let inputs = [Some(Image::filled(3, 5, Kind::Gray, [0.25; 4])), Some(Image::filled(3, 5, Kind::Gray, [0.75; 4]))];
diff --git a/docs/parity-fixes.md b/docs/parity-fixes.md
index e439cfd..32b26de 100644
--- a/docs/parity-fixes.md
+++ b/docs/parity-fixes.md
@@ -253,6 +253,27 @@ Literal-only pixel graphs at 16², seed 23, give 512/768 exact pixels for each l
The shared-lookup ridged root still matches 5,160/16,384 at changed roughness in F32, maximum 1.78813934e−7. Its one-octave .7 control still matches 1,847/4,096, maximum 2.38418579e−7. For positive normal x on the signed field, the reference's general power agrees with exp(y×ln(x)) on all 32,614 pixels. On .7 with exponent 1 it returns `3f333334`. Further work on general power and natural exponential is tracked with the [octave controls](#ridged-noise-octave-isolation).
+### Gradient interpolation, color blend and chrominance
+
+The **color blend** and **chrominance extract** roots each match **171,264/171,264 pixels in 18 cases**, maximum error zero. The original four cases account for 114,688 pixels per root. The four 64² output formats at seed 42 and the independent 32² F32 case account for 17,408. Repeat the nine [original color input cases](#color-burn-and-color-dodge) for a further 39,168. Color blend uses the same foreground, background and mask with opacity .375 in the 16², 128² and signed cases and .8125 elsewhere. Chrominance takes only the original foreground. Before the fix the independent color blend matched 1,021/1,024 pixels, maximum .00676953793. Seven of its grayscale-to-color gradient pixels differed by up to 23 byte levels. The incoming scalar image matched in full.
+
+Gradient Map now reads and writes the interpolation setting and signed midpoint bias. Linear and smooth gradients sample a 1,024-entry float table in F16 and F32 and a 256-entry integer table in U8 and U16. In a smooth segment the fractional position advances by one rounded add per entry. For fractional position t and signed bias b on the left stop, evaluate u=t×(1−b×(1−t)), then u²×(3−2u). Float texture filtering and final storage use the existing precision paths.
+
+| Gradient table controls | Cases | Exact pixels / compared | Maximum stored-component error |
+|---|---:|---:|---:|
+| U8 | 36 | 1,325,806/1,327,104 | 1 |
+| U16 | 36 | 1,238,928/1,327,104 | 1 |
+| F16 | 36 | 1,327,104/1,327,104 | 0 |
+| F32 | 48 | 1,376,256/1,376,256 | 0 |
+
+For the unit ramp, use positions 0 and 1, black and white RGB, and alpha .25 and .75. For a short ramp use positions 0 and .125, colors (0,0,0,1) and (.875,.75,.5,1). For a three-stop ramp use positions (.0625,.34375,.890625) with RGBA (.1875,.25,.4375,.8125), (.59375,.9375,.3125,.5625), (.8125,.125,.75,.375). All three use zero midpoint bias. The fourth ramp uses black and white with alpha one and signed biases .25 and .75. For omitted, linear and smooth interpolation, feed x/255 across a 256² F32 image at seed 17 in each output format. Also feed ((13x+71y+5xy) mod 4096)/4095 at 64², seed 83, F32 output. With explicit linear and smooth interpolation, use a linear pixel index i and inputs (i mod (d+1))/d. Use d=255 and 1,023 at 32², d=65,535 at 256², seed 103 and all four output formats.
+
+Additional controls still differ. A four-stop signed/HDR field with positions (.093,.41327,.77777,.812) gives 127,009/135,168 exact F32 pixels, maximum 7.15255737e−7 across linear and smooth modes. Use biases (−.4375,.1875,−.375,0) and colors (−.25,.75,1.25,.25), (2,−.875,.375,1), (.875,.25,−.0625,.625), (.375,1.5,.625,.375). Repeating the middle position in a separate (.125,.5,.5,.75) ramp gives 101,217/135,168 exact F32 pixels, maximum .687494829. The reference uses the first stop at the repeated position for the following segment. An isolated grayscale fixture using the `gradientluminance` array produced an identity ramp in the reference app and the authored ramp in MaterialCraft. The accepted grayscale key representation still needs validation.
+
+For **color to mask**, the four 64² changed formats each match 4,074/4,096 pixels. Maxima are 255, 65,535, 1 and 1 in format order. The 32² F32 case matches 1,018/1,024, maximum 1. On the changed F32 case the first differing primitive is the grayscale conversion. The imported graph uses default thirds for its function-valued (.299,.587,.114,0) weights.
+
+The **grayscale HDR range viewer** matches all 114,688 original pixels and all 17,408 four-format and independent pixels. For a signed input use (((31x+83y+7xy) mod 1024)−389)/93. Replace the first column with successive repetitions of (low,high,0,1). At 64²/seed 73 with range (−.75,2.25), each of the four formats matches 2,541/4,096, with maxima 255, 65,535, 1 and 1. Additional F32 cases at 16²/19 with (−1.5,.75), 128²/199 with (−3,6), 32×16 input at 32²/181 with (−.1875,.375), 32²/47 with (1.25,4.25) and 16²/311 with (.125,.1875) bring the signed total to 21,956/35,328. The first differing primitive is an inverted Levels node with intermediate clamping disabled. At 64² its LUM32F result matches 262/4,096, maximum 5.81720495.
+
### Color temperature, range reductions, sky parameters and polygon paths
The four roots below match every recorded case. Both the first-pass defaults and the [four-format and independent comparisons](#four-format-inventory-comparison) were replayed with their original procedural inputs. Typed results include a float32 bit comparison for every component.
diff --git a/docs/sbs-root-nodes.md b/docs/sbs-root-nodes.md
index 44b5573..f560550 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 **212 Parity**, **25 In progress** and **309 Too hard**. The November 17 and 18 comparisons include raw counts, output formats and remaining differences. [November 17 measurements](parity-fixes.md#2026-11-17-root-comparisons) · [November 18 measurements](parity-fixes.md#2026-11-18-root-comparisons)
+The first pass covered all **546 roots**, with **166 Parity** and **380 Too hard**. The current inventory has **214 Parity**, **27 In progress** and **305 Too hard**. The November 17 and 18 comparisons include raw counts, output formats and remaining differences. [November 17 measurements](parity-fixes.md#2026-11-17-root-comparisons) · [November 18 measurements](parity-fixes.md#2026-11-18-root-comparisons)
[Grayscale sampler measurements](parity-fixes.md#grayscale-sampling-of-color-inputs) · [Value sampling across 240 typed comparisons](parity-fixes.md#value-processor-texture-filtering)
@@ -83,7 +83,7 @@ The first pass covered all **546 roots**, with **166 Parity** and **380 Too hard
| [blackbody.sbs/blackbody](../assets/sbs/blackbody.sbs) | 0 | No | [Too hard: float rounding](parity-fixes.md#remaining-differences) |
| [blend.sbs/add](../assets/sbs/blend.sbs) | 3 | Yes | [Parity: 5 cases](parity-fixes.md#verified-cases) |
| [blend.sbs/add_sub](../assets/sbs/blend.sbs) | 3 | Yes | [Parity: 4 cases](parity-fixes.md#verified-cases) |
-| [blend.sbs/color](../assets/sbs/blend.sbs) | 3 | No | [Too hard: color conversion](parity-fixes.md#remaining-differences) |
+| [blend.sbs/color](../assets/sbs/blend.sbs) | 3 | No | [Parity · 18 cases, 171,264 exact pixels](parity-fixes.md#gradient-interpolation-color-blend-and-chrominance) |
| [blend.sbs/color_burn](../assets/sbs/blend.sbs) | 3 | No | [Parity · 18 cases, 171,264 exact RGBA pixels](parity-fixes.md#color-burn-and-color-dodge) |
| [blend.sbs/color_dodge](../assets/sbs/blend.sbs) | 3 | No | [Parity · 18 cases, 171,264 exact RGBA pixels](parity-fixes.md#color-burn-and-color-dodge) |
| [blend.sbs/copy](../assets/sbs/blend.sbs) | 3 | Yes | [Parity: 5 cases](parity-fixes.md#verified-cases) |
@@ -120,7 +120,7 @@ The first pass covered all **546 roots**, with **166 Parity** and **380 Too hard
| [channel_mixer.sbs/channel_mixer](../assets/sbs/channel_mixer.sbs) | 1 | No | [Too hard: function parameter output](parity-fixes.md#remaining-differences) |
| [checker_1.sbs/checker_1](../assets/sbs/checker_1.sbs) | 0 | Yes | [Parity · eight cases, four formats](parity-fixes.md#transform-edges-and-floating-point-filtering) |
| [checker_2.sbs/checker_2](../assets/sbs/checker_2.sbs) | 0 | Yes | [Parity: 4 cases](parity-fixes.md#verified-cases) |
-| [chrominance_extract.sbs/chrominance_extract](../assets/sbs/chrominance_extract.sbs) | 1 | No | [Too hard: remaining pixel differences](parity-fixes.md#remaining-differences) |
+| [chrominance_extract.sbs/chrominance_extract](../assets/sbs/chrominance_extract.sbs) | 1 | No | [Parity · 18 cases, 171,264 exact pixels](parity-fixes.md#gradient-interpolation-color-blend-and-chrominance) |
| [clamp.sbs/clamp](../assets/sbs/clamp.sbs) | 1 | No | [Parity: 4 cases](parity-fixes.md#verified-cases) |
| [clamp.sbs/clamp_grayscale](../assets/sbs/clamp.sbs) | 1 | No | [Parity: 4 cases](parity-fixes.md#verified-cases) |
| [clone.sbs/clone](../assets/sbs/clone.sbs) | 2 | No | [Parity · eight cases, four formats](parity-fixes.md#clone-mask-and-alpha-rounding) |
@@ -138,7 +138,7 @@ The first pass covered all **546 roots**, with **166 Parity** and **380 Too hard
| [color_space_conversion.sbs/srgb_to_linear_srgb](../assets/sbs/color_space_conversion.sbs) | 1 | No | [Parity: 4 cases](parity-fixes.md#verified-cases) |
| [color_space_conversion.sbs/srgb_to_linear_srgb_grayscale](../assets/sbs/color_space_conversion.sbs) | 1 | No | [Parity: 4 cases](parity-fixes.md#verified-cases) |
| [color_temperature_adjustment.sbs/color_temperature_adjustment](../assets/sbs/color_temperature_adjustment.sbs) | 1 | No | [Parity · 18 cases, 171,264 exact RGBA pixels](parity-fixes.md#color-temperature-range-reductions-sky-parameters-and-polygon-paths) |
-| [color_to_mask.sbs/color_to_mask](../assets/sbs/color_to_mask.sbs) | 1 | Yes | [Too hard: remaining pixel differences](parity-fixes.md#remaining-differences) |
+| [color_to_mask.sbs/color_to_mask](../assets/sbs/color_to_mask.sbs) | 1 | Yes | [In progress · function-valued grayscale weights differ](parity-fixes.md#gradient-interpolation-color-blend-and-chrominance) |
| [color_to_mask_v2.sbs/color_to_mask](../assets/sbs/color_to_mask_v2.sbs) | 2 | No | [Too hard: 1 pixel remains](parity-fixes.md#remaining-differences) |
| [composite.sbs/composite/background/uniform_color_float3](../assets/sbs/composite.sbs) | 0 | Yes | [Parity: 4 cases](parity-fixes.md#verified-cases) |
| [composite.sbs/composite/blends/blend_content](../assets/sbs/composite.sbs) | 3 | Yes | [Too hard: pixel differences](parity-fixes.md#remaining-differences) |
@@ -229,7 +229,7 @@ The first pass covered all **546 roots**, with **166 Parity** and **380 Too hard
| [hbao_2.sbs/hbao_subsample](../assets/sbs/hbao_2.sbs) | 2 | Yes | [Too hard: remaining pixel differences](parity-fixes.md#remaining-differences) |
| [hdr_exposure_preview.sbs/hdr_exposure_preview](../assets/sbs/hdr_exposure_preview.sbs) | 1 | No | [Parity: 4 cases](parity-fixes.md#verified-cases) |
| [hdr_merge.sbs/average_luminance_merge](../assets/sbs/hdr_merge.sbs) | 1 | Yes | [Parity · 15 cases, 165,120 exact pixels](parity-fixes.md#luminosity-axial-gradients-color-lookup-and-luminance-merge) |
-| [hdr_range_viewer.sbs/hdr_range_viewer_grayscale](../assets/sbs/hdr_range_viewer.sbs) | 1 | No | [Too hard: remaining pixel differences](parity-fixes.md#remaining-differences) |
+| [hdr_range_viewer.sbs/hdr_range_viewer_grayscale](../assets/sbs/hdr_range_viewer.sbs) | 1 | No | [In progress · signed input exposes intermediate Levels clamping](parity-fixes.md#gradient-interpolation-color-blend-and-chrominance) |
| [height_blend.sbs/height_blend](../assets/sbs/height_blend.sbs) | 3 | No | [Too hard: remaining pixel differences](parity-fixes.md#remaining-differences) |
| [height_extrude.sbs/impl/acceleration_struct_impl](../assets/sbs/height_extrude.sbs) | 1 | Yes | [Parity: 4 cases](parity-fixes.md#verified-cases) |
| [height_to_normal_world_units.sbs/height_to_normal_world_units](../assets/sbs/height_to_normal_world_units.sbs) | 1 | Yes | [Parity · eight cases in four formats](parity-fixes.md#height-to-normal-in-world-units) |