Develop a mask layer's film on its own settings

A layer offered the film's sliders and they moved nothing: its copy of
the node was never given the stock, so it stayed inactive. Film now
works in a layer the way the other adjustments do, as offsets to the
photograph's settings, but blended as settings rather than as results,
since a film is a rendering and cross-fading two developments is not
what a region on a pushed film looks like.

- dr-film bakes no slider. Exposure is a gain in the shader; push
  interpolates the stock's measured processes, one curve row each; the
  print is split at the paper's log exposure, so print exposure is an
  addition between two lookups and exact at any setting. The enlarger
  stays balanced at the photograph's exposure.
- film_sim reads all four settings as uniforms, format one-hot over a
  grain count per format, so every uniform is linear in what it does.
- Operation::blends_settings lets the composer average each overlapping
  layer's uniforms with the global ones by mask weight, the global
  setting taking whatever weight the layers leave, and run the fragment
  once. Three layers at full weight give the mean of their settings.
- The stock picker is hidden on a layer. Only the photograph's exposure
  re-solves the print balance; push, print exposure and format need no
  rebake at all now.

core/dr-pipeline/src/mask.rs

@@ -1656,7 +1656,7 @@ impl MaskLayer {
         self.ops
             .iter()
             .map(|o| o.as_ref())
-            .filter(|o| o.is_active() && o.detail().is_none())
+            .filter(|o| moves(*o) && o.detail().is_none())
     }
 
     /// Whether any part of this mask belongs to a different segmentation.
@@ -2087,9 +2087,30 @@ pub(crate) struct LocalOp {
     /// Empty when the offsets cancel the global setting back to neutral. That
     /// is still an entry, because it still means something: inside the mask
     /// this operation does nothing at all.
+    ///
+    /// Empty, too, for an operation blended as settings: that entry stands
+    /// for this layer's uniforms, `mask{slot}_{op}_*`, which the composer
+    /// averages into the one fragment it runs.
     pub fragment: String,
 }
 
+/// Whether a layer's copy of `op` holds an adjustment.
+///
+/// An operation's own answer, except for one blended as settings
+/// ([`Operation::blends_settings`]): that one is active by what it *holds* —
+/// a film is active when a stock is loaded — and a layer never holds a stock,
+/// only offsets to the photograph's. So a layer's film counts as moved when
+/// its sliders are, which is the question being asked.
+fn moves(op: &dyn Operation) -> bool {
+    op.is_active()
+        || (op.blends_settings()
+            && op
+                .descriptor()
+                .params
+                .iter()
+                .any(|p| op.param(p.id) != p.default))
+}
+
 /// A layer's settings for one operation, applied as offsets to the global
 /// operation's.
 ///
