Give the tone curve a curve for each colour channel

The declaration in ops/tone_curve.yaml has claimed per-channel curves since
it was written — it is the justification for the operation carrying both
`tone` and `colour`. Only the master curve existed. This is the other three.

The master runs first and the channels grade its result. Both orders are
real images and they differ visibly, so the choice is made and written down
rather than left to the loop: a point placed on the blue curve should act on
the tone the photographer can see, which is what the master has already
produced. The other order anchors the grade to tones the master is about to
move, so adjusting contrast slides a warm shadow up into the midtones.

Every id that existed before today is spelled exactly as it was. The master
curve keeps `p2_y` and the new curves take `r_`, `g_` and `b_` prefixes, so
a sidecar written when there was one curve loads, means what it meant, and
renders the same shader — asserted on the generated source, not on the
parameter values. Nothing needed a version check because nothing was
renamed.

Each curve reaches the shader only when it has been moved off the diagonal,
so an S-curve and no colour work generates what it generated when this
operation held ten parameters instead of forty, down to the uniform names.
The monotonicity guarantee is enforced per curve: a coincident pair on blue
divides by zero exactly as thoroughly as one on the master.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

core/dr-gpu/tests/tone_curve.rs

@@ -0,0 +1,139 @@
+//! TRACES: FR-DEV-3
+//! The tone curve's four curves, on a device.
+//!
+//! `dr-pipeline` asserts that the right WGSL is generated and `dr-gpu`'s other
+//! tests assert that a shader runs; neither notices a fragment that says
+//! exactly what it should and does not compile, or one that compiles and puts
+//! the red curve's uniforms into the blue slot. So this renders flat grey
+//! through each curve and looks at what came out.
+//!
+//! Flat grey because it makes every assertion a comparison between the three
+//! components of one pixel: a curve that is meant to be chromatic must move
+//! them apart, and one that is meant to be tonal must not.
+
+use dr_gpu::{AdjustPass, DemosaicedImage, GpuContext};
+use dr_pipeline::ops::curve::{self, Axis, Channel};
+use dr_pipeline::EditGraph;
+
+const SIZE: u32 = 8;
+
+fn ctx() -> Option<GpuContext> {
+    pollster::block_on(GpuContext::new_headless()).ok()
+}
+
+/// The centre pixel's red, green and blue, after `graph` has run over flat
+/// mid-grey.
+fn rendered(ctx: &GpuContext, graph: &EditGraph) -> (u8, u8, u8) {
+    let data: Vec<u8> = (0..SIZE * SIZE).flat_map(|_| [128, 128, 128, 255]).collect();
+    let source = DemosaicedImage::from_rgba8(ctx, &data, SIZE, SIZE).expect("upload");
+
+    // Composed the way the display path composes it. A curve that generates
+    // invalid WGSL fails at `render` below, which is the point of running this
+    // on a device at all.
+    let shader = graph.compose();
+
+    let mut adjust = AdjustPass::new(ctx);
+    adjust.render(&source, &shader, SIZE, SIZE).expect("render");
+    let pixels = adjust.export_pixels().expect("readback").0;
+
+    let at = ((SIZE / 2 * SIZE + SIZE / 2) * 4) as usize;
+    (pixels[at], pixels[at + 1], pixels[at + 2])
+}
+
+/// A curve with its mid-point lifted — the simplest edit that is unmistakably
+/// an edit.
+fn lifted(channel: Channel) -> EditGraph {
+    let mut graph = EditGraph::default_chain();
+    graph.set_param(
+        curve::ID,
+        curve::coordinate(channel, 2, Axis::Y),
+        0.75,
+    );
+    graph
+}
+
+#[test]
+fn the_master_curve_lifts_every_component_together() {
+    let Some(ctx) = ctx() else {
+        eprintln!("no adapter; skipping");
+        return;
+    };
+
+    let (r0, g0, b0) = rendered(&ctx, &EditGraph::default_chain());
+    let (r, g, b) = rendered(&ctx, &lifted(Channel::Master));
+
+    assert!(r > r0, "the master curve did not lift the image: {r} vs {r0}");
+    // Grey in, grey out: the master curve is applied as a ratio over
+    // luminance, so it changes tone and not hue. A tolerance of one code
+    // value, because the components travel through the ratio separately and
+    // the result is quantised to eight bits.
+    assert!(
+        r.abs_diff(g) <= 1 && g.abs_diff(b) <= 1,
+        "the master curve tinted a neutral pixel: {r},{g},{b}"
+    );
+    assert_eq!((g0, b0), (r0, r0), "the unedited image is neutral");
+}
+
+#[test]
+fn a_channel_curve_lifts_only_its_own_component() {
+    let Some(ctx) = ctx() else {
+        eprintln!("no adapter; skipping");
+        return;
+    };
+
+    let (r0, g0, b0) = rendered(&ctx, &EditGraph::default_chain());
+    for (channel, name) in [
+        (Channel::Red, "red"),
+        (Channel::Green, "green"),
+        (Channel::Blue, "blue"),
+    ] {
+        let (r, g, b) = rendered(&ctx, &lifted(channel));
+        // The component the curve names moves; the other two stay exactly
+        // where they were. This is what catches a fragment whose uniforms are
+        // wired to the wrong curve — it would still lift *something*.
+        let (moved, still) = match channel {
+            Channel::Red => (r > r0, g == g0 && b == b0),
+            Channel::Green => (g > g0, r == r0 && b == b0),
+            _ => (b > b0, r == r0 && g == g0),
+        };
+        assert!(moved, "the {name} curve changed nothing: {r},{g},{b}");
+        assert!(
+            still,
+            "the {name} curve moved a component that was not its own: \
+             {r},{g},{b} from {r0},{g0},{b0}"
+        );
+    }
+}
+
+#[test]
+fn the_master_and_the_channels_compose_in_one_pass() {
+    // All four curves at once: the case where the generated fragment is
+    // longest, every helper is present, and forty uniforms are in the block.
+    // Mostly a compile check, which is why the assertion is only that the
+    // result is a colour and not the one we started with.
+    let Some(ctx) = ctx() else {
+        eprintln!("no adapter; skipping");
+        return;
+    };
+
+    let mut graph = EditGraph::default_chain();
+    graph.set_param(curve::ID, curve::P1_Y, 0.15);
+    graph.set_param(curve::ID, curve::P3_Y, 0.85);
+    for (channel, y) in [
+        (Channel::Red, 0.55),
+        (Channel::Green, 0.5),
+        (Channel::Blue, 0.62),
+    ] {
+        graph.set_param(curve::ID, curve::coordinate(channel, 2, Axis::Y), y);
+    }
+
+    let (r0, _, _) = rendered(&ctx, &EditGraph::default_chain());
+    let (r, g, b) = rendered(&ctx, &graph);
+    assert!(
+        (r, g, b) != (r0, r0, r0),
+        "four active curves left the image untouched"
+    );
+    // Red and blue were pushed apart from green, which is the chromatic half
+    // doing its work on top of the tonal one.
+    assert!(b > g, "blue was lifted above green: {r},{g},{b}");
+}