dtourolle
affdaecaee
D19 retired the per-body base curve, moved the matrix ahead of the edits and the film into the view transform's place, but a dozen doc comments still listed the curve among what a pixel passes through, or said the film skipped it. The detail stage's module doc still drew the matrix after the edits and the last detail pass encoding, which the view pass took over. The film crate's README gave the base curves as its reason for being data, and the ops README's list of hand-written nodes had neither the view transform nor three of the five kernels. FR-MRG-2 gave the base curve as why the merge cuts below the profile; the view transform is why now. The decision table still said colour defaults were a per-body curve, and FR-DEV-3j said only the default view transform skips a JPEG, where the node skips one whatever its sliders say. frame-budget.md records the view pass as unmeasured.
753 lines
30 KiB
Rust
753 lines
30 KiB
Rust
//! TRACES: FR-DEV-3f
|
|
//! Film simulation — the stock renders the picture.
|
|
//!
|
|
//! # Why this one is the view transform
|
|
//!
|
|
//! [`crate::ops`]' other nodes adjust a picture. This one *makes* it. The view
|
|
//! transform exists because sensor data is scene-referred and nothing anybody
|
|
//! looks at is (FR-DEV-3j); a film stock's characteristic curve does the same
|
|
//! job, from measurements, with a toe and a shoulder that were coated onto
|
|
//! acetate rather than drawn. Running both renders the image twice — the
|
|
//! default rendering, and then a film's rendering of that — which is not what
|
|
//! either is for and looks like neither.
|
|
//!
|
|
//! So this node is in [`Stage::View`] and declares [`Operation::renders`]: when
|
|
//! a stock is loaded the composer puts it at the end of the chain in place of
|
|
//! the default sigmoid (D19). It is handed working-space colour — linear sRGB
|
|
//! primaries, scene-referred, after every other operation and after the detail
|
|
//! stage — and returns display-referred linear sRGB for the output transform.
|
|
//! Before D19 it ran at order 25, after exposure and before everything else,
|
|
//! and the operations below it acted on its output. They now act on the scene
|
|
//! it is shown: an edit is a decision about the exposure the negative
|
|
//! receives, and the film is the last thing that happens to the picture.
|
|
//!
|
|
//! # Why the tables are not parameters
|
|
//!
|
|
//! For the same reason [`crate::ops::vignetting`]'s coefficients are not: they
|
|
//! are measurements of a physical thing, not something a slider moves. The
|
|
//! sliders here are exposure, push, print exposure and format, which are what
|
|
//! a photographer and a printer actually control. `dr-film` turns a stock into
|
|
//! [`FilmTables`] that hold none of them; the shader applies all four per
|
|
//! pixel, which is what lets a mask layer hold its own (see
|
|
//! [`Operation::blends_settings`]). This node knows only the layout.
|
|
//!
|
|
//! Declared as a plain struct here rather than imported, so that dr-pipeline
|
|
//! keeps its no-dependency property (ARCH §6.5a) exactly as `vignetting` does
|
|
//! with `Pa`.
|
|
use std::sync::{Arc, LazyLock};
|
|
|
|
use crate::descriptor::{Attribute, LocalizedKey, OpDescriptor, OpId, ParamDescriptor, ParamId};
|
|
use crate::operation::{Operation, Stage, Uniform};
|
|
|
|
pub const ID: OpId = OpId("film_sim");
|
|
pub const EXPOSURE: ParamId = ParamId("exposure");
|
|
pub const PRINT_EXPOSURE: ParamId = ParamId("print_exposure");
|
|
pub const PUSH: ParamId = ParamId("push");
|
|
pub const FORMAT: ParamId = ParamId("format");
|
|
|
|
/// TRACES: FR-DEV-3f
|
|
/// The frames a photograph can be simulated on, smallest first.
|
|
///
|
|
/// A genuinely fixed list, unlike the stocks: nobody invents a film format, so
|
|
/// this is a declared `enum` parameter and gets its control, its place in the
|
|
/// sidecar and its undo step for free. The *sizes* live in `dr_film::Format`;
|
|
/// this crate carries only the names, in the same order.
|
|
static FORMATS: [LocalizedKey; 6] = [
|
|
LocalizedKey("param.film_sim.format.35mm"),
|
|
LocalizedKey("param.film_sim.format.645"),
|
|
LocalizedKey("param.film_sim.format.6x6"),
|
|
LocalizedKey("param.film_sim.format.6x7"),
|
|
LocalizedKey("param.film_sim.format.4x5"),
|
|
LocalizedKey("param.film_sim.format.8x10"),
|
|
];
|
|
|
|
/// How many samples a characteristic curve carries.
|
|
///
|
|
/// Must agree with `dr_film::profile::CURVE_SAMPLES`. Restated rather than
|
|
/// imported because importing it is exactly the dependency this crate does not
|
|
/// take; [`FilmTables::is_well_formed`] is what stops the two drifting.
|
|
pub const CURVE_SAMPLES: usize = 256;
|
|
|
|
/// The most development times a stock may measure — a curve row and a push
|
|
/// station each. Must agree with `dr_film::bake::MAX_CURVE_ROWS`, for the
|
|
/// reason [`CURVE_SAMPLES`] must; the uniform block holds this many stations.
|
|
pub const MAX_CURVE_ROWS: usize = 8;
|
|
|
|
/// How many frames [`FORMATS`] offers, and so how many grain counts a stock
|
|
/// carries.
|
|
pub const FORMAT_COUNT: usize = 6;
|
|
|
|
/// The uniform field names the fragment reads the exposure matrix from.
|
|
///
|
|
/// A table rather than a formatted string, because a `Uniform`'s name is
|
|
/// `&'static str`: building one per composition would mean leaking a string
|
|
/// every time a slider moved.
|
|
static MATRIX_FIELDS: [[&str; 3]; 3] = [
|
|
["m00", "m01", "m02"],
|
|
["m10", "m11", "m12"],
|
|
["m20", "m21", "m22"],
|
|
];
|
|
|
|
/// Grains per pixel, per format and layer: `gn{format}{layer}`.
|
|
static GRAIN_FIELDS: [[&str; 3]; FORMAT_COUNT] = [
|
|
["gn00", "gn01", "gn02"],
|
|
["gn10", "gn11", "gn12"],
|
|
["gn20", "gn21", "gn22"],
|
|
["gn30", "gn31", "gn32"],
|
|
["gn40", "gn41", "gn42"],
|
|
["gn50", "gn51", "gn52"],
|
|
];
|
|
|
|
/// The push each curve row was developed to, padded with the last.
|
|
static PUSH_FIELDS: [&str; MAX_CURVE_ROWS] =
|
|
["ps0", "ps1", "ps2", "ps3", "ps4", "ps5", "ps6", "ps7"];
|
|
|
|
/// Which format this is, one-hot. See [`FilmSim::uniforms`] for why a choice
|
|
/// reaches the shader as six weights rather than an index.
|
|
static FORMAT_FIELDS: [&str; FORMAT_COUNT] = ["fmt0", "fmt1", "fmt2", "fmt3", "fmt4", "fmt5"];
|
|
|
|
static DESCRIPTOR: LazyLock<Arc<OpDescriptor>> = LazyLock::new(|| {
|
|
Arc::new(OpDescriptor {
|
|
// Tone and colour both, and not `Effect`: a stock is not something applied
|
|
// on top of a photograph, it is what the photograph was made on.
|
|
// Effect, not tone-and-colour. **This is the descriptor a `rust:` node
|
|
// is actually read from** — the `attributes:` line in `ops/*.yaml`
|
|
// describes a *declared* node and is inert here, which is how an
|
|
// earlier attempt to make this move changed nothing at all.
|
|
//
|
|
// A stock is `Effect`'s own definition: applied rather than corrected,
|
|
// a look and not a fix. Declaring tone and colour put "Kodachrome" in
|
|
// the Light group beside exposure and again in Colour beside white
|
|
// balance — two places, neither of which is where anyone looks for it.
|
|
// That it moves tone and colour is true of every look.
|
|
attributes: vec![Attribute::Effect],
|
|
id: ID,
|
|
label: LocalizedKey("op.film_sim"),
|
|
params: vec![
|
|
ParamDescriptor::stops("exposure", "param.film_sim.exposure", -3.0, 3.0),
|
|
ParamDescriptor::stops("print_exposure", "param.film_sim.print_exposure", -3.0, 3.0),
|
|
// TRACES: FR-DEV-3f
|
|
// Development, in stops of push. Bounded by what the manufacturers
|
|
// actually published: Double-X's measured axis spans about -1 to +2,
|
|
// and beyond a range like that a curve would have to be invented.
|
|
ParamDescriptor::stops("push", "param.film_sim.push", -1.0, 3.0),
|
|
// TRACES: FR-DEV-3f
|
|
// Which frame this was taken on — the half of the enlargement a
|
|
// photograph cannot supply. A crystal is a fixed size in micrometres,
|
|
// so how grainy a picture looks is film size against output size, and
|
|
// the same emulsion on 4x5 renders about three times smoother than on
|
|
// 35mm at the same print.
|
|
ParamDescriptor::choice("format", "param.film_sim.format", FORMATS.to_vec()),
|
|
],
|
|
})
|
|
});
|
|
|
|
/// A stock reduced to what a shader runs, as `dr-film` bakes it.
|
|
///
|
|
/// Layout is the contract between the two crates, so it is written down here
|
|
/// and checked rather than assumed:
|
|
///
|
|
/// - `exposure_matrix[l][c]` — layer `l`'s response to linear sRGB channel
|
|
/// `c`, at unit gain: camera exposure is a per-pixel setting.
|
|
/// - `curves` — one row of `CURVE_SAMPLES` density triples per
|
|
/// `push_stations` entry, uniform over `[curve_log_min, curve_log_max]`,
|
|
/// and then, when printed, one more row: the paper's, uniform over
|
|
/// `[paper.log_min, paper.log_max]`.
|
|
/// - `lut` — `lut_size³` triples uniform over `[0, density_max]` on each
|
|
/// axis, with the **red axis varying fastest**: index
|
|
/// `(b * size + g) * size + r`. Linear sRGB when the film is viewed
|
|
/// directly; the paper's log₁₀ exposure through the negative when it is
|
|
/// printed, followed by a second cube, paper density over
|
|
/// `[0, paper.density_max]` to linear sRGB. That is the order a 3D texture
|
|
/// upload expects with the cubes stacked in depth, so the consumer hands the
|
|
/// slice straight to the driver. Filling it the other way round transposes
|
|
/// red and blue in the finished picture — which is a plausible photograph
|
|
/// of the wrong colour, and which the unit tests on both sides of this seam
|
|
/// happily pass, because each side is internally consistent. `dr-film` pins
|
|
/// it; `dr-gpu`'s `film_sim` test catches it end to end.
|
|
///
|
|
/// Everything the sliders move — exposure, push, print exposure, format — is
|
|
/// absent. They are per-pixel settings the shader applies against these
|
|
/// tables, which is what lets a mask layer hold its own.
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub struct FilmTables {
|
|
pub exposure_matrix: [[f32; 3]; 3],
|
|
pub curves: Vec<[f32; 3]>,
|
|
/// The push each film row was developed to, ascending: one entry for a
|
|
/// stock measured at a single process.
|
|
pub push_stations: Vec<f32>,
|
|
pub curve_log_min: f32,
|
|
pub curve_log_max: f32,
|
|
pub lut: Vec<[f32; 3]>,
|
|
pub density_max: f32,
|
|
pub lut_size: usize,
|
|
/// The print, for a negative printed on paper.
|
|
pub paper: Option<PaperTables>,
|
|
/// TRACES: FR-DEV-3f
|
|
/// Grains in one pixel's patch of film, per format and then per layer,
|
|
/// with the density ceiling and uniformity the variance is taken against.
|
|
/// Zero particles means no grain, which is how the control is turned off.
|
|
pub grain_particles: [[f32; 3]; FORMAT_COUNT],
|
|
pub grain_density_max: [f32; 3],
|
|
pub grain_uniformity: f32,
|
|
}
|
|
|
|
/// The print half of [`FilmTables`]: where the paper's row and cube are read.
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
pub struct PaperTables {
|
|
/// The enlarger's filtration, per layer, in log₁₀ exposure.
|
|
pub balance: [f32; 3],
|
|
pub log_min: f32,
|
|
pub log_max: f32,
|
|
pub density_max: f32,
|
|
}
|
|
|
|
impl FilmTables {
|
|
/// Film rows, not counting the paper's.
|
|
pub fn curve_rows(&self) -> usize {
|
|
self.push_stations.len()
|
|
}
|
|
|
|
/// Whether these tables are the shape the shader will index them at.
|
|
///
|
|
/// Checked on the way in, because the failure otherwise is a shader
|
|
/// sampling past the end of a texture: undefined, silent, and different on
|
|
/// every driver.
|
|
pub fn is_well_formed(&self) -> bool {
|
|
let rows = self.curve_rows();
|
|
let printed = usize::from(self.paper.is_some());
|
|
let paper_ok = self
|
|
.paper
|
|
.is_none_or(|p| p.density_max > 0.0 && p.log_max > p.log_min);
|
|
(1..=MAX_CURVE_ROWS).contains(&rows)
|
|
&& self.push_stations.windows(2).all(|w| w[0] < w[1])
|
|
&& self.curves.len() == CURVE_SAMPLES * (rows + printed)
|
|
&& self.lut_size >= 2
|
|
&& self.lut.len() == self.lut_size.pow(3) * (1 + printed)
|
|
&& self.density_max > 0.0
|
|
&& self.curve_log_max > self.curve_log_min
|
|
&& paper_ok
|
|
}
|
|
}
|
|
|
|
/// TRACES: FR-DEV-3f
|
|
#[derive(Debug, Default, Clone)]
|
|
pub struct FilmSim {
|
|
exposure: f32,
|
|
print_exposure: f32,
|
|
push: f32,
|
|
/// Index into `FORMATS`. Zero is 35 mm, which is the neutral choice.
|
|
format: f32,
|
|
tables: Option<FilmTables>,
|
|
}
|
|
|
|
impl FilmSim {
|
|
pub fn new() -> Self {
|
|
Self::default()
|
|
}
|
|
|
|
/// Load a baked stock, or clear it.
|
|
///
|
|
/// Malformed tables are refused rather than stored: an operation that is
|
|
/// active but cannot be indexed is worse than one that is off, because the
|
|
/// first renders garbage and the second renders the photograph.
|
|
pub fn set_tables(&mut self, tables: Option<FilmTables>) {
|
|
match tables {
|
|
Some(t) if !t.is_well_formed() => {
|
|
log::error!(
|
|
"film_sim: refusing malformed tables ({} curve samples, {} lut entries at size {})",
|
|
t.curves.len(),
|
|
t.lut.len(),
|
|
t.lut_size
|
|
);
|
|
self.tables = None;
|
|
}
|
|
other => self.tables = other,
|
|
}
|
|
}
|
|
|
|
/// The loaded stock's tables, for whoever has to upload them.
|
|
pub fn tables(&self) -> Option<&FilmTables> {
|
|
self.tables.as_ref()
|
|
}
|
|
}
|
|
|
|
impl Operation for FilmSim {
|
|
fn descriptor(&self) -> Arc<OpDescriptor> {
|
|
DESCRIPTOR.clone()
|
|
}
|
|
|
|
fn set_param(&mut self, id: ParamId, value: f32) {
|
|
match id {
|
|
EXPOSURE => self.exposure = value,
|
|
PRINT_EXPOSURE => self.print_exposure = value,
|
|
PUSH => self.push = value,
|
|
FORMAT => self.format = value,
|
|
_ => log::warn!("film_sim: unknown parameter {id}"),
|
|
}
|
|
}
|
|
|
|
fn param(&self, id: ParamId) -> f32 {
|
|
match id {
|
|
EXPOSURE => self.exposure,
|
|
PRINT_EXPOSURE => self.print_exposure,
|
|
PUSH => self.push,
|
|
FORMAT => self.format,
|
|
_ => 0.0,
|
|
}
|
|
}
|
|
|
|
/// Active exactly when a stock is loaded.
|
|
///
|
|
/// Not "when a slider has moved", which is the rule everywhere else and
|
|
/// would be wrong here: a stock at zero exposure compensation is the whole
|
|
/// point of choosing it, and a node that went quiet at its defaults would
|
|
/// mean picking a film did nothing until you also nudged something.
|
|
fn is_active(&self) -> bool {
|
|
self.tables.is_some()
|
|
}
|
|
|
|
/// This node renders; the default view transform must not also run.
|
|
fn renders(&self) -> bool {
|
|
true
|
|
}
|
|
|
|
/// TRACES: FR-DEV-3f | FR-DEV-3j
|
|
/// The view transform's place, at the end of the chain (D19).
|
|
fn stage(&self) -> Stage {
|
|
Stage::View
|
|
}
|
|
|
|
fn set_film_tables(&mut self, tables: Option<&FilmTables>) {
|
|
self.set_tables(tables.cloned());
|
|
}
|
|
|
|
fn film_tables(&self) -> Option<&FilmTables> {
|
|
self.tables.as_ref()
|
|
}
|
|
|
|
/// TRACES: FR-DEV-3f
|
|
/// A layer's film is its settings, not its own picture blended over the
|
|
/// global one.
|
|
///
|
|
/// Blending outputs would be a photograph developed twice and cross-faded;
|
|
/// a region on a pushed film is not that. Every uniform below is linear
|
|
/// in what it controls, so the composer can take each layer's weighted
|
|
/// average of them and develop the pixel once.
|
|
fn blends_settings(&self) -> bool {
|
|
true
|
|
}
|
|
|
|
/// Every value here is linear in what the shader does with it, which is
|
|
/// what [`Self::blends_settings`] rests on. The format is the one that
|
|
/// needs arranging: an index averaged between layers is a format nobody
|
|
/// chose, so it goes out one-hot and the shader mixes the six grain
|
|
/// counts by it — two layers on 35 mm and 6x7 meet at the average grain.
|
|
fn uniforms(&self) -> Vec<Uniform> {
|
|
let Some(t) = &self.tables else {
|
|
return Vec::new();
|
|
};
|
|
let mut out = Vec::with_capacity(64);
|
|
let mut push = |name: &'static str, value: f32| out.push(Uniform { name, value });
|
|
for (l, row) in t.exposure_matrix.iter().enumerate() {
|
|
for (c, v) in row.iter().enumerate() {
|
|
push(MATRIX_FIELDS[l][c], *v);
|
|
}
|
|
}
|
|
for (f, per_layer) in t.grain_particles.iter().enumerate() {
|
|
for (l, v) in per_layer.iter().enumerate() {
|
|
push(GRAIN_FIELDS[f][l], *v);
|
|
}
|
|
}
|
|
for (l, name) in ["gd0", "gd1", "gd2"].into_iter().enumerate() {
|
|
push(name, t.grain_density_max[l]);
|
|
}
|
|
push("grain_u", t.grain_uniformity);
|
|
push("log_min", t.curve_log_min);
|
|
push("log_max", t.curve_log_max);
|
|
push("density_max", t.density_max);
|
|
push("lut_size", t.lut_size as f32);
|
|
|
|
let last = *t.push_stations.last().unwrap_or(&0.0);
|
|
for (i, name) in PUSH_FIELDS.into_iter().enumerate() {
|
|
push(name, t.push_stations.get(i).copied().unwrap_or(last));
|
|
}
|
|
push("rows", t.curve_rows() as f32);
|
|
|
|
let paper = t.paper.unwrap_or(PaperTables {
|
|
balance: [0.0; 3],
|
|
log_min: 0.0,
|
|
log_max: 1.0,
|
|
density_max: 1.0,
|
|
});
|
|
push("printed", if t.paper.is_some() { 1.0 } else { 0.0 });
|
|
for (l, name) in ["pb0", "pb1", "pb2"].into_iter().enumerate() {
|
|
push(name, paper.balance[l]);
|
|
}
|
|
push("plog_min", paper.log_min);
|
|
push("plog_max", paper.log_max);
|
|
push("pdmax", paper.density_max);
|
|
|
|
// The sliders.
|
|
push("ev", self.exposure);
|
|
push("push", self.push);
|
|
push("pev", self.print_exposure);
|
|
let chosen = (self.format.max(0.0).round() as usize).min(FORMAT_COUNT - 1);
|
|
for (f, name) in FORMAT_FIELDS.into_iter().enumerate() {
|
|
push(name, if f == chosen { 1.0 } else { 0.0 });
|
|
}
|
|
out
|
|
}
|
|
|
|
fn wgsl_body(&self) -> String {
|
|
// Filtered by hand rather than through a sampler, which is what the
|
|
// framing prologue already does for the source: this pipeline has no
|
|
// sampler binding, and adding one to interpolate two lookups would
|
|
// cost a binding in every shader whether or not a film is loaded.
|
|
"\
|
|
// Working-space colour, which is linear sRGB primaries — what the film's
|
|
// exposure matrix is defined against. The composer converted out of camera
|
|
// RGB before any scene-stage operation ran (D19).
|
|
let scene = c;
|
|
|
|
// What each emulsion layer was exposed to. A matrix, exactly: the scene
|
|
// spectrum reconstructed from an sRGB triple is linear in that triple, so the
|
|
// integral over wavelength collapsed into these nine numbers when the stock
|
|
// was baked. The camera's exposure is a gain on it, applied here rather than
|
|
// baked in so that a layer can hold its own.
|
|
let exposure = exp2(ev) * vec3<f32>(
|
|
dot(vec3<f32>(m00, m01, m02), scene),
|
|
dot(vec3<f32>(m10, m11, m12), scene),
|
|
dot(vec3<f32>(m20, m21, m22), scene),
|
|
);
|
|
// 1e-10 rather than a clamp to zero: a black pixel has to land somewhere on
|
|
// the curve, and the toe is where it belongs.
|
|
let log_exposure = log10(max(exposure, vec3<f32>(0.0)) + 1e-10);
|
|
|
|
// The characteristic curve: what density each layer develops to, at this
|
|
// pixel's push. Clamped, not extrapolated — past the shoulder a real emulsion
|
|
// stops responding, and extrapolating would turn a blown highlight into a
|
|
// colour cast that grows the more it is overexposed.
|
|
let density = film_curve_pushed(
|
|
clamp((log_exposure - log_min) / (log_max - log_min), vec3<f32>(0.0), vec3<f32>(1.0)),
|
|
push,
|
|
array<f32, 8>(ps0, ps1, ps2, ps3, ps4, ps5, ps6, ps7),
|
|
u32(rows),
|
|
);
|
|
|
|
// TRACES: FR-DEV-3f
|
|
// Grain, on the density and before the dye.
|
|
//
|
|
// That order is the physical one and it is not cosmetic: grain is silver that
|
|
// did or did not develop, so it perturbs *density*, and the dye absorbs
|
|
// through whatever density resulted. Adding noise to the finished colour --
|
|
// which is what an effect does -- tints the highlights wrong, because that
|
|
// noise never passes through the dye at all.
|
|
//
|
|
// The format's grain count, mixed by the one-hot weights: exactly one format's
|
|
// on the whole photograph, and the weighted average under overlapping layers.
|
|
let particles = fmt0 * vec3<f32>(gn00, gn01, gn02)
|
|
+ fmt1 * vec3<f32>(gn10, gn11, gn12)
|
|
+ fmt2 * vec3<f32>(gn20, gn21, gn22)
|
|
+ fmt3 * vec3<f32>(gn30, gn31, gn32)
|
|
+ fmt4 * vec3<f32>(gn40, gn41, gn42)
|
|
+ fmt5 * vec3<f32>(gn50, gn51, gn52);
|
|
let grained = film_grain(density, source_px, particles,
|
|
vec3<f32>(gd0, gd1, gd2),
|
|
grain_u);
|
|
|
|
// Dye absorption through to what comes next — all of it takes exactly three
|
|
// numbers in, which is why it fits in one lookup. Viewed directly, that is
|
|
// the picture; printed, it is the light the paper receives through the
|
|
// negative, in log exposure.
|
|
let through = film_lut(clamp(grained / density_max, vec3<f32>(0.0), vec3<f32>(1.0)),
|
|
lut_size, 0);
|
|
if (printed > 0.5) {
|
|
// The enlarger: its filtration, and then its exposure, the same stops on
|
|
// every layer — which is why print exposure is an addition here and not
|
|
// a table, and so exact at any setting.
|
|
let paper_log = through + vec3<f32>(pb0, pb1, pb2) + pev * 0.30103;
|
|
let paper_density = film_curve(
|
|
clamp((paper_log - plog_min) / (plog_max - plog_min), vec3<f32>(0.0), vec3<f32>(1.0)),
|
|
u32(rows),
|
|
);
|
|
c = film_lut(clamp(paper_density / pdmax, vec3<f32>(0.0), vec3<f32>(1.0)),
|
|
lut_size, i32(lut_size));
|
|
} else {
|
|
c = through;
|
|
}"
|
|
.into()
|
|
}
|
|
|
|
fn helpers(&self) -> &'static [crate::operation::Helper] {
|
|
&HELPERS
|
|
}
|
|
}
|
|
|
|
static HELPERS: [crate::operation::Helper; 6] = [
|
|
crate::operation::Helper {
|
|
name: "film_hash",
|
|
source: "\
|
|
// A hash, not a random number generator: the same pixel of the same frame has
|
|
// to grain the same way every time it is drawn, or the picture would crawl
|
|
// while nobody was editing it. Seeded from a position, so it is reproducible
|
|
// by construction rather than by holding state between frames.
|
|
//
|
|
// Two decorrelated uniforms come out, which is what a Gaussian needs.
|
|
fn film_hash(p: vec2<f32>, layer: u32) -> vec2<f32> {
|
|
var h = u32(i32(floor(p.x))) * 73856093u
|
|
^ u32(i32(floor(p.y))) * 19349663u
|
|
^ (layer + 1u) * 83492791u;
|
|
h = h ^ (h >> 16u);
|
|
h = h * 2246822519u;
|
|
h = h ^ (h >> 13u);
|
|
h = h * 3266489917u;
|
|
let a = h ^ (h >> 16u);
|
|
var g = a * 747796405u + 2891336453u;
|
|
g = ((g >> ((g >> 28u) + 4u)) ^ g) * 277803737u;
|
|
let b = g ^ (g >> 22u);
|
|
// Open interval: a zero would send the logarithm below to infinity.
|
|
return vec2<f32>(
|
|
max(f32(a) * 2.3283064e-10, 1e-7),
|
|
max(f32(b) * 2.3283064e-10, 1e-7)
|
|
);
|
|
}",
|
|
},
|
|
crate::operation::Helper {
|
|
name: "film_grain",
|
|
source: "\
|
|
// Developed density, with the variance a count of silver grains actually has.
|
|
//
|
|
// mean = D
|
|
// variance = D * (Dmax - u * D) / N
|
|
//
|
|
// N is grains *per pixel*, so the entire scale dependence sits in that uniform
|
|
// and none of it is here: a zoomed-out pixel covers more film, averages more
|
|
// grains, and comes out smoother with nothing filtered.
|
|
//
|
|
// A Gaussian with the exact first two moments, rather than the exact compound
|
|
// Poisson-Binomial the silver actually follows. The two agree wherever grain
|
|
// is visible; the real one is skewed only in the deep toe, where the density
|
|
// is near zero and so is its variance. Sampling it properly would cost tens of
|
|
// draws per layer per pixel to change nothing anyone can see.
|
|
// Takes its parameters rather than reading uniforms, and must: the composer
|
|
// prefixes a uniform with its operation's id and rewrites the references
|
|
// *inside a fragment body only*. Helpers are shared between operations and
|
|
// deduplicated by name, so a bare `gn0` here is an identifier that exists in
|
|
// no shader. `film_lut` below takes its size for the same reason.
|
|
fn film_grain(
|
|
density: vec3<f32>,
|
|
at: vec2<f32>,
|
|
n: vec3<f32>,
|
|
dmax: vec3<f32>,
|
|
uniformity: f32,
|
|
) -> vec3<f32> {
|
|
var out = density;
|
|
for (var l = 0u; l < 3u; l = l + 1u) {
|
|
if (n[l] <= 0.0) {
|
|
continue;
|
|
}
|
|
let d = clamp(density[l], 0.0, dmax[l]);
|
|
let variance = d * (dmax[l] - uniformity * d) / n[l];
|
|
if (variance <= 0.0) {
|
|
continue;
|
|
}
|
|
let u = film_hash(at, l);
|
|
// Box-Muller. Half the pair is discarded rather than carried: the next
|
|
// layer wants a seed of its own, not this one's leftover.
|
|
let z = sqrt(-2.0 * log(u.x)) * cos(6.2831853 * u.y);
|
|
// Clamped, not wrapped: a negative density is not a colour, and the
|
|
// ceiling is the most silver this emulsion has to develop.
|
|
out[l] = clamp(d + z * sqrt(variance), 0.0, dmax[l]);
|
|
}
|
|
return out;
|
|
}",
|
|
},
|
|
crate::operation::Helper {
|
|
name: "log10",
|
|
source: "\
|
|
// WGSL has no log10, and `log2(x) * log10(2)` is the cheap identity for it.
|
|
fn log10(v: vec3<f32>) -> vec3<f32> {
|
|
return log2(v) * 0.30103;
|
|
}",
|
|
},
|
|
crate::operation::Helper {
|
|
name: "film_curve",
|
|
source: "\
|
|
// Three characteristic curves, one row of a 256-wide texture, interpolated by
|
|
// hand. `t` is already normalised to the curve's domain.
|
|
fn film_curve(t: vec3<f32>, row: u32) -> vec3<f32> {
|
|
let samples = u32(textureDimensions(film_curves).x);
|
|
let last = f32(samples - 1u);
|
|
var out = vec3<f32>(0.0);
|
|
for (var ch = 0u; ch < 3u; ch = ch + 1u) {
|
|
let x = t[ch] * last;
|
|
let i = min(u32(floor(x)), samples - 2u);
|
|
let f = x - f32(i);
|
|
let a = textureLoad(film_curves, vec2<i32>(i32(i), i32(row)), 0);
|
|
let b = textureLoad(film_curves, vec2<i32>(i32(i) + 1, i32(row)), 0);
|
|
out[ch] = mix(a[ch], b[ch], f);
|
|
}
|
|
return out;
|
|
}",
|
|
},
|
|
crate::operation::Helper {
|
|
name: "film_curve_pushed",
|
|
source: "\
|
|
// The curves at a push between two measured processes. Development is
|
|
// interpolated in log time and push *is* log time, so a straight line between
|
|
// the neighbouring rows is the stock's own interpolation, not an estimate of
|
|
// it. Clamped to the first and last process, as the stock is.
|
|
fn film_curve_pushed(t: vec3<f32>, push: f32, stations: array<f32, 8>, rows: u32) -> vec3<f32> {
|
|
if (rows < 2u) {
|
|
return film_curve(t, 0u);
|
|
}
|
|
var at = stations;
|
|
var hi = rows - 1u;
|
|
for (var i = 1u; i < rows; i = i + 1u) {
|
|
if (at[i] >= push) {
|
|
hi = i;
|
|
break;
|
|
}
|
|
}
|
|
let lo = hi - 1u;
|
|
let f = clamp((push - at[lo]) / max(at[hi] - at[lo], 1e-6), 0.0, 1.0);
|
|
return mix(film_curve(t, lo), film_curve(t, hi), f);
|
|
}",
|
|
},
|
|
crate::operation::Helper {
|
|
name: "film_lut",
|
|
source: "\
|
|
// Trilinear interpolation of one cube of the lookup, by hand for the same
|
|
// reason the curve above is: there is no sampler bound, and the eight loads
|
|
// are cache-neighbours. `z0` is where the cube starts in depth: the film's at
|
|
// zero, the paper's stacked after it.
|
|
fn film_lut(t: vec3<f32>, size: f32, z0: i32) -> vec3<f32> {
|
|
let n = i32(size);
|
|
let x = t * (size - 1.0);
|
|
let base = min(vec3<i32>(floor(x)), vec3<i32>(n - 2));
|
|
let f = x - vec3<f32>(base);
|
|
|
|
var out = vec3<f32>(0.0);
|
|
for (var dx = 0; dx < 2; dx = dx + 1) {
|
|
let wx = select(1.0 - f.x, f.x, dx == 1);
|
|
for (var dy = 0; dy < 2; dy = dy + 1) {
|
|
let wy = select(1.0 - f.y, f.y, dy == 1);
|
|
for (var dz = 0; dz < 2; dz = dz + 1) {
|
|
let wz = select(1.0 - f.z, f.z, dz == 1);
|
|
let p = base + vec3<i32>(dx, dy, dz + z0);
|
|
out = out + wx * wy * wz
|
|
* textureLoad(film_lut_texture, p, 0).rgb;
|
|
}
|
|
}
|
|
}
|
|
return out;
|
|
}",
|
|
},
|
|
];
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn tables() -> FilmTables {
|
|
FilmTables {
|
|
exposure_matrix: [[5.0, 0.5, 0.2], [0.1, 5.0, 0.3], [0.2, 0.5, 4.0]],
|
|
curves: vec![[0.0, 0.0, 0.0]; CURVE_SAMPLES],
|
|
curve_log_min: -3.0,
|
|
curve_log_max: 4.0,
|
|
lut: vec![[0.5, 0.5, 0.5]; 32 * 32 * 32],
|
|
density_max: 3.0,
|
|
lut_size: 32,
|
|
grain_particles: [[0.0; 3]; FORMAT_COUNT],
|
|
push_stations: vec![0.0],
|
|
paper: None,
|
|
grain_density_max: [3.0; 3],
|
|
grain_uniformity: 0.97,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn it_starts_inactive() {
|
|
assert!(!FilmSim::new().is_active());
|
|
}
|
|
|
|
#[test]
|
|
fn loading_a_stock_is_what_turns_it_on() {
|
|
// Not a moved slider, which is the rule for every other node. Choosing
|
|
// a film has to do something on its own, or picking one would appear
|
|
// to be broken until you also nudged the exposure.
|
|
let mut op = FilmSim::new();
|
|
op.set_tables(Some(tables()));
|
|
assert!(op.is_active());
|
|
op.set_tables(None);
|
|
assert!(!op.is_active());
|
|
}
|
|
|
|
#[test]
|
|
fn malformed_tables_are_refused_rather_than_stored() {
|
|
// The alternative is a shader indexing past the end of a texture,
|
|
// which is undefined, silent, and different on every driver.
|
|
let mut op = FilmSim::new();
|
|
let mut bad = tables();
|
|
bad.lut.truncate(10);
|
|
op.set_tables(Some(bad));
|
|
assert!(!op.is_active(), "malformed tables were accepted");
|
|
}
|
|
|
|
#[test]
|
|
fn a_short_curve_is_refused_too() {
|
|
let mut op = FilmSim::new();
|
|
let mut bad = tables();
|
|
bad.curves.truncate(CURVE_SAMPLES - 1);
|
|
op.set_tables(Some(bad));
|
|
assert!(!op.is_active());
|
|
}
|
|
|
|
#[test]
|
|
fn it_declares_itself_a_rendering_transform() {
|
|
// The whole reason the composer emits the stock in the view
|
|
// transform's place rather than beside it. If this ever returned
|
|
// false the picture would be rendered twice, which looks like a
|
|
// colour management bug a long way from here.
|
|
assert!(FilmSim::new().renders());
|
|
}
|
|
|
|
#[test]
|
|
fn the_matrix_reaches_the_shader_in_the_order_the_fragment_reads_it() {
|
|
// `m01` must be layer 0's response to sRGB green. A transposed matrix
|
|
// compiles, runs, and swaps the picture's colours.
|
|
let mut op = FilmSim::new();
|
|
op.set_tables(Some(tables()));
|
|
let uniforms = op.uniforms();
|
|
let named = |n: &str| uniforms.iter().find(|u| u.name == n).unwrap().value;
|
|
assert_eq!(named("m01"), 0.5);
|
|
assert_eq!(named("m10"), 0.1);
|
|
assert_eq!(named("m22"), 4.0);
|
|
}
|
|
|
|
#[test]
|
|
fn an_inactive_node_publishes_no_uniforms() {
|
|
assert!(FilmSim::new().uniforms().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn the_fragment_is_handed_working_space_colour() {
|
|
// TRACES: FR-DEV-3f
|
|
// D19: the composer leaves camera space before any scene-stage
|
|
// operation, so a film converting again would apply the camera
|
|
// matrix twice.
|
|
let mut op = FilmSim::new();
|
|
op.set_tables(Some(tables()));
|
|
let wgsl = op.wgsl_body();
|
|
assert!(!wgsl.contains("cam_to_srgb"), "{wgsl}");
|
|
}
|
|
|
|
#[test]
|
|
fn every_helper_defines_the_function_it_names() {
|
|
for h in HELPERS {
|
|
assert!(h.source.contains(&format!("fn {}(", h.name)), "{}", h.name);
|
|
}
|
|
}
|
|
}
|