Count the silver instead of adding noise

An emulsion is a suspension of crystals. Light sensitises some; development
turns a sensitised one opaque, all or nothing. So a patch of film's density
is a *count* of developed grains, and a count of independent yes/no events
has a variance whether or not anyone wanted texture:

    mean     = D
    variance = D * (Dmax - u * D) / N

That expression is the whole feature. It peaks in the middle of the density
range and vanishes at both ends -- clear film has nothing developed to vary,
black film has nothing left to develop -- so grain lives in the midtones as a
consequence rather than as a "midtone bias" slider.

I was wrong earlier that this needs the detail stage. Nothing in it reads a
neighbouring pixel; the only reason to move it was that grain must be fixed in
film space rather than screen space, and that solves itself: N is grains *per
pixel*, so it scales with the film a pixel covers. Zoom out, each pixel
averages more grains, less variance -- correct, with nothing super-sampled and
nothing filtered. It stays in the fused pass.

Grain goes on the density and *before* the dye, which is the physical order
and not cosmetic. Perturbing the finished colour -- what an effect does --
tints highlights wrong, because that noise never passes through the dye.

Crystal habit lives in `rms_granularity`, the number every datasheet
publishes, now a profile field. It measures exactly what differs between a
cubic emulsion and a tabular one: at equal speed, tabular crystals present
more area per unit silver, so the film reads finer. Delta 100 is quoted near 9
where HP5 is near 12, and that gap *is* the habit. Adding a stock whose grain
is its whole reputation is therefore editing one line, not writing a model.

Three things this cost, all of them worth writing down:

  - The default granularity is a colour negative's, blue coarsest. Applied to
    Tri-X it put *colour* speckle on a black and white photograph. Monochrome
    stocks collapse it at parse, where every other per-layer table is already
    replicated from the one measured channel.
  - Helpers cannot read uniforms. The composer prefixes a uniform with its
    operation's id and rewrites references inside a fragment body only;
    helpers are shared and deduplicated, so a bare `gn0` names nothing.
    `film_lut` already took its size as an argument for this reason, and now
    says so.
  - The end-to-end test compares the shader against the CPU model, and grain
    is stochastic, so that comparison now runs with grain off. Which means a
    grain that never left the CPU would look exactly like a passing suite --
    hence a second test that grain off is bit-identical, one grain per pixel
    moves it, and ten thousand move it less.

Not here, deliberately: no grain slider. The parameters are physical and
`rms_granularity` is the honest place to scale one from, but its range wants
choosing rather than guessing. Nor a film format -- 35 mm is assumed, and
medium format at the same stock is far less grainy per unit of picture.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

ui/dr-ui/src/develop.rs

@@ -2385,6 +2385,19 @@ impl DevelopSession {
         } else {
             None
         };
+        // TRACES: FR-DEV-3f
+        // Grain, at the scale this photograph is being sampled at.
+        //
+        // A digital frame has no film format, so simulating one means choosing
+        // what it *would have been* — 35 mm, because that is the format every
+        // published granularity figure and every intuition about how grainy a
+        // stock looks comes from. The sensor's width in pixels then says how
+        // much film one pixel covers, and the grain model needs nothing else
+        // to be correct at any zoom.
+        let (source_width, _) = self.demosaiced.size();
+        let pixel_size_um = dr_film::grain::FRAME_WIDTH_UM / source_width.max(1) as f32;
+        let grain = dr_film::Grain::for_pixel_size(profile, pixel_size_um);
+
         let baked = dr_film::bake(&dr_film::Recipe {
             film: profile,
             print: paper,
@@ -2415,6 +2428,9 @@ impl DevelopSession {
                 lut: baked.lut,
                 density_max: baked.density_max,
                 lut_size: baked.lut_size,
+                grain_particles: grain.particles,
+                grain_density_max: grain.density_max,
+                grain_uniformity: grain.uniformity,
             },
         }));
     }