@@ -2215,7 +2236,7 @@ pub(crate) fn compose_layers_revealing(
         let mut combined = layer_chain();
         for (dst, local) in combined.iter_mut().zip(&layer.ops) {
             let local = local.as_ref();
-            if !local.is_active() || local.detail().is_some() {
+            if !moves(local) || local.detail().is_some() {
                 continue;
             }
             let id = local.descriptor().id.0;
@@ -2223,9 +2244,22 @@ pub(crate) fn compose_layers_revealing(
                 .iter()
                 .map(|o| o.as_ref())
                 .find(|o| o.descriptor().id.0 == id);
+            // The photograph's stock, lent to the layer's copy: a layer holds
+            // offsets to a film, never one of its own.
+            if let Some(g) = g {
+                dst.set_film_tables(g.film_tables());
+            }
             offset_onto(dst.as_mut(), local, g);
 
-            if !dst.is_active() {
+            if dst.blends_settings() {
+                // Its uniforms, and no fragment: the composer blends this
+                // layer's settings with the others' and runs the global
+                // fragment once. With no stock loaded there is nothing to
+                // blend, and the global side skips the operation too.
+                if !dst.is_active() {
+                    continue;
+                }
+            } else if !dst.is_active() {
                 out.ops.push(LocalOp {
                     op: id,
                     slot,
@@ -2250,13 +2284,16 @@ pub(crate) fn compose_layers_revealing(
                 }
             }
 
-            let mut fragment = dst.wgsl_body();
-            for u in &op_uniforms {
-                fragment = crate::operation::rewrite_uniform(
-                    &fragment,
-                    u.name,
-                    &format!("u.{op_prefix}_{}", u.name),
-                );
+            let mut fragment = String::new();
+            if !dst.blends_settings() {
+                fragment = dst.wgsl_body();
+                for u in &op_uniforms {
+                    fragment = crate::operation::rewrite_uniform(
+                        &fragment,
+                        u.name,
+                        &format!("u.{op_prefix}_{}", u.name),
+                    );
+                }
             }
             out.ops.push(LocalOp {
                 op: id,
@@ -2387,6 +2424,78 @@ mod tests {
         layer
     }
 
+    /// A stock the shader can index, with values that are not a real one's.
+    fn film_fixture() -> crate::graph::Film {
+        use crate::ops::film_sim::{CURVE_SAMPLES, FORMAT_COUNT};
+        crate::graph::Film {
+            stock: "fixture".into(),
+            print: None,
+            tables: crate::ops::FilmTables {
+                exposure_matrix: [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
+                curves: vec![[0.5; 3]; CURVE_SAMPLES],
+                push_stations: vec![0.0],
+                curve_log_min: -3.0,
+                curve_log_max: 1.0,
+                lut: vec![[0.5; 3]; 8],
+                density_max: 2.0,
+                lut_size: 2,
+                paper: None,
+                grain_particles: [[0.0; 3]; FORMAT_COUNT],
+                grain_density_max: [2.0; 3],
+                grain_uniformity: 1.0,
+            },
+        }
+    }
+
+    #[test]
+    fn a_layers_film_is_blended_as_settings_and_developed_once() {
+        // TRACES: FR-DEV-3f
+        // The film is a rendering: a layer's version of it run beside the
+        // global one and cross-faded would be the photograph developed twice.
+        // So the layer's uniforms are averaged into the global ones by weight
+        // and the fragment appears once.
+        use crate::ops::film_sim;
+        let mut graph = crate::EditGraph::default_chain();
+        graph.set_film(Some(film_fixture()));
+        let mut layer = MaskLayer::new("m1", regions(&[1]));
+        layer.set_param(film_sim::ID.0, film_sim::PRINT_EXPOSURE, 1.0);
+        assert!(layer.is_active(), "a film offset is an adjustment");
+        graph.masks_mut().push(layer);
+
+        let source = graph.compose().source;
+        assert!(source.contains("let set_w = mask_w0;"), "{source}");
+        assert!(source.contains("let set_g = max(1.0 - set_w, 0.0);"));
+        assert!(
+            source.contains("u.mask0_film_sim_pev"),
+            "the layer's setting is not read"
+        );
+        assert_eq!(
+            source.matches("let density = film_curve_pushed(").count(),
+            1,
+            "the film was developed more than once"
+        );
+        assert!(
+            !source.contains("let local_in"),
+            "the film was blended as a result"
+        );
+    }
+
+    #[test]
+    fn a_layers_film_without_a_stock_composes_to_nothing() {
+        // TRACES: FR-DEV-3f
+        // The offsets are kept — a stock chosen later brings them back — but
+        // with no film on the photograph there is nothing for them to offset.
+        use crate::ops::film_sim;
+        let mut graph = crate::EditGraph::default_chain();
+        let mut layer = MaskLayer::new("m1", regions(&[1]));
+        layer.set_param(film_sim::ID.0, film_sim::PUSH, 1.0);
+        graph.masks_mut().push(layer);
+
+        let source = graph.compose().source;
+        assert!(!source.contains("---- film_sim ----"), "{source}");
+        assert!(!source.contains("mask0_film_sim"));
+    }
+
     #[test]
     fn a_layer_with_no_adjustment_is_not_in_the_shader() {
         let layer = MaskLayer::new("m1", regions(&[1]));