diff --git a/.config/nextest.toml b/.config/nextest.toml
new file mode 100644
index 000000000..2a4cd2cb9
--- /dev/null
+++ b/.config/nextest.toml
@@ -0,0 +1,3 @@
+# Minimum cargo-nextest for this repository: GHSA-vc25-qg58-w57c is fixed in 0.9.150 and CI
+# installs exactly that version, so an older nextest refuses to run (exit 92 REQUIRED_VERSION_NOT_MET).
+nextest-version = "0.9.150"
diff --git a/.github/workflows/sonarcloud.yml b/.github/workflows/sonarcloud.yml
index e78fe1ea3..8f1aa5ad5 100644
--- a/.github/workflows/sonarcloud.yml
+++ b/.github/workflows/sonarcloud.yml
@@ -16,6 +16,9 @@ concurrency:
jobs:
sonarcloud:
- # Tracked at @main so org-wide CI improvements propagate without PR churn.
+ # Track shared CI improvements on main.
uses: storytold/craft-common-actions/.github/workflows/sonarcloud.yml@main
+ with:
+ timeout-minutes: 120
+ fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
secrets: inherit
diff --git a/apps/effectcraft-cli/tests/it/cli.rs b/apps/effectcraft-cli/tests/it/cli.rs
index 538887d9b..c7a905e58 100644
--- a/apps/effectcraft-cli/tests/it/cli.rs
+++ b/apps/effectcraft-cli/tests/it/cli.rs
@@ -7,7 +7,7 @@ use std::process::{Command, Stdio};
use serde_json::{Value, json};
fn bin() -> Command {
- Command::new(env!("CARGO_BIN_EXE_effectcraft-cli"))
+ Command::new(crate::binary())
}
/// Run with `--json`; returns (exit code, parsed stdout).
diff --git a/apps/effectcraft-cli/tests/it/main.rs b/apps/effectcraft-cli/tests/it/main.rs
index 17149f545..bca36ec78 100644
--- a/apps/effectcraft-cli/tests/it/main.rs
+++ b/apps/effectcraft-cli/tests/it/main.rs
@@ -2,3 +2,8 @@
mod cli;
mod qa_template;
+
+/// Nextest archives relocate binaries; plain Cargo keeps the compile-time path valid.
+fn binary() -> std::ffi::OsString {
+ std::env::var_os("NEXTEST_BIN_EXE_effectcraft_cli").unwrap_or_else(|| env!("CARGO_BIN_EXE_effectcraft-cli").into())
+}
diff --git a/apps/effectcraft-cli/tests/it/qa_template.rs b/apps/effectcraft-cli/tests/it/qa_template.rs
index 0618c0d63..8cb533fda 100644
--- a/apps/effectcraft-cli/tests/it/qa_template.rs
+++ b/apps/effectcraft-cli/tests/it/qa_template.rs
@@ -9,7 +9,7 @@ use std::process::Command;
use serde_json::Value;
fn cli(dir: &PathBuf, args: &[&str]) -> (i32, Value) {
- let out = Command::new(env!("CARGO_BIN_EXE_effectcraft-cli")).current_dir(dir).args(args).arg("--json").output().unwrap();
+ let out = Command::new(crate::binary()).current_dir(dir).args(args).arg("--json").output().unwrap();
let stdout = String::from_utf8_lossy(&out.stdout).to_string();
let v = serde_json::from_str(stdout.trim()).unwrap_or_else(|e| panic!("{args:?}: {e}: {stdout} {}", String::from_utf8_lossy(&out.stderr)));
(out.status.code().unwrap_or(-1), v)
@@ -191,7 +191,7 @@ fn essential_graphics_template_via_script_and_commands() {
vec!["render", "--template", "lt.ectemplate", "--queue"],
vec!["render-frame", "--template", "lt.ectemplate", "--bridge", "1"],
] {
- let output = Command::new(env!("CARGO_BIN_EXE_effectcraft-cli")).current_dir(&dir).args(&args).output().unwrap();
+ let output = Command::new(crate::binary()).current_dir(&dir).args(&args).output().unwrap();
assert_eq!(output.status.code(), Some(2), "{args:?}: {}", String::from_utf8_lossy(&output.stderr));
}
@@ -251,7 +251,7 @@ fn assert_template_output_preserves_inputs(dir: &PathBuf, out: &str) -> Value {
let template_before = std::fs::read(dir.join("lt.ectemplate")).unwrap();
let values_before = std::fs::read(dir.join("values.json")).unwrap();
// Read the inputs before interpreting the subprocess status or error text.
- let result = Command::new(env!("CARGO_BIN_EXE_effectcraft-cli"))
+ let result = Command::new(crate::binary())
.current_dir(dir)
.args(["render-frame", "--template", "lt.ectemplate", "--values", "values.json", "--time", "1", "--out", out, "--json"])
.output()
@@ -527,7 +527,7 @@ fn template_unknown_control_does_not_replace_extracted_media() {
let invalid_values_before = std::fs::read(dir.join("bad-values.json")).unwrap();
// Capture every file before interpreting status/JSON, so a failed command cannot hide a write.
- let result = Command::new(env!("CARGO_BIN_EXE_effectcraft-cli"))
+ let result = Command::new(crate::binary())
.current_dir(&dir)
.args(["render-frame", "--template", "lt.ectemplate", "--values", "bad-values.json", "--time", "1", "--out", "failed.png", "--json"])
.output()
@@ -623,11 +623,8 @@ fn template_missing_output_does_not_replace_extracted_media() {
assert_ne!(sentinel_before, source_before);
// Observe writes before interpreting the actual CLI usage exit.
- let result = Command::new(env!("CARGO_BIN_EXE_effectcraft-cli"))
- .current_dir(&dir)
- .args(["render", "--template", "lt.ectemplate", "--values", "values.json", "--json"])
- .output()
- .unwrap();
+ let result =
+ Command::new(crate::binary()).current_dir(&dir).args(["render", "--template", "lt.ectemplate", "--values", "values.json", "--json"]).output().unwrap();
let template_after = std::fs::read(dir.join("lt.ectemplate")).unwrap();
let values_after = std::fs::read(dir.join("values.json")).unwrap();
let source_after = std::fs::read(dir.join("source.png")).unwrap();
diff --git a/apps/effectcraft-web/src/app.rs b/apps/effectcraft-web/src/app.rs
index f09bf28a1..169529e5d 100644
--- a/apps/effectcraft-web/src/app.rs
+++ b/apps/effectcraft-web/src/app.rs
@@ -86,6 +86,8 @@ pub struct WebApp {
}
impl eframe::App for WebApp {
+ /// Take dropped files out of `raw_input` before eframe can replay them on a hidden tab, read them asynchronously
+ /// through `open_or_import`, then run the shared app's input hook.
fn raw_input_hook(&mut self, ctx: &egui::Context, raw_input: &mut egui::RawInput) {
// Files dropped on the page are input: read them here, where the browser's drop event is
// still the current pass's, not from a later (possibly logic-only) tick.
@@ -101,6 +103,9 @@ impl eframe::App for WebApp {
self.app.raw_input_hook(ctx, raw_input);
}
+ /// The browser host's logic tick: run queued UI actions, tick the shared app, poll API replies, flush Render
+ /// Queue downloads, persist the session snapshot when enabled, publish GPU/frame-worker/disk-cache info and close
+ /// the IME pass.
fn logic(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
let actions = ACTIONS.with(|a| std::mem::take(&mut *a.borrow_mut()));
for f in actions {
diff --git a/apps/effectcraft-web/src/lib.rs b/apps/effectcraft-web/src/lib.rs
index 0d59906f2..97d2e887f 100644
--- a/apps/effectcraft-web/src/lib.rs
+++ b/apps/effectcraft-web/src/lib.rs
@@ -6,17 +6,17 @@
//!
//! | Desktop | Web |
//! |---|---|
-//! | file system (`FsServices`, media reads, export writes) | a virtual file table ([`files`]) persisted to the Origin Private File System / IndexedDB ([`persist`], [`store`]) |
+//! | file system (`FsServices`, media reads, export writes) | a virtual file table (`files`) persisted to the Origin Private File System / IndexedDB (`persist`, [`store`]) |
//! | config directory (settings, shortcuts, recent projects, auto-saves) | the same store ([`store::WebConfig`]) |
//! | rfd file dialogs | `` pickers; drop files on the page |
-//! | Media Browser on the file system | browser storage and folders opened with the File System Access API ([`browse`]) |
+//! | Media Browser on the file system | browser storage and folders opened with the File System Access API (`browse`) |
//! | written files (Save, Render Queue) | browser downloads (several render files as one `.zip`) |
-//! | frame render threads | frame workers, each with a project replica fed by diffs and its own WebGPU device ([`frames`]); `Frames::pump` on the UI thread without workers |
-//! | disk cache folder | frames in the Origin Private File System, written by the frame workers ([`diskcache`]) |
-//! | (none) | the storage manager: usage, quota, persistence, clearing ([`storage`]) |
-//! | Render Queue / analysis threads | Web Workers running their own engine instance ([`worker`]) |
-//! | cpal audio output | Web Audio: an AudioWorklet fed from the preview mixdown ([`audio`]) |
-//! | TCP control channel / MCP | `window.effectcraft` JavaScript API ([`api`]) |
+//! | frame render threads | frame workers, each with a project replica fed by diffs and its own WebGPU device (`frames`); `Frames::pump` on the UI thread without workers |
+//! | disk cache folder | frames in the Origin Private File System, written by the frame workers (`diskcache`) |
+//! | (none) | the storage manager: usage, quota, persistence, clearing (`storage`) |
+//! | Render Queue / analysis threads | Web Workers running their own engine instance (`worker`) |
+//! | cpal audio output | Web Audio: an AudioWorklet fed from the preview mixdown (`audio`) |
+//! | TCP control channel / MCP | `window.effectcraft` JavaScript API (`api`) |
//!
//! [`store`] is portable (unit-tested natively); everything else is `wasm32`-only.
diff --git a/apps/effectcraft/src/main.rs b/apps/effectcraft/src/main.rs
index 5e3e14c65..6df015290 100644
--- a/apps/effectcraft/src/main.rs
+++ b/apps/effectcraft/src/main.rs
@@ -148,6 +148,10 @@ fn install_file_dialogs(app: &mut EffectcraftApp) -> Option eframe::Result {
// Windows: the update helper is a copy of this program started with `--finish-update`.
#[cfg(windows)]
@@ -451,6 +455,7 @@ struct Desktop {
}
impl eframe::App for Desktop {
+ /// The desktop host's logic tick: update the macOS menu bar, run the shared app tick and close the IME pass.
fn logic(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
#[cfg(target_os = "macos")]
self.menu.update(&mut self.app, ctx);
diff --git a/apps/effectcraft/tests/args.rs b/apps/effectcraft/tests/args.rs
index 8367d2a99..41281eb23 100644
--- a/apps/effectcraft/tests/args.rs
+++ b/apps/effectcraft/tests/args.rs
@@ -6,6 +6,11 @@ use std::path::PathBuf;
use std::process::{Command, Stdio};
use std::time::{Duration, Instant};
+/// Nextest archives relocate binaries; plain Cargo keeps the compile-time path valid.
+fn binary() -> std::ffi::OsString {
+ std::env::var_os("NEXTEST_BIN_EXE_effectcraft").unwrap_or_else(|| env!("CARGO_BIN_EXE_effectcraft").into())
+}
+
/// A settings folder of its own, so a launch that got past the arguments would show up as
/// preferences (Recent Footage) written there instead of in the user's settings.
fn config_dir(name: &str) -> PathBuf {
@@ -19,7 +24,7 @@ fn config_dir(name: &str) -> PathBuf {
/// regression fails instead of leaving a window open: the process is killed after 5 s.
fn rejects(name: &str, args: &[&str], env: &[(&str, &str)], message: &str) {
let config = config_dir(name);
- let mut cmd = Command::new(env!("CARGO_BIN_EXE_effectcraft"));
+ let mut cmd = Command::new(binary());
cmd.args(args).env_remove("EFFECTCRAFT_CONTROL_PORT").env_remove("RUST_LOG").env("EFFECTCRAFT_CONFIG_DIR", &config);
for (k, v) in env {
cmd.env(k, v);
@@ -67,7 +72,7 @@ fn a_bad_control_port_stops_the_launch() {
#[test]
fn version_still_prints_with_a_bad_port_variable() {
- let out = Command::new(env!("CARGO_BIN_EXE_effectcraft")).arg("--version").env("EFFECTCRAFT_CONTROL_PORT", "abc").output().unwrap();
+ let out = Command::new(binary()).arg("--version").env("EFFECTCRAFT_CONTROL_PORT", "abc").output().unwrap();
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
assert_eq!(String::from_utf8(out.stdout).unwrap(), format!("effectcraft {}\n", env!("CARGO_PKG_VERSION")));
}
diff --git a/crates/effects/src/catalog.rs b/crates/effects/src/catalog.rs
index 0be2b04f5..80a937b22 100644
--- a/crates/effects/src/catalog.rs
+++ b/crates/effects/src/catalog.rs
@@ -92,7 +92,7 @@ const CPU_ONLY_CONTROLS: &[(&str, &[&str])] = &[
];
/// Whether the GPU kernel of effect `id` covers the instance's current settings (see
-/// [`CPU_ONLY_CONTROLS`]; plus Cell Pattern's HQ variants and Turbulent Displace's locked
+/// `CPU_ONLY_CONTROLS`; plus Cell Pattern's HQ variants and Turbulent Displace's locked
/// pinning).
pub fn gpu_supported(id: &str, ctx: &crate::EffectCtx) -> bool {
match id {
diff --git a/crates/effects/src/channel3d.rs b/crates/effects/src/channel3d.rs
index 39a1c49b1..08241107c 100644
--- a/crates/effects/src/channel3d.rs
+++ b/crates/effects/src/channel3d.rs
@@ -359,7 +359,7 @@ pub(crate) fn selection_names(sel: &str) -> Vec {
out
}
-/// Parse a selection: comma-separated names (optionally quoted, see [`selection_names`]) or
+/// Parse a selection: comma-separated names (optionally quoted, see `selection_names`) or
/// `` hashes / wildcards.
pub fn selection_hashes(sel: &str, manifest: Option<&[(String, u32)]>) -> Vec {
let mut out = vec![];
@@ -686,384 +686,4 @@ pub fn specs() -> Vec {
}
#[cfg(test)]
-mod tests {
- use super::*;
- use crate::{EffectEnv, EffectHost, LayerPixels, run_fx};
- use effectcraft_raster::channels3d::crypto_float;
-
- /// A 20×10 layer: left half object 1 at depth 100, right half object 2 at depth 500; the
- /// top-right corner is background. Cryptomatte: "left" / "right".
- struct AuxHost(Arc);
- impl EffectHost for AuxHost {
- fn layer(&self, _: u64, _: bool) -> Option {
- None
- }
- fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option> {
- None
- }
- fn aux(&self) -> Option> {
- Some(self.0.clone())
- }
- }
-
- fn scene() -> AuxHost {
- let (w, h) = (20usize, 10usize);
- let mut a = AuxChannels::new(w as u32, h as u32, 1.0);
- let (mut z, mut id, mut r, mut g) = (vec![0.0; w * h], vec![0.0; w * h], vec![0.0; w * h], vec![0.0; w * h]);
- let (hl, hr) = (crypto_hash("left"), crypto_hash("right"));
- for y in 0..h {
- for x in 0..w {
- let i = y * w + x;
- if x >= 15 && y < 3 {
- z[i] = BACKGROUND_DEPTH;
- } else if x < 10 {
- z[i] = 100.0;
- id[i] = 1.0;
- r[i] = crypto_float(hl);
- g[i] = 1.0;
- } else {
- z[i] = 500.0;
- id[i] = 2.0;
- r[i] = crypto_float(hr);
- g[i] = 1.0;
- }
- }
- }
- a.channels = vec![("Z".into(), z), ("ObjectID".into(), id), ("CryptoObject00.R".into(), r), ("CryptoObject00.G".into(), g)];
- a.manifests = vec![("CryptoObject".into(), vec![("left".into(), hl), ("right".into(), hr)])];
- AuxHost(Arc::new(a))
- }
-
- fn img() -> Image {
- Image::filled(20, 10, [0.5, 0.5, 0.5, 1.0])
- }
-
- fn run(id: &str, vals: &[(&str, Value)], host: &AuxHost) -> Image {
- run_fx(id, vals, img(), 0.0, EffectEnv { host: Some(host), ..Default::default() }).img
- }
-
- #[test]
- fn passes_through_without_aux_channels() {
- for s in specs() {
- let out = run_fx(s.id, &[], img(), 0.0, EffectEnv::default());
- assert_eq!(out.img.data, img().data, "{}", s.id);
- }
- }
-
- #[test]
- fn depth_matte_thresholds() {
- let h = scene();
- let o = run("ec.3d.depthmatte", &[("depth", num(300.0))], &h);
- assert_eq!(o.get(2, 5)[3], 0.0);
- assert_eq!(o.get(12, 5)[3], 1.0);
- let inv = run("ec.3d.depthmatte", &[("depth", num(300.0)), ("invert", Value::Bool(true))], &h);
- assert_eq!(inv.get(2, 5)[3], 1.0);
- assert_eq!(inv.get(12, 5)[3], 0.0);
- // Feather: a ramp of 800 units centred on 300 → depth 100 at 0.25, 500 at 0.75.
- let f = run("ec.3d.depthmatte", &[("depth", num(300.0)), ("feather", num(800.0))], &h);
- assert!((f.get(2, 5)[3] - 0.25).abs() < 1e-5 && (f.get(12, 5)[3] - 0.75).abs() < 1e-5);
- }
-
- #[test]
- fn channel_extract_maps_depth_and_ids() {
- let h = scene();
- let o = run("ec.3d.channelextract", &[("blackPoint", num(0.0)), ("whitePoint", num(1000.0))], &h);
- assert!((o.get(2, 5)[0] - 0.1).abs() < 1e-6 && (o.get(12, 5)[0] - 0.5).abs() < 1e-6);
- assert_eq!(o.get(17, 1)[0], 1.0);
- let ids = run("ec.3d.channelextract", &[("channel", Value::Enum(1)), ("whitePoint", num(2.0))], &h);
- assert_eq!(ids.get(2, 5)[0], 0.5);
- // Invert Depth Map flips the ramp; without Clamp Output values run past 1.
- let inv = run("ec.3d.channelextract", &[("blackPoint", num(0.0)), ("whitePoint", num(1000.0)), ("invertDepthMap", Value::Bool(true))], &h);
- assert!((inv.get(2, 5)[0] - 0.9).abs() < 1e-6);
- let raw = run("ec.3d.channelextract", &[("blackPoint", num(0.0)), ("whitePoint", num(100.0)), ("clampOutput", Value::Bool(false))], &h);
- assert!(raw.get(12, 5)[0] > 1.5);
- }
-
- #[test]
- fn id_matte_and_identifier() {
- let h = scene();
- let o = run("ec.3d.idmatte", &[("idSelection", num(2.0))], &h);
- assert_eq!(o.get(2, 5)[3], 0.0);
- assert_eq!(o.get(12, 5)[3], 1.0);
- let l = run("ec.3d.identifier", &[("display", Value::Enum(1)), ("id", num(1.0))], &h);
- assert_eq!(l.get(2, 5)[0], 1.0);
- assert_eq!(l.get(12, 5)[0], 0.0);
- let c = run("ec.3d.identifier", &[], &h);
- assert_ne!(c.get(2, 5), c.get(12, 5));
- }
-
- /// The parallel aux image (rank planes resolved once) is bit-identical to the per-pixel
- /// reduction over `crypto_ranks` it replaces.
- #[test]
- fn crypto_aux_image_matches_the_per_pixel_reduction() {
- let (w, h) = (7u32, 5u32);
- let n = (w * h) as usize;
- let mut a = AuxChannels::new(w, h, 1.0);
- let ids = [crypto_hash("cube"), crypto_hash("sphere"), crypto_hash("ring")].map(effectcraft_raster::channels3d::crypto_float);
- for (k, ch) in ["00.R", "00.G", "00.B", "00.A", "01.R", "01.G", "01.B", "01.A"].iter().enumerate() {
- let v: Vec = (0..n).map(|i| if k % 2 == 0 { ids[(i + k) % 3] } else { ((i * 7 + k * 3) % 11) as f32 / 10.0 }).collect();
- a.channels.push((format!("CryptoObject{ch}"), v));
- }
- let sel = vec![crypto_hash("sphere"), crypto_hash("ring")];
- let img = crypto_aux_image(&a, "CryptoObject", &sel);
- for i in 0..n {
- let ranks = a.crypto_ranks("CryptoObject", i);
- let m: f32 = ranks.iter().filter(|(id, c)| *c > 0.0 && sel.contains(&id.to_bits())).map(|(_, c)| *c).sum::().clamp(0.0, 1.0);
- let mut c = [0.0f32; 3];
- for (id, cov) in &ranks {
- let k = id_color(*id);
- for j in 0..3 {
- c[j] += k[j] * cov;
- }
- }
- let want = [c[0], c[1], c[2], m];
- assert_eq!(img.data[i].map(f32::to_bits), want.map(f32::to_bits), "pixel {i}");
- }
- }
-
- /// The lookup before #473, kept as the reference: the rank channels formatted and searched
- /// by name for every pixel.
- fn ranks_by_name(a: &AuxChannels, layer: &str, i: usize) -> Vec<(f32, f32)> {
- let mut out = vec![];
- for k in 0.. {
- let get = |c: &str| a.get(&format!("{layer}{k:02}.{c}"));
- let (Some(r), Some(g)) = (get("R"), get("G")) else { break };
- out.push((r[i], g[i]));
- if let (Some(b), Some(al)) = (get("B"), get("A")) {
- out.push((b[i], al[i]));
- }
- }
- out
- }
-
- /// The reduction before #473 over those ranks: (ID colours, selection coverage).
- fn reduce_by_name(a: &AuxChannels, layer: &str, sel: &[u32], i: usize) -> ([f32; 3], f32) {
- let ranks = ranks_by_name(a, layer, i);
- let m: f32 = ranks.iter().filter(|(id, c)| *c > 0.0 && sel.contains(&id.to_bits())).map(|(_, c)| *c).sum::().clamp(0.0, 1.0);
- let mut c = [0.0f32; 3];
- for (id, cov) in &ranks {
- let k = id_color(*id);
- for j in 0..3 {
- c[j] += k[j] * cov;
- }
- }
- (c, m)
- }
-
- /// A 6×2 Cryptomatte layer with awkward values: NaN, ±inf, negative and -0.0 coverage, NaN
- /// and -0.0 IDs; rank 01 has no B/A pair, rank 02 is missing, so rank 03 (filled with values
- /// that would change every pixel) must be ignored as before.
- fn edge_aux(with_rank_after_gap: bool) -> AuxChannels {
- let (w, h) = (6u32, 2u32);
- let nan_payload = f32::from_bits(0x7fc0_1234);
- let (hs, hc) = (crypto_float(crypto_hash("sphere")), crypto_float(crypto_hash("cube")));
- let cov = [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, -0.5, -0.0, 0.0, 0.25, 1.0, 2.0, f32::MIN_POSITIVE, nan_payload, 0.5];
- let ids = [hs, f32::NAN, hc, -0.0, 0.0, nan_payload, hs, hc, f32::NAN, hs, hc, -0.0];
- let rot = |v: &[f32; 12], k: usize| -> Vec { (0..12).map(|i| v[(i + k) % 12]).collect() };
- let mut a = AuxChannels::new(w, h, 1.0);
- let mut push = |n: &str, v: Vec| a.channels.push((format!("CryptoObject{n}"), v));
- push("00.R", rot(&ids, 0));
- push("00.G", rot(&cov, 0));
- push("00.B", rot(&ids, 3));
- push("00.A", rot(&cov, 5));
- push("01.R", rot(&ids, 7));
- push("01.G", rot(&cov, 2));
- if with_rank_after_gap {
- push("03.R", vec![hs; 12]);
- push("03.G", vec![1.0; 12]);
- push("03.B", vec![hc; 12]);
- push("03.A", vec![1.0; 12]);
- }
- a
- }
-
- /// The memo hands out exactly `id_color`'s bits for every rank and pixel of the edge values
- /// (NaN IDs with and without a payload, -0.0 and 0.0 are keyed by their bits).
- #[test]
- fn id_color_memo_matches_id_color() {
- let a = edge_aux(true);
- let planes = a.crypto_rank_planes("CryptoObject");
- let mut memo = IdColorMemo::default();
- for i in 0..12 {
- for (r, (id, _)) in planes.iter().enumerate() {
- assert_eq!(memo.get(r, id[i]).map(f32::to_bits), id_color(id[i]).map(f32::to_bits), "pixel {i} rank {r}");
- }
- }
- }
-
- fn edge_selection() -> Vec {
- vec![crypto_hash("sphere"), f32::NAN.to_bits(), 0x7fc0_1234, (-0.0f32).to_bits()]
- }
-
- /// Edge values give bit-identical results to the lookup by name, the missing B/A pair is
- /// skipped and a rank after a gap is ignored.
- #[test]
- fn crypto_aux_image_is_bit_exact_on_edge_values() {
- let sel = edge_selection();
- let a = edge_aux(true);
- assert_eq!(a.crypto_rank_planes("CryptoObject").len(), 3, "00.R/G, 00.B/A, 01.R/G; not 03 after the gap");
- let img = crypto_aux_image(&a, "CryptoObject", &sel);
- let without_gap_rank = crypto_aux_image(&edge_aux(false), "CryptoObject", &sel);
- for i in 0..12 {
- let (c, m) = reduce_by_name(&a, "CryptoObject", &sel, i);
- let want = [c[0], c[1], c[2], m];
- assert_eq!(img.data[i].map(f32::to_bits), want.map(f32::to_bits), "pixel {i}");
- assert_eq!(img.data[i].map(f32::to_bits), without_gap_rank.data[i].map(f32::to_bits), "pixel {i}: the rank after the gap was used");
- }
- }
-
- /// Without the ID colours the matte (A) is bit-identical and the RGB is 0, on the edge values.
- #[test]
- fn crypto_aux_image_without_colors_keeps_the_matte() {
- let a = edge_aux(true);
- let sel = edge_selection();
- let full = crypto_aux_image(&a, "CryptoObject", &sel);
- let matte = crypto_aux_image_with(&a, "CryptoObject", &sel, CryptoAux::MatteOnly);
- for (f, m) in full.data.iter().zip(&matte.data) {
- assert_eq!(f[3].to_bits(), m[3].to_bits());
- assert_eq!(m[..3], [0.0; 3]);
- }
- }
-
- /// Only the Colors display without Matte Only reads the ID colours.
- #[test]
- fn crypto_aux_for_display_reads_colors_only_for_the_colors_display() {
- assert_eq!(CryptoAux::for_display(0, false), CryptoAux::ColorsAndMatte);
- assert_eq!(CryptoAux::for_display(0, true), CryptoAux::MatteOnly);
- for display in [1, 2, 3, u32::MAX] {
- for matte_only in [false, true] {
- assert_eq!(CryptoAux::for_display(display, matte_only), CryptoAux::MatteOnly, "display {display}");
- }
- }
- }
-
- /// The CPU effect on a 20×10 layer over the 6×2 edge aux: pixels inside the aux area match
- /// the lookup by name bit for bit in every display mode, pixels outside it (no aux index)
- /// get an empty matte and no ID colour.
- #[test]
- fn cryptomatte_cpu_path_is_bit_exact_inside_and_outside_the_aux_area() {
- let a = edge_aux(true);
- let host = AuxHost(Arc::new(a.clone()));
- let names = "sphere, <7fc00000>, <7fc01234>, <80000000>";
- assert_eq!(selection_hashes(names, None), edge_selection());
- let src = img().data[0];
- for (display, matte_only) in [(0, false), (1, false), (2, false), (0, true)] {
- let out = run(
- "ec.3d.cryptomatte",
- &[("selection", Value::Str(names.into())), ("display", Value::Enum(display)), ("matteOnly", Value::Bool(matte_only))],
- &host,
- );
- let expect = |c: [f32; 3], m: f32| -> [f32; 4] {
- if matte_only {
- return [m; 4];
- }
- match display {
- 0 => {
- let c = c.map(|v| v * (1.0 - 0.5 * m) + 0.5 * m);
- [c[0], c[1], c[2], 1.0]
- }
- 1 => src.map(|v| v * m),
- _ => [src[0] * (1.0 - 0.5 * m) + 0.5 * m * src[3], src[1] * (1.0 - 0.5 * m) + 0.5 * m * src[3], src[2] * (1.0 - 0.5 * m), src[3]],
- }
- };
- for (x, y) in [(0u32, 0u32), (1, 0), (5, 0), (0, 1), (3, 1), (5, 1)] {
- let (c, m) = reduce_by_name(&a, "CryptoObject", &edge_selection(), (y * 6 + x) as usize);
- assert_eq!(
- out.get(x as i64, y as i64).map(f32::to_bits),
- expect(c, m).map(f32::to_bits),
- "display {display} matteOnly {matte_only} at ({x}, {y})"
- );
- }
- for (x, y) in [(6u32, 0u32), (19, 0), (0, 2), (12, 9)] {
- assert_eq!(
- out.get(x as i64, y as i64).map(f32::to_bits),
- expect([0.0; 3], 0.0).map(f32::to_bits),
- "display {display} matteOnly {matte_only} outside the aux at ({x}, {y})"
- );
- }
- }
- }
-
- #[test]
- fn cryptomatte_selects_by_name_and_wildcard() {
- let h = scene();
- let m = run("ec.3d.cryptomatte", &[("selection", Value::Str("right".into())), ("matteOnly", Value::Bool(true))], &h);
- assert_eq!(m.get(2, 5)[3], 0.0);
- assert_eq!(m.get(12, 5)[3], 1.0);
- let w = run("ec.3d.cryptomatte", &[("selection", Value::Str("l*".into())), ("display", Value::Enum(1))], &h);
- assert_eq!(w.get(2, 5)[3], 1.0);
- assert_eq!(w.get(12, 5)[3], 0.0);
- assert!(wild("*ight", "right") && wild("r*t", "right") && !wild("x*", "right"));
- let hex = format!("<{:08x}>", crypto_hash("left"));
- assert_eq!(selection_hashes(&hex, None), vec![crypto_hash("left")]);
- }
-
- /// #473: a name with a comma in it (Blender allows `Green, Glossy`) is selected when it is
- /// quoted or its comma escaped, instead of being cut into two names that match nothing.
- #[test]
- fn cryptomatte_selection_keeps_quoted_names_with_commas_whole() {
- let manifest = vec![("Green, Glossy".to_string(), 7), ("Green".to_string(), 1), ("Glossy".to_string(), 2), ("ring".to_string(), 3)];
- let m = Some(manifest.as_slice());
- assert_eq!(selection_hashes(r#""Green, Glossy""#, m), vec![7]);
- assert_eq!(selection_hashes("'Green, Glossy', ring", m), vec![7, 3]);
- assert_eq!(selection_hashes(r"Green\, Glossy", m), vec![7]);
- assert_eq!(selection_hashes(r#"ring , "Green, Glossy""#, m), vec![3, 7]);
- // Without a manifest the whole name is hashed.
- assert_eq!(selection_hashes(r#""Green, Glossy""#, None), vec![crypto_hash("Green, Glossy")]);
- // Plain lists, apostrophes inside names and an unclosed quote still parse.
- assert_eq!(selection_hashes("Green, Glossy", m), vec![1, 2]);
- assert_eq!(selection_names("Bob's mat, ring"), vec!["Bob's mat", "ring"]);
- assert_eq!(selection_names(r#""Green, Glossy"#), vec!["Green, Glossy"]);
- assert_eq!(selection_names(r#"say \"hi\""#), vec![r#"say "hi""#]);
- }
-
- #[test]
- fn fog_and_depth_of_field_follow_depth() {
- let h = scene();
- let f = run("ec.3d.fog3d", &[("fogColor", col(1.0, 0.0, 0.0)), ("fogEndDepth", num(1000.0)), ("scatteringDensity", num(0.0))], &h);
- // Linear fog: 10 % at depth 100, 50 % at 500, full on the background.
- assert!((f.get(2, 5)[0] - 0.55).abs() < 1e-4, "{:?}", f.get(2, 5));
- assert!((f.get(12, 5)[0] - 0.75).abs() < 1e-4);
- assert!((f.get(17, 1)[0] - 1.0).abs() < 1e-4 && f.get(17, 1)[1] < 1e-4);
- assert!((dof_radius(100.0, 100.0, 0.0, 10.0, 50.0)).abs() < 1e-6);
- assert!((dof_radius(200.0, 100.0, 0.0, 10.0, 50.0) - 10.0).abs() < 1e-6);
- assert_eq!(dof_radius(140.0, 100.0, 100.0, 10.0, 50.0), 0.0);
- // A sharp edge at the far object blurs when focused near.
- let mut pic = Image::new(20, 10);
- for y in 0..10 {
- for x in 0..20 {
- let v = if x % 2 == 0 { 1.0 } else { 0.0 };
- pic.set(x, y, [v, v, v, 1.0]);
- }
- }
- let env = EffectEnv { host: Some(&h), ..Default::default() };
- let d = run_fx("ec.3d.depthoffield", &[("focalPlane", num(100.0)), ("maximumRadius", num(4.0))], pic.clone(), 0.0, env).img;
- assert_eq!(d.get(4, 5), pic.get(4, 5));
- assert!((d.get(12, 5)[0] - 0.5).abs() < 0.3 && d.get(12, 5) != pic.get(12, 5));
- }
-
- #[test]
- fn extractor_maps_named_channels() {
- let h = scene();
- let o = run("ec.3d.extractor", &[("red", Value::Str("Z".into())), ("whitePoint", num(1000.0))], &h);
- assert!((o.get(2, 5)[0] - 0.1).abs() < 1e-6);
- assert!((o.get(2, 5)[1] - 0.0005).abs() < 1e-6);
- // Without aux: the layer's own channels can be swapped.
- let s = run_fx("ec.3d.extractor", &[("red", Value::Str("A".into()))], Image::filled(2, 2, [0.2, 0.3, 0.4, 1.0]), 0.0, EffectEnv::default());
- assert_eq!(s.img.get(0, 0), [1.0, 0.3, 0.4, 1.0]);
- }
-
- #[test]
- fn channel_extract_antialias_averages_sub_pixels() {
- // Depth at twice the layer resolution, alternating 0 / 1000 per aux column.
- let mut a = AuxChannels::new(40, 20, 2.0);
- a.channels = vec![("Z".into(), (0..800).map(|i| if i % 2 == 0 { 0.0 } else { 1000.0 }).collect())];
- let host = AuxHost(Arc::new(a));
- let vals = [("blackPoint", num(0.0)), ("whitePoint", num(1000.0))];
- let hard = run("ec.3d.channelextract", &vals, &host);
- let v = hard.get(5, 5)[0];
- assert!(v == 0.0 || v == 1.0, "{v}");
- let soft = run("ec.3d.channelextract", &[vals.as_slice(), &[("antialias", Value::Bool(true))]].concat(), &host);
- assert!((soft.get(5, 5)[0] - 0.5).abs() < 1e-5, "{:?}", soft.get(5, 5));
- }
-}
+mod tests;
diff --git a/crates/effects/src/channel3d/tests.rs b/crates/effects/src/channel3d/tests.rs
new file mode 100644
index 000000000..4fc84440e
--- /dev/null
+++ b/crates/effects/src/channel3d/tests.rs
@@ -0,0 +1,375 @@
+use super::*;
+use crate::{EffectEnv, EffectHost, LayerPixels, run_fx};
+use effectcraft_raster::channels3d::crypto_float;
+
+/// A 20×10 layer: left half object 1 at depth 100, right half object 2 at depth 500; the
+/// top-right corner is background. Cryptomatte: "left" / "right".
+struct AuxHost(Arc);
+impl EffectHost for AuxHost {
+ fn layer(&self, _: u64, _: bool) -> Option {
+ None
+ }
+ fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option> {
+ None
+ }
+ fn aux(&self) -> Option> {
+ Some(self.0.clone())
+ }
+}
+
+fn scene() -> AuxHost {
+ let (w, h) = (20usize, 10usize);
+ let mut a = AuxChannels::new(w as u32, h as u32, 1.0);
+ let (mut z, mut id, mut r, mut g) = (vec![0.0; w * h], vec![0.0; w * h], vec![0.0; w * h], vec![0.0; w * h]);
+ let (hl, hr) = (crypto_hash("left"), crypto_hash("right"));
+ for y in 0..h {
+ for x in 0..w {
+ let i = y * w + x;
+ if x >= 15 && y < 3 {
+ z[i] = BACKGROUND_DEPTH;
+ } else if x < 10 {
+ z[i] = 100.0;
+ id[i] = 1.0;
+ r[i] = crypto_float(hl);
+ g[i] = 1.0;
+ } else {
+ z[i] = 500.0;
+ id[i] = 2.0;
+ r[i] = crypto_float(hr);
+ g[i] = 1.0;
+ }
+ }
+ }
+ a.channels = vec![("Z".into(), z), ("ObjectID".into(), id), ("CryptoObject00.R".into(), r), ("CryptoObject00.G".into(), g)];
+ a.manifests = vec![("CryptoObject".into(), vec![("left".into(), hl), ("right".into(), hr)])];
+ AuxHost(Arc::new(a))
+}
+
+fn img() -> Image {
+ Image::filled(20, 10, [0.5, 0.5, 0.5, 1.0])
+}
+
+fn run(id: &str, vals: &[(&str, Value)], host: &AuxHost) -> Image {
+ run_fx(id, vals, img(), 0.0, EffectEnv { host: Some(host), ..Default::default() }).img
+}
+
+#[test]
+fn passes_through_without_aux_channels() {
+ for s in specs() {
+ let out = run_fx(s.id, &[], img(), 0.0, EffectEnv::default());
+ assert_eq!(out.img.data, img().data, "{}", s.id);
+ }
+}
+
+#[test]
+fn depth_matte_thresholds() {
+ let h = scene();
+ let o = run("ec.3d.depthmatte", &[("depth", num(300.0))], &h);
+ assert_eq!(o.get(2, 5)[3], 0.0);
+ assert_eq!(o.get(12, 5)[3], 1.0);
+ let inv = run("ec.3d.depthmatte", &[("depth", num(300.0)), ("invert", Value::Bool(true))], &h);
+ assert_eq!(inv.get(2, 5)[3], 1.0);
+ assert_eq!(inv.get(12, 5)[3], 0.0);
+ // Feather: a ramp of 800 units centred on 300 → depth 100 at 0.25, 500 at 0.75.
+ let f = run("ec.3d.depthmatte", &[("depth", num(300.0)), ("feather", num(800.0))], &h);
+ assert!((f.get(2, 5)[3] - 0.25).abs() < 1e-5 && (f.get(12, 5)[3] - 0.75).abs() < 1e-5);
+}
+
+#[test]
+fn channel_extract_maps_depth_and_ids() {
+ let h = scene();
+ let o = run("ec.3d.channelextract", &[("blackPoint", num(0.0)), ("whitePoint", num(1000.0))], &h);
+ assert!((o.get(2, 5)[0] - 0.1).abs() < 1e-6 && (o.get(12, 5)[0] - 0.5).abs() < 1e-6);
+ assert_eq!(o.get(17, 1)[0], 1.0);
+ let ids = run("ec.3d.channelextract", &[("channel", Value::Enum(1)), ("whitePoint", num(2.0))], &h);
+ assert_eq!(ids.get(2, 5)[0], 0.5);
+ // Invert Depth Map flips the ramp; without Clamp Output values run past 1.
+ let inv = run("ec.3d.channelextract", &[("blackPoint", num(0.0)), ("whitePoint", num(1000.0)), ("invertDepthMap", Value::Bool(true))], &h);
+ assert!((inv.get(2, 5)[0] - 0.9).abs() < 1e-6);
+ let raw = run("ec.3d.channelextract", &[("blackPoint", num(0.0)), ("whitePoint", num(100.0)), ("clampOutput", Value::Bool(false))], &h);
+ assert!(raw.get(12, 5)[0] > 1.5);
+}
+
+#[test]
+fn id_matte_and_identifier() {
+ let h = scene();
+ let o = run("ec.3d.idmatte", &[("idSelection", num(2.0))], &h);
+ assert_eq!(o.get(2, 5)[3], 0.0);
+ assert_eq!(o.get(12, 5)[3], 1.0);
+ let l = run("ec.3d.identifier", &[("display", Value::Enum(1)), ("id", num(1.0))], &h);
+ assert_eq!(l.get(2, 5)[0], 1.0);
+ assert_eq!(l.get(12, 5)[0], 0.0);
+ let c = run("ec.3d.identifier", &[], &h);
+ assert_ne!(c.get(2, 5), c.get(12, 5));
+}
+
+/// The parallel aux image (rank planes resolved once) is bit-identical to the per-pixel
+/// reduction over `crypto_ranks` it replaces.
+#[test]
+fn crypto_aux_image_matches_the_per_pixel_reduction() {
+ let (w, h) = (7u32, 5u32);
+ let n = (w * h) as usize;
+ let mut a = AuxChannels::new(w, h, 1.0);
+ let ids = [crypto_hash("cube"), crypto_hash("sphere"), crypto_hash("ring")].map(effectcraft_raster::channels3d::crypto_float);
+ for (k, ch) in ["00.R", "00.G", "00.B", "00.A", "01.R", "01.G", "01.B", "01.A"].iter().enumerate() {
+ let v: Vec = (0..n).map(|i| if k % 2 == 0 { ids[(i + k) % 3] } else { ((i * 7 + k * 3) % 11) as f32 / 10.0 }).collect();
+ a.channels.push((format!("CryptoObject{ch}"), v));
+ }
+ let sel = vec![crypto_hash("sphere"), crypto_hash("ring")];
+ let img = crypto_aux_image(&a, "CryptoObject", &sel);
+ for i in 0..n {
+ let ranks = a.crypto_ranks("CryptoObject", i);
+ let m: f32 = ranks.iter().filter(|(id, c)| *c > 0.0 && sel.contains(&id.to_bits())).map(|(_, c)| *c).sum::().clamp(0.0, 1.0);
+ let mut c = [0.0f32; 3];
+ for (id, cov) in &ranks {
+ let k = id_color(*id);
+ for j in 0..3 {
+ c[j] += k[j] * cov;
+ }
+ }
+ let want = [c[0], c[1], c[2], m];
+ assert_eq!(img.data[i].map(f32::to_bits), want.map(f32::to_bits), "pixel {i}");
+ }
+}
+
+/// The lookup before #473, kept as the reference: the rank channels formatted and searched
+/// by name for every pixel.
+fn ranks_by_name(a: &AuxChannels, layer: &str, i: usize) -> Vec<(f32, f32)> {
+ let mut out = vec![];
+ for k in 0.. {
+ let get = |c: &str| a.get(&format!("{layer}{k:02}.{c}"));
+ let (Some(r), Some(g)) = (get("R"), get("G")) else { break };
+ out.push((r[i], g[i]));
+ if let (Some(b), Some(al)) = (get("B"), get("A")) {
+ out.push((b[i], al[i]));
+ }
+ }
+ out
+}
+
+/// The reduction before #473 over those ranks: (ID colours, selection coverage).
+fn reduce_by_name(a: &AuxChannels, layer: &str, sel: &[u32], i: usize) -> ([f32; 3], f32) {
+ let ranks = ranks_by_name(a, layer, i);
+ let m: f32 = ranks.iter().filter(|(id, c)| *c > 0.0 && sel.contains(&id.to_bits())).map(|(_, c)| *c).sum::().clamp(0.0, 1.0);
+ let mut c = [0.0f32; 3];
+ for (id, cov) in &ranks {
+ let k = id_color(*id);
+ for j in 0..3 {
+ c[j] += k[j] * cov;
+ }
+ }
+ (c, m)
+}
+
+/// A 6×2 Cryptomatte layer with awkward values: NaN, ±inf, negative and -0.0 coverage, NaN
+/// and -0.0 IDs; rank 01 has no B/A pair, rank 02 is missing, so rank 03 (filled with values
+/// that would change every pixel) must be ignored as before.
+fn edge_aux(with_rank_after_gap: bool) -> AuxChannels {
+ let (w, h) = (6u32, 2u32);
+ let nan_payload = f32::from_bits(0x7fc0_1234);
+ let (hs, hc) = (crypto_float(crypto_hash("sphere")), crypto_float(crypto_hash("cube")));
+ let cov = [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, -0.5, -0.0, 0.0, 0.25, 1.0, 2.0, f32::MIN_POSITIVE, nan_payload, 0.5];
+ let ids = [hs, f32::NAN, hc, -0.0, 0.0, nan_payload, hs, hc, f32::NAN, hs, hc, -0.0];
+ let rot = |v: &[f32; 12], k: usize| -> Vec { (0..12).map(|i| v[(i + k) % 12]).collect() };
+ let mut a = AuxChannels::new(w, h, 1.0);
+ let mut push = |n: &str, v: Vec| a.channels.push((format!("CryptoObject{n}"), v));
+ push("00.R", rot(&ids, 0));
+ push("00.G", rot(&cov, 0));
+ push("00.B", rot(&ids, 3));
+ push("00.A", rot(&cov, 5));
+ push("01.R", rot(&ids, 7));
+ push("01.G", rot(&cov, 2));
+ if with_rank_after_gap {
+ push("03.R", vec![hs; 12]);
+ push("03.G", vec![1.0; 12]);
+ push("03.B", vec![hc; 12]);
+ push("03.A", vec![1.0; 12]);
+ }
+ a
+}
+
+/// The memo hands out exactly `id_color`'s bits for every rank and pixel of the edge values
+/// (NaN IDs with and without a payload, -0.0 and 0.0 are keyed by their bits).
+#[test]
+fn id_color_memo_matches_id_color() {
+ let a = edge_aux(true);
+ let planes = a.crypto_rank_planes("CryptoObject");
+ let mut memo = IdColorMemo::default();
+ for i in 0..12 {
+ for (r, (id, _)) in planes.iter().enumerate() {
+ assert_eq!(memo.get(r, id[i]).map(f32::to_bits), id_color(id[i]).map(f32::to_bits), "pixel {i} rank {r}");
+ }
+ }
+}
+
+fn edge_selection() -> Vec {
+ vec![crypto_hash("sphere"), f32::NAN.to_bits(), 0x7fc0_1234, (-0.0f32).to_bits()]
+}
+
+/// Edge values give bit-identical results to the lookup by name, the missing B/A pair is
+/// skipped and a rank after a gap is ignored.
+#[test]
+fn crypto_aux_image_is_bit_exact_on_edge_values() {
+ let sel = edge_selection();
+ let a = edge_aux(true);
+ assert_eq!(a.crypto_rank_planes("CryptoObject").len(), 3, "00.R/G, 00.B/A, 01.R/G; not 03 after the gap");
+ let img = crypto_aux_image(&a, "CryptoObject", &sel);
+ let without_gap_rank = crypto_aux_image(&edge_aux(false), "CryptoObject", &sel);
+ for i in 0..12 {
+ let (c, m) = reduce_by_name(&a, "CryptoObject", &sel, i);
+ let want = [c[0], c[1], c[2], m];
+ assert_eq!(img.data[i].map(f32::to_bits), want.map(f32::to_bits), "pixel {i}");
+ assert_eq!(img.data[i].map(f32::to_bits), without_gap_rank.data[i].map(f32::to_bits), "pixel {i}: the rank after the gap was used");
+ }
+}
+
+/// Without the ID colours the matte (A) is bit-identical and the RGB is 0, on the edge values.
+#[test]
+fn crypto_aux_image_without_colors_keeps_the_matte() {
+ let a = edge_aux(true);
+ let sel = edge_selection();
+ let full = crypto_aux_image(&a, "CryptoObject", &sel);
+ let matte = crypto_aux_image_with(&a, "CryptoObject", &sel, CryptoAux::MatteOnly);
+ for (f, m) in full.data.iter().zip(&matte.data) {
+ assert_eq!(f[3].to_bits(), m[3].to_bits());
+ assert_eq!(m[..3], [0.0; 3]);
+ }
+}
+
+/// Only the Colors display without Matte Only reads the ID colours.
+#[test]
+fn crypto_aux_for_display_reads_colors_only_for_the_colors_display() {
+ assert_eq!(CryptoAux::for_display(0, false), CryptoAux::ColorsAndMatte);
+ assert_eq!(CryptoAux::for_display(0, true), CryptoAux::MatteOnly);
+ for display in [1, 2, 3, u32::MAX] {
+ for matte_only in [false, true] {
+ assert_eq!(CryptoAux::for_display(display, matte_only), CryptoAux::MatteOnly, "display {display}");
+ }
+ }
+}
+
+/// The CPU effect on a 20×10 layer over the 6×2 edge aux: pixels inside the aux area match
+/// the lookup by name bit for bit in every display mode, pixels outside it (no aux index)
+/// get an empty matte and no ID colour.
+#[test]
+fn cryptomatte_cpu_path_is_bit_exact_inside_and_outside_the_aux_area() {
+ let a = edge_aux(true);
+ let host = AuxHost(Arc::new(a.clone()));
+ let names = "sphere, <7fc00000>, <7fc01234>, <80000000>";
+ assert_eq!(selection_hashes(names, None), edge_selection());
+ let src = img().data[0];
+ for (display, matte_only) in [(0, false), (1, false), (2, false), (0, true)] {
+ let out = run(
+ "ec.3d.cryptomatte",
+ &[("selection", Value::Str(names.into())), ("display", Value::Enum(display)), ("matteOnly", Value::Bool(matte_only))],
+ &host,
+ );
+ let expect = |c: [f32; 3], m: f32| -> [f32; 4] {
+ if matte_only {
+ return [m; 4];
+ }
+ match display {
+ 0 => {
+ let c = c.map(|v| v * (1.0 - 0.5 * m) + 0.5 * m);
+ [c[0], c[1], c[2], 1.0]
+ }
+ 1 => src.map(|v| v * m),
+ _ => [src[0] * (1.0 - 0.5 * m) + 0.5 * m * src[3], src[1] * (1.0 - 0.5 * m) + 0.5 * m * src[3], src[2] * (1.0 - 0.5 * m), src[3]],
+ }
+ };
+ for (x, y) in [(0u32, 0u32), (1, 0), (5, 0), (0, 1), (3, 1), (5, 1)] {
+ let (c, m) = reduce_by_name(&a, "CryptoObject", &edge_selection(), (y * 6 + x) as usize);
+ assert_eq!(out.get(x as i64, y as i64).map(f32::to_bits), expect(c, m).map(f32::to_bits), "display {display} matteOnly {matte_only} at ({x}, {y})");
+ }
+ for (x, y) in [(6u32, 0u32), (19, 0), (0, 2), (12, 9)] {
+ assert_eq!(
+ out.get(x as i64, y as i64).map(f32::to_bits),
+ expect([0.0; 3], 0.0).map(f32::to_bits),
+ "display {display} matteOnly {matte_only} outside the aux at ({x}, {y})"
+ );
+ }
+ }
+}
+
+#[test]
+fn cryptomatte_selects_by_name_and_wildcard() {
+ let h = scene();
+ let m = run("ec.3d.cryptomatte", &[("selection", Value::Str("right".into())), ("matteOnly", Value::Bool(true))], &h);
+ assert_eq!(m.get(2, 5)[3], 0.0);
+ assert_eq!(m.get(12, 5)[3], 1.0);
+ let w = run("ec.3d.cryptomatte", &[("selection", Value::Str("l*".into())), ("display", Value::Enum(1))], &h);
+ assert_eq!(w.get(2, 5)[3], 1.0);
+ assert_eq!(w.get(12, 5)[3], 0.0);
+ assert!(wild("*ight", "right") && wild("r*t", "right") && !wild("x*", "right"));
+ let hex = format!("<{:08x}>", crypto_hash("left"));
+ assert_eq!(selection_hashes(&hex, None), vec![crypto_hash("left")]);
+}
+
+/// #473: a name with a comma in it (Blender allows `Green, Glossy`) is selected when it is
+/// quoted or its comma escaped, instead of being cut into two names that match nothing.
+#[test]
+fn cryptomatte_selection_keeps_quoted_names_with_commas_whole() {
+ let manifest = vec![("Green, Glossy".to_string(), 7), ("Green".to_string(), 1), ("Glossy".to_string(), 2), ("ring".to_string(), 3)];
+ let m = Some(manifest.as_slice());
+ assert_eq!(selection_hashes(r#""Green, Glossy""#, m), vec![7]);
+ assert_eq!(selection_hashes("'Green, Glossy', ring", m), vec![7, 3]);
+ assert_eq!(selection_hashes(r"Green\, Glossy", m), vec![7]);
+ assert_eq!(selection_hashes(r#"ring , "Green, Glossy""#, m), vec![3, 7]);
+ // Without a manifest the whole name is hashed.
+ assert_eq!(selection_hashes(r#""Green, Glossy""#, None), vec![crypto_hash("Green, Glossy")]);
+ // Plain lists, apostrophes inside names and an unclosed quote still parse.
+ assert_eq!(selection_hashes("Green, Glossy", m), vec![1, 2]);
+ assert_eq!(selection_names("Bob's mat, ring"), vec!["Bob's mat", "ring"]);
+ assert_eq!(selection_names(r#""Green, Glossy"#), vec!["Green, Glossy"]);
+ assert_eq!(selection_names(r#"say \"hi\""#), vec![r#"say "hi""#]);
+}
+
+#[test]
+fn fog_and_depth_of_field_follow_depth() {
+ let h = scene();
+ let f = run("ec.3d.fog3d", &[("fogColor", col(1.0, 0.0, 0.0)), ("fogEndDepth", num(1000.0)), ("scatteringDensity", num(0.0))], &h);
+ // Linear fog: 10 % at depth 100, 50 % at 500, full on the background.
+ assert!((f.get(2, 5)[0] - 0.55).abs() < 1e-4, "{:?}", f.get(2, 5));
+ assert!((f.get(12, 5)[0] - 0.75).abs() < 1e-4);
+ assert!((f.get(17, 1)[0] - 1.0).abs() < 1e-4 && f.get(17, 1)[1] < 1e-4);
+ assert!((dof_radius(100.0, 100.0, 0.0, 10.0, 50.0)).abs() < 1e-6);
+ assert!((dof_radius(200.0, 100.0, 0.0, 10.0, 50.0) - 10.0).abs() < 1e-6);
+ assert_eq!(dof_radius(140.0, 100.0, 100.0, 10.0, 50.0), 0.0);
+ // A sharp edge at the far object blurs when focused near.
+ let mut pic = Image::new(20, 10);
+ for y in 0..10 {
+ for x in 0..20 {
+ let v = if x % 2 == 0 { 1.0 } else { 0.0 };
+ pic.set(x, y, [v, v, v, 1.0]);
+ }
+ }
+ let env = EffectEnv { host: Some(&h), ..Default::default() };
+ let d = run_fx("ec.3d.depthoffield", &[("focalPlane", num(100.0)), ("maximumRadius", num(4.0))], pic.clone(), 0.0, env).img;
+ assert_eq!(d.get(4, 5), pic.get(4, 5));
+ assert!((d.get(12, 5)[0] - 0.5).abs() < 0.3 && d.get(12, 5) != pic.get(12, 5));
+}
+
+#[test]
+fn extractor_maps_named_channels() {
+ let h = scene();
+ let o = run("ec.3d.extractor", &[("red", Value::Str("Z".into())), ("whitePoint", num(1000.0))], &h);
+ assert!((o.get(2, 5)[0] - 0.1).abs() < 1e-6);
+ assert!((o.get(2, 5)[1] - 0.0005).abs() < 1e-6);
+ // Without aux: the layer's own channels can be swapped.
+ let s = run_fx("ec.3d.extractor", &[("red", Value::Str("A".into()))], Image::filled(2, 2, [0.2, 0.3, 0.4, 1.0]), 0.0, EffectEnv::default());
+ assert_eq!(s.img.get(0, 0), [1.0, 0.3, 0.4, 1.0]);
+}
+
+#[test]
+fn channel_extract_antialias_averages_sub_pixels() {
+ // Depth at twice the layer resolution, alternating 0 / 1000 per aux column.
+ let mut a = AuxChannels::new(40, 20, 2.0);
+ a.channels = vec![("Z".into(), (0..800).map(|i| if i % 2 == 0 { 0.0 } else { 1000.0 }).collect())];
+ let host = AuxHost(Arc::new(a));
+ let vals = [("blackPoint", num(0.0)), ("whitePoint", num(1000.0))];
+ let hard = run("ec.3d.channelextract", &vals, &host);
+ let v = hard.get(5, 5)[0];
+ assert!(v == 0.0 || v == 1.0, "{v}");
+ let soft = run("ec.3d.channelextract", &[vals.as_slice(), &[("antialias", Value::Bool(true))]].concat(), &host);
+ assert!((soft.get(5, 5)[0] - 0.5).abs() < 1e-5, "{:?}", soft.get(5, 5));
+}
diff --git a/crates/effects/src/color2.rs b/crates/effects/src/color2.rs
index 9547fd775..25203cd7a 100644
--- a/crates/effects/src/color2.rs
+++ b/crates/effects/src/color2.rs
@@ -1129,347 +1129,4 @@ pub fn specs() -> Vec {
}
#[cfg(test)]
-mod tests {
- use super::*;
- use crate::{Params, find};
-
- fn run(id: &str, img: &Image, over: &[(&str, Value)]) -> Image {
- let s = find(id).unwrap();
- let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
- for (k, v) in over {
- params.values.insert(k.to_string(), v.clone());
- }
- let ctx =
- EffectCtx { params: ¶ms, time: 0.0, layer_size: [img.width as f64, img.height as f64], seed: 1, adjustment: false, env: Default::default() };
- (s.render)(&ctx, Buf { img: img.clone(), offset: [0.0, 0.0], scale: 1.0 }).img
- }
-
- fn ramp() -> Image {
- let mut img = Image::new(16, 8);
- for y in 0..8 {
- for x in 0..16 {
- let v = x as f32 / 15.0;
- let a = if y == 0 { 0.5 } else { 1.0 };
- img.set(x, y, [v * a, (1.0 - v) * a, 0.3 * a, a]);
- }
- }
- img
- }
-
- fn close(a: &Image, b: &Image, eps: f32) -> bool {
- a.data.iter().zip(&b.data).all(|(p, q)| (0..4).all(|i| (p[i] - q[i]).abs() <= eps))
- }
-
- #[test]
- fn curve_parsing() {
- assert!(Curve::parse("0,0 1,1").is_none());
- assert!(Curve::parse("garbage").is_none());
- let c = Curve::parse("1,1; 0,0 0.5,0.7").unwrap();
- assert_eq!(c.xs, vec![0.0, 0.5, 1.0]);
- assert!((c.eval(0.5) - 0.7).abs() < 1e-3);
- // Monotone: never decreases.
- let mut last = -1.0;
- for i in 0..=100 {
- let v = c.eval(i as f32 / 100.0);
- assert!(v >= last - 1e-6);
- last = v;
- }
- }
-
- #[test]
- fn curves_identity_is_identity() {
- let img = ramp();
- assert_eq!(run("ec.color.curves", &img, &[]), img);
- let explicit = run("ec.color.curves", &img, &[("rgb", Value::Str("0,0 0.25,0.25 1,1".into()))]);
- assert!(close(&explicit, &img, 1e-4));
- }
-
- #[test]
- fn curves_midpoint_brightens() {
- let img = Image::filled(4, 4, [0.5, 0.5, 0.5, 1.0]);
- let out = run("ec.color.curves", &img, &[("rgb", Value::Str("0,0 0.5,0.75 1,1".into()))]);
- assert!((out.data[0][0] - 0.75).abs() < 1e-3);
- let red = run("ec.color.curves", &img, &[("red", Value::Str("0,1 1,1".into()))]);
- assert!((red.data[0][0] - 1.0).abs() < 1e-4 && (red.data[0][1] - 0.5).abs() < 1e-6);
- }
-
- /// After Effects 2026, 32 bpc project, Levels (Individual Controls) with RGB Input Black 0.1,
- /// Input White 0.9, Gamma 1.5, Output Black 0.05, Output White 0.95, Red Gamma 0.8, Green
- /// Input White 0.8, Blue Output Black 0.2, both clips "Off for 32 bpc Color", on grey steps:
- /// the channel controls run first, nothing clips (8-bit captures clamp the results).
- #[test]
- fn levels_ic_matches_after_effects_in_32_bpc() {
- let steps = [0, 16, 32, 64, 96, 128, 160, 192, 224, 255];
- let ae = [
- [0, 0, 70],
- [0, 0, 88],
- [0, 52, 104],
- [61, 108, 132],
- [102, 150, 158],
- [138, 187, 181],
- [171, 220, 203],
- [203, 250, 223],
- [233, 255, 243],
- [255, 255, 255],
- ];
- let mut img = Image::new(10, 1);
- for (x, v) in steps.iter().enumerate() {
- let v = *v as f32 / 255.0;
- img.set(x as u32, 0, [v, v, v, 1.0]);
- }
- let vals = [
- ("rgb/rgbInBlack", Value::Scalar(0.1)),
- ("rgb/rgbInWhite", Value::Scalar(0.9)),
- ("rgb/rgbGamma", Value::Scalar(1.5)),
- ("rgb/rgbOutBlack", Value::Scalar(0.05)),
- ("rgb/rgbOutWhite", Value::Scalar(0.95)),
- ("red/redGamma", Value::Scalar(0.8)),
- ("green/greenInWhite", Value::Scalar(0.8)),
- ("blue/blueOutBlack", Value::Scalar(0.2)),
- ];
- let s = find("ec.color.levelsic").unwrap();
- let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
- for (k, v) in &vals {
- params.values.insert(k.to_string(), v.clone());
- }
- let render = |float_depth: bool| {
- let env = crate::EffectEnv { float_depth, ..Default::default() };
- let ctx = EffectCtx { params: ¶ms, time: 0.0, layer_size: [10.0, 1.0], seed: 1, adjustment: false, env };
- (s.render)(&ctx, Buf { img: img.clone(), offset: [0.0, 0.0], scale: 1.0 }).img
- };
- let out = render(true);
- for (x, want) in ae.iter().enumerate() {
- let p = out.get(x as i64, 0);
- for c in 0..3 {
- let got = p[c].clamp(0.0, 1.0) * 255.0;
- assert!((got - want[c] as f32).abs() <= 2.0, "step {} channel {c}: {got} vs AE {}", steps[x], want[c]);
- }
- }
- // In 8 / 16 bpc "Off for 32 bpc Color" clips: black stops at Output Black.
- let clipped = render(false);
- assert!((clipped.get(0, 0)[0] - 0.05).abs() < 1e-5, "{:?}", clipped.get(0, 0));
- }
-
- /// After Effects 2026 (cases 962 / 963): Curves through RGB (0,0) (125,199)
- /// (255,255) and Red (0,0) (128,44) (255,255) on grey steps 0..255, 8-bit results.
- #[test]
- fn curves_follow_a_natural_spline_as_in_after_effects() {
- let steps = [0u8, 16, 32, 64, 96, 128, 160, 192, 224, 255];
- let mut img = Image::new(10, 1);
- for (x, v) in steps.iter().enumerate() {
- let v = *v as f32 / 255.0;
- img.set(x as u32, 0, [v, v, v, 1.0]);
- }
- let p = |pts: &[(f32, f32)]| Value::Str(pts.iter().map(|(x, y)| format!("{},{}", x / 255.0, y / 255.0)).collect::>().join(" "));
- let rgb = run("ec.color.curves", &img, &[("rgb", p(&[(0.0, 0.0), (125.0, 199.0), (255.0, 255.0)]))]);
- let red = run("ec.color.curves", &img, &[("red", p(&[(0.0, 0.0), (128.0, 44.0), (255.0, 255.0)]))]);
- let ae_rgb = [0, 30, 59, 115, 164, 202, 227, 242, 250, 255];
- let ae_red = [0, 0, 1, 6, 19, 44, 83, 135, 194, 255];
- for x in 0..10 {
- let g = (rgb.get(x as i64, 0)[1] * 255.0).round() as i32;
- let r = (red.get(x as i64, 0)[0] * 255.0).round() as i32;
- assert!((g - ae_rgb[x]).abs() <= 1, "RGB step {}: {g} vs AE {}", steps[x], ae_rgb[x]);
- assert!((r - ae_red[x]).abs() <= 1, "Red step {}: {r} vs AE {}", steps[x], ae_red[x]);
- }
- }
-
- #[test]
- fn levels_ic_identity_and_red_only() {
- let img = ramp();
- assert_eq!(run("ec.color.levelsic", &img, &[]), img);
- let out = run("ec.color.levelsic", &img, &[("red/redOutWhite", num(0.5))]);
- let p = out.get(15, 3);
- assert!((p[0] - 0.5).abs() < 1e-4 && (p[1] - 0.0).abs() < 1e-4);
- }
-
- #[test]
- fn auto_levels_stretches_low_contrast() {
- let mut img = Image::new(32, 4);
- for y in 0..4 {
- for x in 0..32 {
- let v = 0.4 + 0.2 * x as f32 / 31.0;
- img.set(x, y, [v, v, v, 1.0]);
- }
- }
- let out = run("ec.color.autolevels", &img, &[("blackClip", num(0.0)), ("whiteClip", num(0.0))]);
- let lo = out.data.iter().map(|p| p[0]).fold(1.0, f32::min);
- let hi = out.data.iter().map(|p| p[0]).fold(0.0, f32::max);
- assert!(lo < 0.02 && hi > 0.98, "{lo} {hi}");
- let ac = run("ec.color.autocontrast", &img, &[("blackClip", num(0.0)), ("whiteClip", num(0.0))]);
- assert!(ac.data.iter().map(|p| p[0]).fold(0.0, f32::max) > 0.98);
- }
-
- #[test]
- fn auto_color_neutralises_cast() {
- let mut img = Image::new(16, 4);
- for y in 0..4 {
- for x in 0..16 {
- let v = x as f32 / 15.0;
- img.set(x, y, [v * 0.6 + 0.1, v * 0.9, v * 0.5, 1.0]);
- }
- }
- let out = run("ec.color.autocolor", &img, &[]);
- let p = out.get(8, 1);
- assert!((p[0] - p[1]).abs() < 0.08 && (p[1] - p[2]).abs() < 0.08, "{p:?}");
- }
-
- #[test]
- fn equalize_flattens_histogram() {
- let mut img = Image::new(64, 1);
- for x in 0..64 {
- let v = if x < 48 { 0.1 + x as f32 * 0.001 } else { 0.9 };
- img.set(x, 0, [v, v, v, 1.0]);
- }
- let out = run("ec.color.equalize", &img, &[]);
- // The crowded dark values are spread across the range.
- assert!(out.get(47, 0)[0] > 0.6, "{}", out.get(47, 0)[0]);
- assert!(out.get(0, 0)[0] < 0.1);
- assert_eq!(run("ec.color.equalize", &img, &[("amount", num(0.0))]), img);
- }
-
- #[test]
- fn selective_color_zero_is_identity_and_reds_respond() {
- let img = ramp();
- assert_eq!(run("ec.color.selectivecolor", &img, &[]), img);
- let red = Image::filled(2, 2, [1.0, 0.1, 0.1, 1.0]);
- let out = run("ec.color.selectivecolor", &red, &[("details/reds/redsCyan", num(100.0)), ("method", Value::Enum(1))]);
- assert!(out.data[0][0] < 0.3, "{:?}", out.data[0]);
- let blue = Image::filled(2, 2, [0.1, 0.1, 1.0, 1.0]);
- assert_eq!(run("ec.color.selectivecolor", &blue, &[("details/reds/redsCyan", num(100.0))]), blue);
- }
-
- #[test]
- fn color_offset_full_turn_is_identity() {
- let img = ramp();
- let out = run("ec.color.cccoloroffset", &img, &[("redPhase", num(360.0)), ("greenPhase", num(720.0))]);
- assert_eq!(out, img);
- let out = run("ec.color.cccoloroffset", &img, &[("redPhase", num(180.0))]);
- assert!((out.get(0, 3)[0] - 0.5).abs() < 1e-4);
- }
-
- #[test]
- fn broadcast_reduces_unsafe_color() {
- let img = Image::filled(2, 2, [1.0, 1.0, 0.0, 1.0]);
- let out = run("ec.color.broadcast", &img, &[]);
- assert!(out.data[0][0] < 1.0);
- let key = run("ec.color.broadcast", &img, &[("howToMakeSafe", Value::Enum(2))]);
- assert_eq!(key.data[0][3], 0.0);
- let gray = Image::filled(2, 2, [0.5, 0.5, 0.5, 1.0]);
- assert_eq!(run("ec.color.broadcast", &gray, &[]), gray);
- }
-
- #[test]
- fn color_balance_hls_zero_identity_and_hue_shift() {
- let img = ramp();
- assert_eq!(run("ec.color.colorbalancehls", &img, &[]), img);
- let red = Image::filled(1, 1, [1.0, 0.0, 0.0, 1.0]);
- let out = run("ec.color.colorbalancehls", &red, &[("hue", num(120.0))]);
- assert!(out.data[0][1] > 0.99 && out.data[0][0] < 0.01);
- }
-
- #[test]
- fn color_link_fills_with_average_keeping_alpha() {
- let mut img = Image::new(2, 1);
- img.set(0, 0, [1.0, 0.0, 0.0, 1.0]);
- img.set(1, 0, [0.0, 0.0, 0.5, 0.5]);
- let out = run("ec.color.colorlink", &img, &[]);
- assert!((out.data[1][3] - 0.5).abs() < 1e-5);
- let (c, _) = unpremul(out.data[0]);
- assert!((c[0] - 2.0 / 3.0).abs() < 1e-3 && (c[2] - 1.0 / 3.0).abs() < 1e-3, "{c:?}");
- }
-
- #[test]
- fn cc_kernel_identity_and_toner_duotone() {
- let img = ramp();
- assert_eq!(run("ec.color.cckernel", &img, &[]), img);
- let g = Image::filled(1, 1, [0.5, 0.5, 0.5, 1.0]);
- let t = run("ec.color.cctoner", &g, &[("tones", Value::Enum(0)), ("highlights", col(1.0, 0.0, 0.0))]);
- assert!((t.data[0][0] - 0.5).abs() < 1e-3 && t.data[0][1] < 1e-3);
- }
-
- #[test]
- fn shadow_highlight_lifts_shadows() {
- let img = Image::filled(8, 8, [0.1, 0.1, 0.1, 1.0]);
- let out = run("ec.color.shadowhighlight", &img, &[("autoAmounts", Value::Bool(false))]);
- assert!(out.data[0][0] > 0.15);
- }
-
- #[test]
- fn levels_ic_clip_popups() {
- let img = Image::filled(2, 2, [0.9, 0.9, 0.9, 1.0]);
- let lv = [("rgb/rgbInWhite", num(0.5))];
- assert!((run("ec.color.levelsic", &img, &lv).data[0][0] - 1.0).abs() < 1e-6);
- let off = [("rgb/rgbInWhite", num(0.5)), ("clipToOutputWhite", Value::Enum(0))];
- assert!(run("ec.color.levelsic", &img, &off).data[0][0] > 1.5);
- }
-
- /// A host whose other layers and other frames are a fixed image.
- struct ImgHost(Image);
- impl crate::EffectHost for ImgHost {
- fn layer(&self, _: u64, _: bool) -> Option {
- Some(crate::LayerPixels { buf: Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 }, size: [2.0, 2.0] })
- }
- fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option> {
- None
- }
- fn self_at(&self, _: f64, _: usize) -> Option {
- Some(Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 })
- }
- }
-
- fn run_host(id: &str, img: &Image, over: &[(&str, Value)], host: &ImgHost) -> Image {
- let env = crate::EffectEnv { host: Some(host), frame_rate: 10.0, ..Default::default() };
- crate::run_fx(id, over, img.clone(), 1.0, env).img
- }
-
- #[test]
- fn color_link_samples_clip_and_source_layer() {
- let mut img = Image::new(5, 1);
- for (x, v) in [0.0f32, 0.1, 0.2, 0.3, 1.0].iter().enumerate() {
- img.set(x as u32, 0, [*v, *v, *v, 1.0]);
- }
- // Median ignores the outlier the average follows.
- let med = run("ec.color.colorlink", &img, &[("sampleSource", Value::Enum(1))]);
- assert!((med.data[0][0] - 0.2).abs() < 1e-5);
- // Brightest with 20 % clip skips the brightest pixel.
- let br = run("ec.color.colorlink", &img, &[("sampleSource", Value::Enum(2)), ("clip", num(20.0))]);
- assert!((br.data[0][0] - 0.3).abs() < 1e-5);
- // Min Alpha of a half-transparent source layer sets the alpha.
- let host = ImgHost(Image::filled(2, 2, [0.25, 0.25, 0.25, 0.5]));
- let out = run_host("ec.color.colorlink", &img, &[("sourceLayer", Value::Layer(Some(9))), ("sampleSource", Value::Enum(9))], &host);
- assert!((out.data[4][3] - 0.5).abs() < 1e-5);
- // Average of the source layer (not the effect's own pixels).
- let out = run_host("ec.color.colorlink", &img, &[("sourceLayer", Value::Layer(Some(9)))], &host);
- assert!((out.data[4][0] - 0.5).abs() < 1e-5);
- }
-
- #[test]
- fn auto_levels_temporal_smoothing_reads_neighbour_frames() {
- let mut img = Image::new(4, 1);
- for x in 0..4 {
- let v = 0.3 + 0.1 * x as f32;
- img.set(x, 0, [v, v, v, 1.0]);
- }
- let wide = ImgHost(ramp());
- let p0 = [("blackClip", num(0.0)), ("whiteClip", num(0.0))];
- let alone = run_host("ec.color.autolevels", &img, &p0, &wide);
- let smooth = run_host("ec.color.autolevels", &img, &[p0[0].clone(), p0[1].clone(), ("temporalSmoothing", num(0.2))], &wide);
- // Alone the frame is stretched to full range; with full-range neighbours much less.
- assert!(alone.data[0][0] < 0.01);
- assert!(smooth.data[0][0] > 0.1, "{:?}", smooth.data[0]);
- }
-
- #[test]
- fn shadow_highlight_clip_keeps_the_tonal_range() {
- let img = ramp();
- let lift = [("autoAmounts", Value::Bool(false)), ("shadowAmount", num(80.0))];
- let unclipped = run(
- "ec.color.shadowhighlight",
- &img,
- &[lift[0].clone(), lift[1].clone(), ("moreOptions/blackClip", num(0.0)), ("moreOptions/whiteClip", num(0.0))],
- );
- let clipped = run("ec.color.shadowhighlight", &img, &[lift[0].clone(), lift[1].clone(), ("moreOptions/blackClip", num(1.0))]);
- let min = |im: &Image| im.data.iter().filter(|p| p[3] > 0.99).map(|p| luminance(p[0], p[1], p[2])).fold(f32::MAX, f32::min);
- assert!(min(&clipped) < min(&unclipped));
- }
-}
+mod tests;
diff --git a/crates/effects/src/color2/tests.rs b/crates/effects/src/color2/tests.rs
new file mode 100644
index 000000000..5f57692a0
--- /dev/null
+++ b/crates/effects/src/color2/tests.rs
@@ -0,0 +1,338 @@
+use super::*;
+use crate::{Params, find};
+
+fn run(id: &str, img: &Image, over: &[(&str, Value)]) -> Image {
+ let s = find(id).unwrap();
+ let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+ for (k, v) in over {
+ params.values.insert(k.to_string(), v.clone());
+ }
+ let ctx = EffectCtx { params: ¶ms, time: 0.0, layer_size: [img.width as f64, img.height as f64], seed: 1, adjustment: false, env: Default::default() };
+ (s.render)(&ctx, Buf { img: img.clone(), offset: [0.0, 0.0], scale: 1.0 }).img
+}
+
+fn ramp() -> Image {
+ let mut img = Image::new(16, 8);
+ for y in 0..8 {
+ for x in 0..16 {
+ let v = x as f32 / 15.0;
+ let a = if y == 0 { 0.5 } else { 1.0 };
+ img.set(x, y, [v * a, (1.0 - v) * a, 0.3 * a, a]);
+ }
+ }
+ img
+}
+
+fn close(a: &Image, b: &Image, eps: f32) -> bool {
+ a.data.iter().zip(&b.data).all(|(p, q)| (0..4).all(|i| (p[i] - q[i]).abs() <= eps))
+}
+
+#[test]
+fn curve_parsing() {
+ assert!(Curve::parse("0,0 1,1").is_none());
+ assert!(Curve::parse("garbage").is_none());
+ let c = Curve::parse("1,1; 0,0 0.5,0.7").unwrap();
+ assert_eq!(c.xs, vec![0.0, 0.5, 1.0]);
+ assert!((c.eval(0.5) - 0.7).abs() < 1e-3);
+ // Monotone: never decreases.
+ let mut last = -1.0;
+ for i in 0..=100 {
+ let v = c.eval(i as f32 / 100.0);
+ assert!(v >= last - 1e-6);
+ last = v;
+ }
+}
+
+#[test]
+fn curves_identity_is_identity() {
+ let img = ramp();
+ assert_eq!(run("ec.color.curves", &img, &[]), img);
+ let explicit = run("ec.color.curves", &img, &[("rgb", Value::Str("0,0 0.25,0.25 1,1".into()))]);
+ assert!(close(&explicit, &img, 1e-4));
+}
+
+#[test]
+fn curves_midpoint_brightens() {
+ let img = Image::filled(4, 4, [0.5, 0.5, 0.5, 1.0]);
+ let out = run("ec.color.curves", &img, &[("rgb", Value::Str("0,0 0.5,0.75 1,1".into()))]);
+ assert!((out.data[0][0] - 0.75).abs() < 1e-3);
+ let red = run("ec.color.curves", &img, &[("red", Value::Str("0,1 1,1".into()))]);
+ assert!((red.data[0][0] - 1.0).abs() < 1e-4 && (red.data[0][1] - 0.5).abs() < 1e-6);
+}
+
+/// After Effects 2026, 32 bpc project, Levels (Individual Controls) with RGB Input Black 0.1,
+/// Input White 0.9, Gamma 1.5, Output Black 0.05, Output White 0.95, Red Gamma 0.8, Green
+/// Input White 0.8, Blue Output Black 0.2, both clips "Off for 32 bpc Color", on grey steps:
+/// the channel controls run first, nothing clips (8-bit captures clamp the results).
+#[test]
+fn levels_ic_matches_after_effects_in_32_bpc() {
+ let steps = [0, 16, 32, 64, 96, 128, 160, 192, 224, 255];
+ let ae = [
+ [0, 0, 70],
+ [0, 0, 88],
+ [0, 52, 104],
+ [61, 108, 132],
+ [102, 150, 158],
+ [138, 187, 181],
+ [171, 220, 203],
+ [203, 250, 223],
+ [233, 255, 243],
+ [255, 255, 255],
+ ];
+ let mut img = Image::new(10, 1);
+ for (x, v) in steps.iter().enumerate() {
+ let v = *v as f32 / 255.0;
+ img.set(x as u32, 0, [v, v, v, 1.0]);
+ }
+ let vals = [
+ ("rgb/rgbInBlack", Value::Scalar(0.1)),
+ ("rgb/rgbInWhite", Value::Scalar(0.9)),
+ ("rgb/rgbGamma", Value::Scalar(1.5)),
+ ("rgb/rgbOutBlack", Value::Scalar(0.05)),
+ ("rgb/rgbOutWhite", Value::Scalar(0.95)),
+ ("red/redGamma", Value::Scalar(0.8)),
+ ("green/greenInWhite", Value::Scalar(0.8)),
+ ("blue/blueOutBlack", Value::Scalar(0.2)),
+ ];
+ let s = find("ec.color.levelsic").unwrap();
+ let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+ for (k, v) in &vals {
+ params.values.insert(k.to_string(), v.clone());
+ }
+ let render = |float_depth: bool| {
+ let env = crate::EffectEnv { float_depth, ..Default::default() };
+ let ctx = EffectCtx { params: ¶ms, time: 0.0, layer_size: [10.0, 1.0], seed: 1, adjustment: false, env };
+ (s.render)(&ctx, Buf { img: img.clone(), offset: [0.0, 0.0], scale: 1.0 }).img
+ };
+ let out = render(true);
+ for (x, want) in ae.iter().enumerate() {
+ let p = out.get(x as i64, 0);
+ for c in 0..3 {
+ let got = p[c].clamp(0.0, 1.0) * 255.0;
+ assert!((got - want[c] as f32).abs() <= 2.0, "step {} channel {c}: {got} vs AE {}", steps[x], want[c]);
+ }
+ }
+ // In 8 / 16 bpc "Off for 32 bpc Color" clips: black stops at Output Black.
+ let clipped = render(false);
+ assert!((clipped.get(0, 0)[0] - 0.05).abs() < 1e-5, "{:?}", clipped.get(0, 0));
+}
+
+/// After Effects 2026 (cases 962 / 963): Curves through RGB (0,0) (125,199)
+/// (255,255) and Red (0,0) (128,44) (255,255) on grey steps 0..255, 8-bit results.
+#[test]
+fn curves_follow_a_natural_spline_as_in_after_effects() {
+ let steps = [0u8, 16, 32, 64, 96, 128, 160, 192, 224, 255];
+ let mut img = Image::new(10, 1);
+ for (x, v) in steps.iter().enumerate() {
+ let v = *v as f32 / 255.0;
+ img.set(x as u32, 0, [v, v, v, 1.0]);
+ }
+ let p = |pts: &[(f32, f32)]| Value::Str(pts.iter().map(|(x, y)| format!("{},{}", x / 255.0, y / 255.0)).collect::>().join(" "));
+ let rgb = run("ec.color.curves", &img, &[("rgb", p(&[(0.0, 0.0), (125.0, 199.0), (255.0, 255.0)]))]);
+ let red = run("ec.color.curves", &img, &[("red", p(&[(0.0, 0.0), (128.0, 44.0), (255.0, 255.0)]))]);
+ let ae_rgb = [0, 30, 59, 115, 164, 202, 227, 242, 250, 255];
+ let ae_red = [0, 0, 1, 6, 19, 44, 83, 135, 194, 255];
+ for x in 0..10 {
+ let g = (rgb.get(x as i64, 0)[1] * 255.0).round() as i32;
+ let r = (red.get(x as i64, 0)[0] * 255.0).round() as i32;
+ assert!((g - ae_rgb[x]).abs() <= 1, "RGB step {}: {g} vs AE {}", steps[x], ae_rgb[x]);
+ assert!((r - ae_red[x]).abs() <= 1, "Red step {}: {r} vs AE {}", steps[x], ae_red[x]);
+ }
+}
+
+#[test]
+fn levels_ic_identity_and_red_only() {
+ let img = ramp();
+ assert_eq!(run("ec.color.levelsic", &img, &[]), img);
+ let out = run("ec.color.levelsic", &img, &[("red/redOutWhite", num(0.5))]);
+ let p = out.get(15, 3);
+ assert!((p[0] - 0.5).abs() < 1e-4 && (p[1] - 0.0).abs() < 1e-4);
+}
+
+#[test]
+fn auto_levels_stretches_low_contrast() {
+ let mut img = Image::new(32, 4);
+ for y in 0..4 {
+ for x in 0..32 {
+ let v = 0.4 + 0.2 * x as f32 / 31.0;
+ img.set(x, y, [v, v, v, 1.0]);
+ }
+ }
+ let out = run("ec.color.autolevels", &img, &[("blackClip", num(0.0)), ("whiteClip", num(0.0))]);
+ let lo = out.data.iter().map(|p| p[0]).fold(1.0, f32::min);
+ let hi = out.data.iter().map(|p| p[0]).fold(0.0, f32::max);
+ assert!(lo < 0.02 && hi > 0.98, "{lo} {hi}");
+ let ac = run("ec.color.autocontrast", &img, &[("blackClip", num(0.0)), ("whiteClip", num(0.0))]);
+ assert!(ac.data.iter().map(|p| p[0]).fold(0.0, f32::max) > 0.98);
+}
+
+#[test]
+fn auto_color_neutralises_cast() {
+ let mut img = Image::new(16, 4);
+ for y in 0..4 {
+ for x in 0..16 {
+ let v = x as f32 / 15.0;
+ img.set(x, y, [v * 0.6 + 0.1, v * 0.9, v * 0.5, 1.0]);
+ }
+ }
+ let out = run("ec.color.autocolor", &img, &[]);
+ let p = out.get(8, 1);
+ assert!((p[0] - p[1]).abs() < 0.08 && (p[1] - p[2]).abs() < 0.08, "{p:?}");
+}
+
+#[test]
+fn equalize_flattens_histogram() {
+ let mut img = Image::new(64, 1);
+ for x in 0..64 {
+ let v = if x < 48 { 0.1 + x as f32 * 0.001 } else { 0.9 };
+ img.set(x, 0, [v, v, v, 1.0]);
+ }
+ let out = run("ec.color.equalize", &img, &[]);
+ // The crowded dark values are spread across the range.
+ assert!(out.get(47, 0)[0] > 0.6, "{}", out.get(47, 0)[0]);
+ assert!(out.get(0, 0)[0] < 0.1);
+ assert_eq!(run("ec.color.equalize", &img, &[("amount", num(0.0))]), img);
+}
+
+#[test]
+fn selective_color_zero_is_identity_and_reds_respond() {
+ let img = ramp();
+ assert_eq!(run("ec.color.selectivecolor", &img, &[]), img);
+ let red = Image::filled(2, 2, [1.0, 0.1, 0.1, 1.0]);
+ let out = run("ec.color.selectivecolor", &red, &[("details/reds/redsCyan", num(100.0)), ("method", Value::Enum(1))]);
+ assert!(out.data[0][0] < 0.3, "{:?}", out.data[0]);
+ let blue = Image::filled(2, 2, [0.1, 0.1, 1.0, 1.0]);
+ assert_eq!(run("ec.color.selectivecolor", &blue, &[("details/reds/redsCyan", num(100.0))]), blue);
+}
+
+#[test]
+fn color_offset_full_turn_is_identity() {
+ let img = ramp();
+ let out = run("ec.color.cccoloroffset", &img, &[("redPhase", num(360.0)), ("greenPhase", num(720.0))]);
+ assert_eq!(out, img);
+ let out = run("ec.color.cccoloroffset", &img, &[("redPhase", num(180.0))]);
+ assert!((out.get(0, 3)[0] - 0.5).abs() < 1e-4);
+}
+
+#[test]
+fn broadcast_reduces_unsafe_color() {
+ let img = Image::filled(2, 2, [1.0, 1.0, 0.0, 1.0]);
+ let out = run("ec.color.broadcast", &img, &[]);
+ assert!(out.data[0][0] < 1.0);
+ let key = run("ec.color.broadcast", &img, &[("howToMakeSafe", Value::Enum(2))]);
+ assert_eq!(key.data[0][3], 0.0);
+ let gray = Image::filled(2, 2, [0.5, 0.5, 0.5, 1.0]);
+ assert_eq!(run("ec.color.broadcast", &gray, &[]), gray);
+}
+
+#[test]
+fn color_balance_hls_zero_identity_and_hue_shift() {
+ let img = ramp();
+ assert_eq!(run("ec.color.colorbalancehls", &img, &[]), img);
+ let red = Image::filled(1, 1, [1.0, 0.0, 0.0, 1.0]);
+ let out = run("ec.color.colorbalancehls", &red, &[("hue", num(120.0))]);
+ assert!(out.data[0][1] > 0.99 && out.data[0][0] < 0.01);
+}
+
+#[test]
+fn color_link_fills_with_average_keeping_alpha() {
+ let mut img = Image::new(2, 1);
+ img.set(0, 0, [1.0, 0.0, 0.0, 1.0]);
+ img.set(1, 0, [0.0, 0.0, 0.5, 0.5]);
+ let out = run("ec.color.colorlink", &img, &[]);
+ assert!((out.data[1][3] - 0.5).abs() < 1e-5);
+ let (c, _) = unpremul(out.data[0]);
+ assert!((c[0] - 2.0 / 3.0).abs() < 1e-3 && (c[2] - 1.0 / 3.0).abs() < 1e-3, "{c:?}");
+}
+
+#[test]
+fn cc_kernel_identity_and_toner_duotone() {
+ let img = ramp();
+ assert_eq!(run("ec.color.cckernel", &img, &[]), img);
+ let g = Image::filled(1, 1, [0.5, 0.5, 0.5, 1.0]);
+ let t = run("ec.color.cctoner", &g, &[("tones", Value::Enum(0)), ("highlights", col(1.0, 0.0, 0.0))]);
+ assert!((t.data[0][0] - 0.5).abs() < 1e-3 && t.data[0][1] < 1e-3);
+}
+
+#[test]
+fn shadow_highlight_lifts_shadows() {
+ let img = Image::filled(8, 8, [0.1, 0.1, 0.1, 1.0]);
+ let out = run("ec.color.shadowhighlight", &img, &[("autoAmounts", Value::Bool(false))]);
+ assert!(out.data[0][0] > 0.15);
+}
+
+#[test]
+fn levels_ic_clip_popups() {
+ let img = Image::filled(2, 2, [0.9, 0.9, 0.9, 1.0]);
+ let lv = [("rgb/rgbInWhite", num(0.5))];
+ assert!((run("ec.color.levelsic", &img, &lv).data[0][0] - 1.0).abs() < 1e-6);
+ let off = [("rgb/rgbInWhite", num(0.5)), ("clipToOutputWhite", Value::Enum(0))];
+ assert!(run("ec.color.levelsic", &img, &off).data[0][0] > 1.5);
+}
+
+/// A host whose other layers and other frames are a fixed image.
+struct ImgHost(Image);
+impl crate::EffectHost for ImgHost {
+ fn layer(&self, _: u64, _: bool) -> Option {
+ Some(crate::LayerPixels { buf: Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 }, size: [2.0, 2.0] })
+ }
+ fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option> {
+ None
+ }
+ fn self_at(&self, _: f64, _: usize) -> Option {
+ Some(Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 })
+ }
+}
+
+fn run_host(id: &str, img: &Image, over: &[(&str, Value)], host: &ImgHost) -> Image {
+ let env = crate::EffectEnv { host: Some(host), frame_rate: 10.0, ..Default::default() };
+ crate::run_fx(id, over, img.clone(), 1.0, env).img
+}
+
+#[test]
+fn color_link_samples_clip_and_source_layer() {
+ let mut img = Image::new(5, 1);
+ for (x, v) in [0.0f32, 0.1, 0.2, 0.3, 1.0].iter().enumerate() {
+ img.set(x as u32, 0, [*v, *v, *v, 1.0]);
+ }
+ // Median ignores the outlier the average follows.
+ let med = run("ec.color.colorlink", &img, &[("sampleSource", Value::Enum(1))]);
+ assert!((med.data[0][0] - 0.2).abs() < 1e-5);
+ // Brightest with 20 % clip skips the brightest pixel.
+ let br = run("ec.color.colorlink", &img, &[("sampleSource", Value::Enum(2)), ("clip", num(20.0))]);
+ assert!((br.data[0][0] - 0.3).abs() < 1e-5);
+ // Min Alpha of a half-transparent source layer sets the alpha.
+ let host = ImgHost(Image::filled(2, 2, [0.25, 0.25, 0.25, 0.5]));
+ let out = run_host("ec.color.colorlink", &img, &[("sourceLayer", Value::Layer(Some(9))), ("sampleSource", Value::Enum(9))], &host);
+ assert!((out.data[4][3] - 0.5).abs() < 1e-5);
+ // Average of the source layer (not the effect's own pixels).
+ let out = run_host("ec.color.colorlink", &img, &[("sourceLayer", Value::Layer(Some(9)))], &host);
+ assert!((out.data[4][0] - 0.5).abs() < 1e-5);
+}
+
+#[test]
+fn auto_levels_temporal_smoothing_reads_neighbour_frames() {
+ let mut img = Image::new(4, 1);
+ for x in 0..4 {
+ let v = 0.3 + 0.1 * x as f32;
+ img.set(x, 0, [v, v, v, 1.0]);
+ }
+ let wide = ImgHost(ramp());
+ let p0 = [("blackClip", num(0.0)), ("whiteClip", num(0.0))];
+ let alone = run_host("ec.color.autolevels", &img, &p0, &wide);
+ let smooth = run_host("ec.color.autolevels", &img, &[p0[0].clone(), p0[1].clone(), ("temporalSmoothing", num(0.2))], &wide);
+ // Alone the frame is stretched to full range; with full-range neighbours much less.
+ assert!(alone.data[0][0] < 0.01);
+ assert!(smooth.data[0][0] > 0.1, "{:?}", smooth.data[0]);
+}
+
+#[test]
+fn shadow_highlight_clip_keeps_the_tonal_range() {
+ let img = ramp();
+ let lift = [("autoAmounts", Value::Bool(false)), ("shadowAmount", num(80.0))];
+ let unclipped =
+ run("ec.color.shadowhighlight", &img, &[lift[0].clone(), lift[1].clone(), ("moreOptions/blackClip", num(0.0)), ("moreOptions/whiteClip", num(0.0))]);
+ let clipped = run("ec.color.shadowhighlight", &img, &[lift[0].clone(), lift[1].clone(), ("moreOptions/blackClip", num(1.0))]);
+ let min = |im: &Image| im.data.iter().filter(|p| p[3] > 0.99).map(|p| luminance(p[0], p[1], p[2])).fold(f32::MAX, f32::min);
+ assert!(min(&clipped) < min(&unclipped));
+}
diff --git a/crates/effects/src/color_fx.rs b/crates/effects/src/color_fx.rs
index 402d0ebe2..3a52e7a54 100644
--- a/crates/effects/src/color_fx.rs
+++ b/crates/effects/src/color_fx.rs
@@ -25,7 +25,7 @@ pub(crate) fn luma_601(c: [f32; 3]) -> f32 {
LUMA_601[0] * c[0] + LUMA_601[1] * c[1] + LUMA_601[2] * c[2]
}
-/// The Rec. 601 luma weights of [`luma_601`]. The WGSL kernels repeat them as literals; the GPU
+/// The Rec. 601 luma weights of `luma_601`. The WGSL kernels repeat them as literals; the GPU
/// test `shader_constants_match_the_cpu` checks that they are these.
pub const LUMA_601: [f32; 3] = [0.299, 0.587, 0.114];
@@ -384,7 +384,7 @@ pub fn mirror_pow(v: f32, p: f32) -> f32 {
/// back toward the gray). After Effects 2026 with Tint Color [1, 0.5, 0]: gray 0.1 (a red solid
/// at Reds 10, case 717) → (43, 21, 0), gray 0.6 (yellow at defaults, case 825) → (255, 129, 2),
/// white → white; the old hue / saturation / lightness mix gave (51, 26, 0) for the first.
-/// The luminosity weights of [`bw_tint`] (a Color blend's). `fx_color.wgsl` repeats them; the GPU
+/// The luminosity weights of `bw_tint` (a Color blend's). `fx_color.wgsl` repeats them; the GPU
/// test `shader_constants_match_the_cpu` checks that they are these.
pub const BW_TINT_LUMA: [f32; 3] = [0.3, 0.59, 0.11];
@@ -755,7 +755,7 @@ impl ColoramaPalette {
}
}
- /// Parse "pos:r,g,b[,a] pos:r,g,b …" (positions 0..1, channels 0..1). `None` without stops.
+ /// Parse "pos:r,g,b\[,a\] pos:r,g,b …" (positions 0..1, channels 0..1). `None` without stops.
pub fn parse(s: &str) -> Option {
let mut stops: Vec<(f32, [f32; 4])> = s
.split_whitespace()
@@ -1215,524 +1215,4 @@ pub fn specs() -> Vec {
}
#[cfg(test)]
-mod tests {
- use super::*;
- use crate::{EffectEnv, run_fx};
- use effectcraft_raster::Image;
-
- fn px(id: &str, vals: &[(&str, Value)], c: [f32; 4]) -> [f32; 4] {
- run_fx(id, vals, Image::filled(2, 2, c), 0.0, EffectEnv::default()).img.get(0, 0)
- }
- fn close(a: [f32; 4], b: [f32; 4], eps: f32) -> bool {
- a.iter().zip(b).all(|(x, y)| (x - y).abs() <= eps)
- }
-
- /// Projects saved before Use Legacy / the Photo Filter menu existed keep rendering as before.
- #[test]
- fn old_saves_get_legacy_values_for_added_params() {
- use effectcraft_project::build::Ids;
- let mut next = 1;
- for (id, param, want) in
- [("ec.color.brightnesscontrast", "useLegacy", Value::Bool(true)), ("ec.color.photofilter", "filter", Value::Enum(PHOTO_FILTER_CUSTOM))]
- {
- let spec = crate::find(id).unwrap();
- let mut g = crate::instantiate(spec, &mut Ids(&mut next), spec.name, [10.0, 10.0]);
- g.children.retain(|c| c.match_id() != param);
- crate::migrate::upgrade_instance(spec, &mut g, &mut Ids(&mut next), [10.0, 10.0]);
- assert_eq!(g.get(param).unwrap().value, want, "{id}");
- }
- }
-
- /// After Effects 2026 renders of full-frame solids with Tint at its defaults (sRGB working
- /// space, not linearised, 32 bpc, 8-bit capture): Rec. 601 weights on the encoded values.
- #[test]
- fn tint_defaults_match_after_effects_greys() {
- for (c, want) in [([1.0, 0.0, 0.0], 76.0), ([0.0, 1.0, 0.0], 150.0), ([0.0, 0.0, 1.0], 29.0), ([0.5, 0.5, 0.5], 128.0)] {
- let o = px("ec.color.tint", &[], [c[0], c[1], c[2], 1.0]);
- let want = want / 255.0;
- assert!(close(o, [want, want, want, 1.0], 1.0 / 255.0), "{c:?}: {o:?} vs {want}");
- }
- }
-
- #[test]
- fn colorama_reads_get_phase_from() {
- // Same intensity, different red: Intensity gives one colour, Red gives two.
- let a = [0.6, 0.2, 0.2, 1.0];
- let b = [0.2, 0.2, 0.6, 1.0];
- let red = |c| px("ec.color.colorama", &[("inputPhase/mode", Value::Enum(1))], c);
- assert!(!close(red(a), red(b), 1e-3));
- // Zero maps everything to the start of the cycle (red).
- assert!(close(px("ec.color.colorama", &[("inputPhase/mode", Value::Enum(9))], b), [1.0, 0.0, 0.0, 1.0], 1e-5));
- // Interpolate Palette off posterizes: two nearby inputs land on the same colour.
- let off = |v: f32| px("ec.color.colorama", &[("outputCycle/interpolatePalette", Value::Bool(false))], [v, v, v, 1.0]);
- assert_eq!(off(0.20), off(0.22));
- }
-
- #[test]
- fn brightness_contrast_modern_keeps_black_and_white_and_legacy_is_linear() {
- let bc = |vals: &[(&str, Value)], v: f32| px("ec.color.brightnesscontrast", vals, [v, v, v, 1.0])[0];
- let up = [("brightness", num(50.0)), ("contrast", num(40.0))];
- assert_eq!(bc(&up, 0.0), 0.0);
- assert!((bc(&up, 1.0) - 1.0).abs() < 1e-6);
- assert!(bc(&up, 0.4) > 0.4);
- let legacy = [("brightness", num(50.0)), ("useLegacy", Value::Bool(true))];
- assert!((bc(&legacy, 0.2) - 0.7).abs() < 1e-5);
- assert!((bc(&legacy, 0.0) - 0.5).abs() < 1e-5);
- }
-
- /// After Effects non-legacy ramps (kasper9n, #681). B0 C-100 matched B0 C-50 and is omitted.
- #[test]
- fn brightness_contrast_modern_matches_ae_ramp_samples() {
- let u8 = |v: f32| (v * 255.0).round() as i32;
- let go = |b: f64, c: f64, x: u8| {
- u8(px("ec.color.brightnesscontrast", &[("brightness", num(b)), ("contrast", num(c))], [x as f32 / 255.0, x as f32 / 255.0, x as f32 / 255.0, 1.0])
- [0])
- };
- // (brightness, contrast, input, AE 8-bit)
- let samples: &[(f64, f64, u8, u8)] = &[
- (0.0, 100.0, 64, 40),
- (0.0, 100.0, 128, 129),
- (0.0, 100.0, 192, 217),
- (0.0, 50.0, 64, 53),
- (0.0, 50.0, 192, 205),
- (0.0, -50.0, 64, 77),
- (100.0, 0.0, 128, 209),
- (50.0, 0.0, 128, 171),
- (106.0, -18.0, 128, 214),
- ];
- for &(b, c, x, ae) in samples {
- let got = go(b, c, x);
- assert!((got - ae as i32).abs() <= 10, "B{b} C{c} in {x}: got {got} AE {ae}");
- }
- // Old g=4 S-curve put Contrast 100 at ~8/255 here.
- assert!(go(0.0, 100.0, 64) >= 30);
- }
-
- /// After Effects 2026: Tritone Highlights [1, 1, 0.8], Midtones [0.6, 0.2, 0.2], Shadows
- /// [0, 0, 0.3]. On a red solid with Blend With Original 25 (case 718) AE gives (132, 23, 46);
- /// on a grey ramp (case 815) levels 0, 63.9, 127.6, 191.4 give (0, 0, 77), (77, 26, 64),
- /// (153, 51, 51), (204, 153, 128).
- #[test]
- fn tritone_matches_after_effects() {
- let colours = [
- ("highlights", Value::Color([1.0, 1.0, 0.8, 1.0])),
- ("midtones", Value::Color([0.6, 0.2, 0.2, 1.0])),
- ("shadows", Value::Color([0.0, 0.0, 0.3, 1.0])),
- ];
- let near = |o: [f32; 4], ae: [f32; 3]| (0..3).all(|i| (o[i] * 255.0 - ae[i]).abs() <= 1.0);
- let mut red = colours.to_vec();
- red.push(("blend", num(25.0)));
- let o = px("ec.color.tritone", &red, [1.0, 0.0, 0.0, 1.0]);
- assert!(near(o, [132.0, 23.0, 46.0]), "{:?}", o.map(|v| v * 255.0));
- for (level, ae) in [(0.1f32, [0.0, 0.0, 77.0]), (63.9, [77.0, 26.0, 64.0]), (127.6, [153.0, 51.0, 51.0]), (191.4, [204.0, 153.0, 128.0])] {
- let v = level / 255.0;
- let o = px("ec.color.tritone", &colours, [v, v, v, 1.0]);
- assert!(near(o, ae), "level {level}: {:?} vs {ae:?}", o.map(|v| v * 255.0));
- }
- }
-
- /// After Effects 2026, Tint Color [1, 0.5, 0]: a red solid at Reds 10 (case 717) and yellow
- /// and white solids at the default sliders (case 825).
- #[test]
- fn black_white_tint_matches_after_effects() {
- let tint = [("tint", Value::Bool(true)), ("tintColor", Value::Color([1.0, 0.5, 0.0, 1.0]))];
- let near = |o: [f32; 4], ae: [f32; 3]| (0..3).all(|i| (o[i] * 255.0 - ae[i]).abs() <= 1.5);
- let mut reds = tint.to_vec();
- reds.push(("reds", num(10.0)));
- let o = px("ec.color.blackwhite", &reds, [1.0, 0.0, 0.0, 1.0]);
- assert!(near(o, [43.0, 21.0, 0.0]), "{:?}", o.map(|v| v * 255.0));
- let o = px("ec.color.blackwhite", &tint, [1.0, 1.0, 0.0, 1.0]);
- assert!(near(o, [255.0, 129.0, 2.0]), "{:?}", o.map(|v| v * 255.0));
- let o = px("ec.color.blackwhite", &tint, [1.0, 1.0, 1.0, 1.0]);
- assert!(near(o, [255.0, 255.0, 255.0]), "{:?}", o.map(|v| v * 255.0));
- // Hostile grays stay finite.
- for g in [f32::NAN, -1.0, 0.0, 4.0] {
- assert!(bw_tint([1.0, 0.5, 0.0], g).iter().all(|v| v.is_finite()));
- }
- }
-
- /// After Effects 2026 ramps (RENDERER round 2, session R8): negative Brightness and Contrast
- /// are the inverses of the positive curves. (brightness, contrast, input, AE 8-bit)
- #[test]
- fn negative_brightness_and_contrast_invert_the_positive_curves() {
- let go = |b: f64, c: f64, x: u8| {
- let v = x as f32 / 255.0;
- (px("ec.color.brightnesscontrast", &[("brightness", num(b)), ("contrast", num(c))], [v, v, v, 1.0])[0] * 255.0).round() as i32
- };
- let samples: &[(f64, f64, u8, u8)] = &[
- (-40.0, 0.0, 64, 50),
- (-40.0, 0.0, 128, 99),
- (-40.0, 0.0, 191, 155),
- (-40.0, 0.0, 234, 207),
- (0.0, -50.0, 21, 28),
- (0.0, -50.0, 64, 76),
- (0.0, -50.0, 191, 179),
- (0.0, -50.0, 234, 227),
- (40.0, 0.0, 128, 162),
- (0.0, 50.0, 64, 52),
- ];
- for &(b, c, x, ae) in samples {
- let got = go(b, c, x);
- assert!((got - ae as i32).abs() <= 7, "B{b} C{c} in {x}: got {got} AE {ae}");
- }
- }
-
- /// #1463: Black & White's sliders set the gray of each pure hue and blend between
- /// neighbouring hues; neutral pixels keep their value, overbright ones too, and an overbright
- /// colour stays finite (it used to divide by zero).
- #[test]
- fn black_white_sliders_set_the_gray_of_each_hue() {
- let bw = |vals: &[(&str, Value)], c: [f32; 3]| px("ec.color.blackwhite", vals, [c[0], c[1], c[2], 1.0]);
- let gray = |v: f32| [v, v, v, 1.0];
- // The defaults: Reds 40, Yellows 60, Greens 40, Cyans 60, Blues 20, Magentas 80 (%).
- let hues = [
- ([1.0, 0.0, 0.0], 0.4),
- ([1.0, 1.0, 0.0], 0.6),
- ([0.0, 1.0, 0.0], 0.4),
- ([0.0, 1.0, 1.0], 0.6),
- ([0.0, 0.0, 1.0], 0.2),
- ([1.0, 0.0, 1.0], 0.8),
- // Half as bright, half the gray; orange is halfway from Reds to Yellows.
- ([0.5, 0.0, 0.0], 0.2),
- ([1.0, 0.5, 0.0], 0.5),
- // Neutral pixels keep their value.
- ([0.3, 0.3, 0.3], 0.3),
- ([4.0, 4.0, 4.0], 4.0),
- // An overbright red: its smallest channel plus its chroma at Reds' 40 %.
- ([1.5, 0.5, 0.5], 0.9),
- ];
- for (c, want) in hues {
- let o = bw(&[], c);
- assert!(close(o, gray(want), 1e-5), "{c:?}: {o:?}, want {want}");
- }
- assert!(close(bw(&[("reds", num(120.0))], [1.0, 0.0, 0.0]), gray(1.2), 1e-5));
- assert!(close(bw(&[("reds", num(-200.0))], [1.0, 0.0, 0.0]), gray(0.0), 1e-5));
- assert!(close(bw(&[("blues", num(300.0))], [0.1, 0.1, 0.3]), gray(0.7), 1e-5));
- }
-
- /// #1463: faint colour noise stays faint. The shadows of compressed footage carry a code or
- /// two of colour noise, which Black & White turned into bright and black blocks (the HSL
- /// saturation it scaled is near 1 for any tinted near-black pixel). At 8, 16 and 32 bpc the
- /// gray of a dark ramp with ±2 steps of colour noise stays within 2 steps of the clean ramp's.
- #[test]
- fn black_white_keeps_faint_colour_noise_faint() {
- // A step of 8 bpc, of 16 bpc (After Effects' 0..32768), and a small 32-bpc float one.
- for step in [1.0 / 255.0, 1.0 / 32768.0, 1e-3_f32] {
- let (w, h) = (64u32, 4u32);
- let (mut clean, mut noisy) = (Image::new(w, h), Image::new(w, h));
- for y in 0..h {
- for x in 0..w {
- // A dark ramp up to a quarter gray, in whole steps...
- let v = (x as f32 / w as f32 * 0.25 / step).round() * step;
- // ...and up to ±2 steps of noise per channel, mixed differently in each pixel.
- let n = |k: u32| (((x * 7 + y * 13 + k * 2) % 5) as f32 - 2.0) * step;
- clean.set(x, y, [v, v, v, 1.0]);
- noisy.set(x, y, [(v + n(0)).max(0.0), (v + n(1)).max(0.0), (v + n(2)).max(0.0), 1.0]);
- }
- }
- let bw = |img| run_fx("ec.color.blackwhite", &[], img, 0.0, EffectEnv::default()).img;
- let (a, b) = (bw(clean), bw(noisy));
- let worst = a.data.iter().zip(&b.data).map(|(p, q)| (p[0] - q[0]).abs()).fold(0.0, f32::max);
- assert!(worst <= 2.0 * step + 1e-6, "step {step}: the noise moved the gray by {} steps", worst / step);
- }
- }
-
- #[test]
- fn levels_clips_black_and_white_independently() {
- let lv = |vals: &[(&str, Value)], v: f32| px("ec.color.levels", vals, [v, v, v, 1.0])[0];
- let base = [("inBlack", num(0.2)), ("inWhite", num(0.6)), ("outBlack", num(0.1)), ("outWhite", num(0.9))];
- assert!((lv(&base, 0.9) - 0.9).abs() < 1e-5);
- let mut no_white = base.to_vec();
- no_white.push(("clipToOutputWhite", Value::Enum(0)));
- assert!(lv(&no_white, 0.9) > 0.9);
- assert!((lv(&no_white, 0.0) - 0.1).abs() < 1e-5);
- // The hidden switch of older projects turns both off.
- let mut legacy = base.to_vec();
- legacy.push(("noClip", Value::Bool(true)));
- assert!(lv(&legacy, 0.9) > 0.9);
- }
-
- #[test]
- fn exposure_individual_channels_and_bypass() {
- let g = [0.5, 0.5, 0.5, 1.0];
- let one = px("ec.color.exposure", &[("channels", Value::Enum(1)), ("red/redExposure", num(1.0))], g);
- assert!(one[0] > 0.6 && (one[1] - 0.5).abs() < 1e-5 && (one[2] - 0.5).abs() < 1e-5);
- // Master values are ignored in Individual Channels mode.
- assert!(close(px("ec.color.exposure", &[("channels", Value::Enum(1)), ("master/exposure", num(2.0))], g), g, 1e-5));
- // Bypass Linear Light Conversion: +1 stop doubles the raw value.
- let raw = px("ec.color.exposure", &[("master/exposure", num(1.0)), ("bypassLinearLight", Value::Bool(true))], [0.25, 0.25, 0.25, 1.0]);
- assert!((raw[0] - 0.5).abs() < 1e-5);
- // Negative results are mirrored, not clipped.
- let neg = px(
- "ec.color.exposure",
- &[("master/offset", num(-0.5)), ("bypassLinearLight", Value::Bool(true)), ("master/gamma", num(2.0))],
- [0.25, 0.25, 0.25, 1.0],
- );
- assert!((neg[0] + 0.5).abs() < 1e-4, "{neg:?}");
- }
-
- /// After Effects' Exposure ranges for all twelve sliders; a saved value outside them (a gamma
- /// of 0.05, valid before, as in Photoshop) survives loading and still renders.
- #[test]
- fn exposure_has_after_effects_ranges_and_keeps_old_values() {
- use effectcraft_project::build::Ids;
- let spec = crate::find("ec.color.exposure").unwrap();
- let want = [(-100.0, 100.0, -4.0, 4.0, 2), (-2.0, 2.0, -0.5, 0.5, 4), (0.1, 10.0, 0.1, 10.0, 2)];
- let sliders: Vec<_> = spec
- .params
- .iter()
- .filter_map(|p| match p.ui {
- ParamUi::Slider { min, max, slider_min, slider_max, decimals } => Some((p.id, (min, max, slider_min, slider_max, decimals))),
- _ => None,
- })
- .collect();
- assert_eq!(sliders.len(), 12);
- for (i, (id, r)) in sliders.iter().enumerate() {
- assert_eq!(*r, want[i % 3], "{id}");
- }
- let mut next = 1;
- let mut g = crate::instantiate(spec, &mut Ids(&mut next), spec.name, [10.0, 10.0]);
- let gamma = g.prop_mut("master/gamma").unwrap();
- gamma.value = num(0.05);
- gamma.ui = slider(0.01, 9.99, 0.1, 3.0, 2);
- crate::migrate::upgrade_instance(spec, &mut g, &mut Ids(&mut next), [10.0, 10.0]);
- let gamma = g.prop_mut("master/gamma").unwrap();
- assert_eq!(gamma.value, num(0.05));
- assert!(matches!(gamma.ui, ParamUi::Slider { min, .. } if min == 0.1));
- let o = px("ec.color.exposure", &[("master/gamma", num(0.05)), ("bypassLinearLight", Value::Bool(true))], [0.5, 0.5, 0.5, 1.0]);
- assert!((o[0] - 0.5f32.powf(20.0)).abs() < 1e-9, "{o:?}");
- }
-
- /// Exposure on a red [1, 0, 0] solid against After Effects 2026 renders (sRGB working space,
- /// not linearised, 32 bpc, 8-bit captures): the linear-light conversion is a pure 2.2 power.
- /// The piecewise sRGB curve gave 2 / 7 / 39 for the three smallest Offsets.
- #[test]
- fn exposure_matches_after_effects_gamma_2_2() {
- let red = [1.0, 0.0, 0.0, 1.0];
- let code = |o: [f32; 4], i: usize| o[i] * 255.0;
- // Master Offset only: G and B carry the curve; R goes over 1 (255 in the 8-bit capture).
- for (offset, ae) in [(0.0005, 8.0), (0.002, 15.0), (0.02, 43.0), (0.1, 90.0)] {
- let o = px("ec.color.exposure", &[("master/offset", num(offset))], red);
- for i in [1, 2] {
- assert!((code(o, i) - ae).abs() <= 1.0, "offset {offset}: {} vs AE {ae}", code(o, i));
- }
- assert!(o[0] >= 1.0, "{o:?}");
- }
- // Exposure −2.25: AE 126; with Bypass Linear Light Conversion (gain on encoded values) 54.
- let o = px("ec.color.exposure", &[("master/exposure", num(-2.25))], red);
- assert!((code(o, 0) - 126.0).abs() <= 1.0 && o[1] == 0.0, "{o:?}");
- let o = px("ec.color.exposure", &[("master/exposure", num(-2.25)), ("bypassLinearLight", Value::Bool(true))], red);
- assert!((code(o, 0) - 54.0).abs() <= 1.0 && o[1] == 0.0, "{o:?}");
- // Default settings leave 32-bpc values alone, negative and over-range ones included.
- let hdr = [-0.25, 0.5, 2.0, 1.0];
- assert!(close(px("ec.color.exposure", &[], hdr), hdr, 1e-5));
- // A negative Offset pushes black below zero, mirrored, rather than clipping or NaN.
- let o = px("ec.color.exposure", &[("master/offset", num(-0.02))], [0.0, 0.0, 0.0, 1.0]);
- assert!((o[0] + 0.02f32.powf(1.0 / 2.2)).abs() < 1e-5, "{o:?}");
- }
-
- #[test]
- fn change_to_color_change_modes_tolerances_and_matte() {
- let red = [0.8, 0.1, 0.1, 1.0];
- let green = [0.1, 0.8, 0.1, 1.0];
- let base = [("from", col(0.8, 0.1, 0.1)), ("to", col(0.1, 0.1, 0.8))];
- // Hue only: red turns blue with its own lightness / saturation; green is untouched.
- let o = px("ec.color.changetocolor", &base, red);
- assert!(o[2] > 0.7 && o[0] < 0.2, "{o:?}");
- assert!(close(px("ec.color.changetocolor", &base, green), green, 1e-5));
- // The matte is white where matched, black elsewhere.
- let mut m = base.to_vec();
- m.push(("viewCorrectionMatte", Value::Bool(true)));
- assert!(close(px("ec.color.changetocolor", &m, red), [1.0, 1.0, 1.0, 1.0], 1e-5));
- assert!(close(px("ec.color.changetocolor", &m, green), [0.0, 0.0, 0.0, 1.0], 1e-5));
- // A lightness tolerance of 0 rejects a lighter red.
- let mut strict = m.clone();
- strict.push(("toleranceGroup/lightness", num(0.0)));
- strict.push(("softness", num(0.0)));
- assert!(close(px("ec.color.changetocolor", &strict, [1.0, 0.5, 0.5, 1.0]), [0.0, 0.0, 0.0, 1.0], 1e-5));
- // Hue, Lightness & Saturation, set: a matched pixel becomes the To colour.
- let mut all = base.to_vec();
- all.push(("change", Value::Enum(3)));
- assert!(close(px("ec.color.changetocolor", &all, red), [0.1, 0.1, 0.8, 1.0], 1e-4));
- }
-
- #[test]
- fn leave_color_tolerance_softness_and_match_mode() {
- let green = [0.1, 0.8, 0.1, 1.0];
- let lc = |vals: &[(&str, Value)]| {
- let mut v = vec![("amount", num(100.0))];
- v.extend_from_slice(vals);
- px("ec.color.leavecolor", &v, green)
- };
- let g = luminance(0.1, 0.8, 0.1);
- assert!(close(lc(&[]), [g, g, g, 1.0], 1e-5));
- assert!(close(lc(&[("tolerance", num(100.0))]), green, 1e-6));
- // Softness keeps part of the colour.
- let s = lc(&[("tolerance", num(10.0)), ("edgeSoftness", num(100.0))]);
- assert!(s[1] > g + 0.05 && s[1] < 0.8);
- // Using Hue: a dark red still matches pure red.
- let dark = px("ec.color.leavecolor", &[("amount", num(100.0)), ("tolerance", num(5.0)), ("matchColors", Value::Enum(1))], [0.4, 0.0, 0.0, 1.0]);
- assert!(close(dark, [0.4, 0.0, 0.0, 1.0], 1e-6));
- }
-
- #[test]
- fn photo_filter_presets_and_custom() {
- let g = [0.5, 0.5, 0.5, 1.0];
- let cool = px("ec.color.photofilter", &[("filter", Value::Enum(3)), ("preserveLuminosity", Value::Bool(false))], g);
- assert!(cool[2] > cool[0], "a cooling filter is blue: {cool:?}");
- let custom = |c| px("ec.color.photofilter", &[("filter", Value::Enum(PHOTO_FILTER_CUSTOM)), ("color", c)], g);
- assert!(custom(col(0.0, 1.0, 0.0))[1] > custom(col(1.0, 0.0, 0.0))[1]);
- // The Color swatch is ignored by the presets.
- let warm = |c| px("ec.color.photofilter", &[("color", c)], g);
- assert_eq!(warm(col(0.0, 1.0, 0.0)), warm(col(1.0, 0.0, 0.0)));
- }
-
- #[test]
- fn color_balance_preserve_luminosity_and_black_stretch() {
- let g = [0.5, 0.5, 0.5, 1.0];
- let o = px("ec.color.colorbalance", &[("midRed", num(60.0)), ("preserveLuminosity", Value::Bool(true))], g);
- assert!((luminance(o[0], o[1], o[2]) - 0.5).abs() < 1e-4 && o[0] > o[2]);
- let dark = [0.1, 0.1, 0.1, 1.0];
- assert!(px("ec.color.gammapedestalgain", &[("blackStretch", num(4.0))], dark)[0] > 0.15);
- assert!(close(px("ec.color.gammapedestalgain", &[], dark), dark, 1e-6));
- }
-
- #[test]
- fn levels_channel_controls_act_on_their_channel() {
- let g = [0.5, 0.5, 0.5, 1.0];
- assert!(close(px("ec.color.levels", &[("channel", Value::Enum(1))], g), g, 1e-6), "the popup alone changes nothing");
- let r = px("ec.color.levels", &[("redOutWhite", num(0.5))], g);
- assert!(close(r, [0.25, 0.5, 0.5, 1.0], 1e-5), "{r:?}");
- let b = px("ec.color.levels", &[("blueGamma", num(2.0)), ("inWhite", num(0.5))], [0.25, 0.25, 0.25, 1.0]);
- assert!(close(b, [0.5, 0.5, 0.5f32.sqrt(), 1.0], 1e-5), "RGB first, then blue: {b:?}");
- let a = px("ec.color.levels", &[("alphaOutWhite", num(0.5))], [0.5, 0.5, 0.5, 1.0]);
- assert!(close(a, [0.25, 0.25, 0.25, 0.5], 1e-5), "{a:?}");
- // Per-channel clipping follows its own popups.
- let hot = [0.9, 0.9, 0.9, 1.0];
- let c = px("ec.color.levels", &[("greenInWhite", num(0.5))], hot)[1];
- let nc = px("ec.color.levels", &[("greenInWhite", num(0.5)), ("greenClipToOutputWhite", Value::Enum(0))], hot)[1];
- assert!((c - 1.0).abs() < 1e-6 && (nc - 1.8).abs() < 1e-5, "{c} {nc}");
- }
-
- #[test]
- fn hue_saturation_ranges_adjust_their_hues_only() {
- let red = [0.8, 0.1, 0.1, 1.0];
- let blue = [0.1, 0.1, 0.8, 1.0];
- let grey = [0.5, 0.5, 0.5, 1.0];
- let v = [("redsSaturation", num(-100.0))];
- let r = px("ec.color.huesaturation", &v, red);
- assert!((r[0] - r[1]).abs() < 1e-4, "reds desaturated: {r:?}");
- assert!(close(px("ec.color.huesaturation", &v, blue), blue, 1e-5));
- assert!(close(px("ec.color.huesaturation", &v, grey), grey, 1e-5));
- // Blues hue +120°: blue becomes red.
- let b = px("ec.color.huesaturation", &[("bluesHue", num(120.0))], blue);
- assert!(b[0] > 0.7 && b[2] < 0.2, "{b:?}");
- // Fall-off: a hue 15° past the range end (Reds: −15..15, fall-off 30) gets half.
- let orange_ish = {
- let (r, g, b) = hsl_to_rgb(30.0 / 360.0, 0.8, 0.5);
- [r, g, b, 1.0]
- };
- let o = px("ec.color.huesaturation", &[("redsLightness", num(100.0))], orange_ish);
- let (_, _, l) = rgb_to_hsl(o[0], o[1], o[2]);
- assert!((l - 0.75).abs() < 0.01, "half weight: {l}");
- // Moving the range changes which hues it takes.
- let o2 = px("ec.color.huesaturation", &[("redsLightness", num(100.0)), ("redsRangeEnd", num(40.0))], orange_ish);
- assert!(rgb_to_hsl(o2[0], o2[1], o2[2]).2 > 0.99);
- let params = crate::Params { values: [("redsHue".to_string(), num(10.0))].into_iter().collect() };
- let ctx = EffectCtx { params: ¶ms, time: 0.0, layer_size: [1.0, 1.0], seed: 0, adjustment: false, env: Default::default() };
- assert!(!huesat_ranges_identity(&ctx));
- }
-
- #[test]
- fn fill_mask_all_masks_feather_and_invert() {
- let sq = |x0: f64, x1: f64| crate::MaskShape {
- name: String::new(),
- points: vec![[x0, 0.0], [x1, 0.0], [x1, 10.0], [x0, 10.0]],
- closed: true,
- inverted: false,
- };
- let masks = [sq(0.0, 5.0), sq(15.0, 20.0)];
- let env = EffectEnv { masks: &masks, ..Default::default() };
- let grey = Image::filled(20, 10, [0.5, 0.5, 0.5, 1.0]);
- let run = |vals: &[(&str, Value)]| run_fx("ec.generate.fill", vals, grey.clone(), 0.0, env).img;
- let one = run(&[("fillMask", num(1.0))]);
- assert_eq!(one.get(2, 5), [1.0, 0.0, 0.0, 1.0]);
- assert_eq!(one.get(10, 5), [0.5, 0.5, 0.5, 1.0]);
- assert_eq!(one.get(17, 5), [0.5, 0.5, 0.5, 1.0]);
- let all = run(&[("allMasks", Value::Bool(true))]);
- assert_eq!(all.get(17, 5), [1.0, 0.0, 0.0, 1.0]);
- let inv = run(&[("fillMask", num(1.0)), ("invert", Value::Bool(true))]);
- assert_eq!(inv.get(2, 5), [0.5, 0.5, 0.5, 1.0]);
- assert_eq!(inv.get(10, 5), [1.0, 0.0, 0.0, 1.0]);
- let soft = run(&[("fillMask", num(1.0)), ("horizontalFeather", num(6.0))]);
- let v = soft.get(6, 5)[1];
- assert!(v > 0.05 && v < 0.5, "feathered edge {v}");
- // Without masks, Fill fills the layer as before.
- let plain = run_fx("ec.generate.fill", &[("fillMask", num(1.0))], grey.clone(), 0.0, EffectEnv::default()).img;
- assert_eq!(plain.get(10, 5), [1.0, 0.0, 0.0, 1.0]);
- }
-
- /// After Effects 2026: Fill (0, 0.5, 1) at Opacity 50 % on an opaque layer (a Gradient Ramp
- /// on a red solid) renders premultiplied (0, 0.251, 0.502) at alpha 0.502 everywhere: the
- /// fill colour at half the layer's alpha, nothing of the ramp left.
- #[test]
- fn fill_opacity_is_the_layers_opacity_as_in_after_effects() {
- let mut img = Image::new(16, 4);
- for x in 0..16 {
- let v = x as f32 / 15.0;
- for y in 0..4 {
- img.set(x, y, [v, 0.0, 0.0, 1.0]);
- }
- }
- let vals = [("color", Value::Color([0.0, 0.5, 1.0, 1.0])), ("opacity", num(50.0))];
- let out = run_fx("ec.generate.fill", &vals, img, 0.0, EffectEnv::default()).img;
- for x in [0, 7, 15] {
- let p = out.get(x, 2);
- let ae = [0.0, 0.251, 0.502, 0.502];
- assert!(p.iter().zip(ae).all(|(v, a)| (v - a).abs() < 1.0 / 255.0), "x {x}: {p:?} vs AE {ae:?}");
- }
- // A half-transparent pixel ends at a quarter alpha, still the fill colour.
- let half = run_fx("ec.generate.fill", &vals, Image::filled(2, 2, [0.2, 0.2, 0.2, 0.5]), 0.0, EffectEnv::default()).img;
- assert_eq!(half.get(0, 0), [0.0, 0.125, 0.25, 0.25]);
- }
-
- #[test]
- fn colorama_palettes_modify_selection_masking_and_add_phase() {
- let grey = [0.5, 0.5, 0.5, 1.0];
- let red = [1.0, 0.0, 0.0, 1.0];
- // Ramp Grayscale: intensity 0.5 maps to mid grey.
- let g = px("ec.color.colorama", &[("outputCycle/usePresetPalette", Value::Enum(1))], grey);
- assert!((g[0] - 0.5).abs() < 0.01 && (g[0] - g[2]).abs() < 1e-5, "{g:?}");
- // Custom palette: two stops, black at 0 and blue at 0.5.
- let custom = [("outputCycle/usePresetPalette", Value::Enum(8)), ("outputCycle/palette", Value::Str("0:0,0,0 0.5:0,0,1".into()))];
- let c = px("ec.color.colorama", &custom, grey);
- assert!(c[2] > 0.99 && c[0] < 0.01, "{c:?}");
- // Modify Lightness keeps the hue of the pixel (red stays red).
- let l = px("ec.color.colorama", &[("modify/modify", Value::Enum(5)), ("outputCycle/usePresetPalette", Value::Enum(1))], red);
- assert!(l[0] > l[1] + 0.2 && l[1] < 0.01 + l[2] + 1e-4, "{l:?}");
- // Pixel Selection: only colours near Matching Color change.
- let sel = [
- ("pixelSelection/matchingMode", Value::Enum(1)),
- ("pixelSelection/matchingColor", col(1.0, 0.0, 0.0)),
- ("pixelSelection/matchingTolerance", num(10.0)),
- ];
- assert!(close(px("ec.color.colorama", &sel, grey), grey, 1e-6));
- assert!(!close(px("ec.color.colorama", &sel, red), red, 1e-3));
- // Composite Over Layer off: unselected pixels vanish.
- let mut off = sel.to_vec();
- off.push(("masking/compositeOverLayer", Value::Bool(false)));
- assert_eq!(px("ec.color.colorama", &off, grey)[3], 0.0);
- // Modify Alpha takes the palette alpha.
- let alpha = [
- ("outputCycle/usePresetPalette", Value::Enum(8)),
- ("outputCycle/palette", Value::Str("0:1,1,1,0.25".into())),
- ("modify/modifyAlpha", Value::Bool(true)),
- ];
- assert!((px("ec.color.colorama", &alpha, grey)[3] - 0.25).abs() < 1e-5);
- // Palette parsing and evaluation.
- let p = ColoramaPalette::parse("0.5:0,0,1 0:1,0,0").unwrap();
- assert_eq!(p.eval(0.25, true), [0.5, 0.0, 0.5, 1.0]);
- assert_eq!(p.eval(0.75, true), [0.5, 0.0, 0.5, 1.0], "wraps around");
- assert_eq!(p.eval(0.25, false), [1.0, 0.0, 0.0, 1.0]);
- }
-}
+mod tests;
diff --git a/crates/effects/src/color_fx/tests.rs b/crates/effects/src/color_fx/tests.rs
new file mode 100644
index 000000000..2f3370204
--- /dev/null
+++ b/crates/effects/src/color_fx/tests.rs
@@ -0,0 +1,508 @@
+use super::*;
+use crate::{EffectEnv, run_fx};
+use effectcraft_raster::Image;
+
+fn px(id: &str, vals: &[(&str, Value)], c: [f32; 4]) -> [f32; 4] {
+ run_fx(id, vals, Image::filled(2, 2, c), 0.0, EffectEnv::default()).img.get(0, 0)
+}
+fn close(a: [f32; 4], b: [f32; 4], eps: f32) -> bool {
+ a.iter().zip(b).all(|(x, y)| (x - y).abs() <= eps)
+}
+
+/// Projects saved before Use Legacy / the Photo Filter menu existed keep rendering as before.
+#[test]
+fn old_saves_get_legacy_values_for_added_params() {
+ use effectcraft_project::build::Ids;
+ let mut next = 1;
+ for (id, param, want) in
+ [("ec.color.brightnesscontrast", "useLegacy", Value::Bool(true)), ("ec.color.photofilter", "filter", Value::Enum(PHOTO_FILTER_CUSTOM))]
+ {
+ let spec = crate::find(id).unwrap();
+ let mut g = crate::instantiate(spec, &mut Ids(&mut next), spec.name, [10.0, 10.0]);
+ g.children.retain(|c| c.match_id() != param);
+ crate::migrate::upgrade_instance(spec, &mut g, &mut Ids(&mut next), [10.0, 10.0]);
+ assert_eq!(g.get(param).unwrap().value, want, "{id}");
+ }
+}
+
+/// After Effects 2026 renders of full-frame solids with Tint at its defaults (sRGB working
+/// space, not linearised, 32 bpc, 8-bit capture): Rec. 601 weights on the encoded values.
+#[test]
+fn tint_defaults_match_after_effects_greys() {
+ for (c, want) in [([1.0, 0.0, 0.0], 76.0), ([0.0, 1.0, 0.0], 150.0), ([0.0, 0.0, 1.0], 29.0), ([0.5, 0.5, 0.5], 128.0)] {
+ let o = px("ec.color.tint", &[], [c[0], c[1], c[2], 1.0]);
+ let want = want / 255.0;
+ assert!(close(o, [want, want, want, 1.0], 1.0 / 255.0), "{c:?}: {o:?} vs {want}");
+ }
+}
+
+#[test]
+fn colorama_reads_get_phase_from() {
+ // Same intensity, different red: Intensity gives one colour, Red gives two.
+ let a = [0.6, 0.2, 0.2, 1.0];
+ let b = [0.2, 0.2, 0.6, 1.0];
+ let red = |c| px("ec.color.colorama", &[("inputPhase/mode", Value::Enum(1))], c);
+ assert!(!close(red(a), red(b), 1e-3));
+ // Zero maps everything to the start of the cycle (red).
+ assert!(close(px("ec.color.colorama", &[("inputPhase/mode", Value::Enum(9))], b), [1.0, 0.0, 0.0, 1.0], 1e-5));
+ // Interpolate Palette off posterizes: two nearby inputs land on the same colour.
+ let off = |v: f32| px("ec.color.colorama", &[("outputCycle/interpolatePalette", Value::Bool(false))], [v, v, v, 1.0]);
+ assert_eq!(off(0.20), off(0.22));
+}
+
+#[test]
+fn brightness_contrast_modern_keeps_black_and_white_and_legacy_is_linear() {
+ let bc = |vals: &[(&str, Value)], v: f32| px("ec.color.brightnesscontrast", vals, [v, v, v, 1.0])[0];
+ let up = [("brightness", num(50.0)), ("contrast", num(40.0))];
+ assert_eq!(bc(&up, 0.0), 0.0);
+ assert!((bc(&up, 1.0) - 1.0).abs() < 1e-6);
+ assert!(bc(&up, 0.4) > 0.4);
+ let legacy = [("brightness", num(50.0)), ("useLegacy", Value::Bool(true))];
+ assert!((bc(&legacy, 0.2) - 0.7).abs() < 1e-5);
+ assert!((bc(&legacy, 0.0) - 0.5).abs() < 1e-5);
+}
+
+/// After Effects non-legacy ramps (kasper9n, #681). B0 C-100 matched B0 C-50 and is omitted.
+#[test]
+fn brightness_contrast_modern_matches_ae_ramp_samples() {
+ let u8 = |v: f32| (v * 255.0).round() as i32;
+ let go = |b: f64, c: f64, x: u8| {
+ u8(px("ec.color.brightnesscontrast", &[("brightness", num(b)), ("contrast", num(c))], [x as f32 / 255.0, x as f32 / 255.0, x as f32 / 255.0, 1.0])[0])
+ };
+ // (brightness, contrast, input, AE 8-bit)
+ let samples: &[(f64, f64, u8, u8)] = &[
+ (0.0, 100.0, 64, 40),
+ (0.0, 100.0, 128, 129),
+ (0.0, 100.0, 192, 217),
+ (0.0, 50.0, 64, 53),
+ (0.0, 50.0, 192, 205),
+ (0.0, -50.0, 64, 77),
+ (100.0, 0.0, 128, 209),
+ (50.0, 0.0, 128, 171),
+ (106.0, -18.0, 128, 214),
+ ];
+ for &(b, c, x, ae) in samples {
+ let got = go(b, c, x);
+ assert!((got - ae as i32).abs() <= 10, "B{b} C{c} in {x}: got {got} AE {ae}");
+ }
+ // Old g=4 S-curve put Contrast 100 at ~8/255 here.
+ assert!(go(0.0, 100.0, 64) >= 30);
+}
+
+/// After Effects 2026: Tritone Highlights [1, 1, 0.8], Midtones [0.6, 0.2, 0.2], Shadows
+/// [0, 0, 0.3]. On a red solid with Blend With Original 25 (case 718) AE gives (132, 23, 46);
+/// on a grey ramp (case 815) levels 0, 63.9, 127.6, 191.4 give (0, 0, 77), (77, 26, 64),
+/// (153, 51, 51), (204, 153, 128).
+#[test]
+fn tritone_matches_after_effects() {
+ let colours =
+ [("highlights", Value::Color([1.0, 1.0, 0.8, 1.0])), ("midtones", Value::Color([0.6, 0.2, 0.2, 1.0])), ("shadows", Value::Color([0.0, 0.0, 0.3, 1.0]))];
+ let near = |o: [f32; 4], ae: [f32; 3]| (0..3).all(|i| (o[i] * 255.0 - ae[i]).abs() <= 1.0);
+ let mut red = colours.to_vec();
+ red.push(("blend", num(25.0)));
+ let o = px("ec.color.tritone", &red, [1.0, 0.0, 0.0, 1.0]);
+ assert!(near(o, [132.0, 23.0, 46.0]), "{:?}", o.map(|v| v * 255.0));
+ for (level, ae) in [(0.1f32, [0.0, 0.0, 77.0]), (63.9, [77.0, 26.0, 64.0]), (127.6, [153.0, 51.0, 51.0]), (191.4, [204.0, 153.0, 128.0])] {
+ let v = level / 255.0;
+ let o = px("ec.color.tritone", &colours, [v, v, v, 1.0]);
+ assert!(near(o, ae), "level {level}: {:?} vs {ae:?}", o.map(|v| v * 255.0));
+ }
+}
+
+/// After Effects 2026, Tint Color [1, 0.5, 0]: a red solid at Reds 10 (case 717) and yellow
+/// and white solids at the default sliders (case 825).
+#[test]
+fn black_white_tint_matches_after_effects() {
+ let tint = [("tint", Value::Bool(true)), ("tintColor", Value::Color([1.0, 0.5, 0.0, 1.0]))];
+ let near = |o: [f32; 4], ae: [f32; 3]| (0..3).all(|i| (o[i] * 255.0 - ae[i]).abs() <= 1.5);
+ let mut reds = tint.to_vec();
+ reds.push(("reds", num(10.0)));
+ let o = px("ec.color.blackwhite", &reds, [1.0, 0.0, 0.0, 1.0]);
+ assert!(near(o, [43.0, 21.0, 0.0]), "{:?}", o.map(|v| v * 255.0));
+ let o = px("ec.color.blackwhite", &tint, [1.0, 1.0, 0.0, 1.0]);
+ assert!(near(o, [255.0, 129.0, 2.0]), "{:?}", o.map(|v| v * 255.0));
+ let o = px("ec.color.blackwhite", &tint, [1.0, 1.0, 1.0, 1.0]);
+ assert!(near(o, [255.0, 255.0, 255.0]), "{:?}", o.map(|v| v * 255.0));
+ // Hostile grays stay finite.
+ for g in [f32::NAN, -1.0, 0.0, 4.0] {
+ assert!(bw_tint([1.0, 0.5, 0.0], g).iter().all(|v| v.is_finite()));
+ }
+}
+
+/// After Effects 2026 ramps (RENDERER round 2, session R8): negative Brightness and Contrast
+/// are the inverses of the positive curves. (brightness, contrast, input, AE 8-bit)
+#[test]
+fn negative_brightness_and_contrast_invert_the_positive_curves() {
+ let go = |b: f64, c: f64, x: u8| {
+ let v = x as f32 / 255.0;
+ (px("ec.color.brightnesscontrast", &[("brightness", num(b)), ("contrast", num(c))], [v, v, v, 1.0])[0] * 255.0).round() as i32
+ };
+ let samples: &[(f64, f64, u8, u8)] = &[
+ (-40.0, 0.0, 64, 50),
+ (-40.0, 0.0, 128, 99),
+ (-40.0, 0.0, 191, 155),
+ (-40.0, 0.0, 234, 207),
+ (0.0, -50.0, 21, 28),
+ (0.0, -50.0, 64, 76),
+ (0.0, -50.0, 191, 179),
+ (0.0, -50.0, 234, 227),
+ (40.0, 0.0, 128, 162),
+ (0.0, 50.0, 64, 52),
+ ];
+ for &(b, c, x, ae) in samples {
+ let got = go(b, c, x);
+ assert!((got - ae as i32).abs() <= 7, "B{b} C{c} in {x}: got {got} AE {ae}");
+ }
+}
+
+/// #1463: Black & White's sliders set the gray of each pure hue and blend between
+/// neighbouring hues; neutral pixels keep their value, overbright ones too, and an overbright
+/// colour stays finite (it used to divide by zero).
+#[test]
+fn black_white_sliders_set_the_gray_of_each_hue() {
+ let bw = |vals: &[(&str, Value)], c: [f32; 3]| px("ec.color.blackwhite", vals, [c[0], c[1], c[2], 1.0]);
+ let gray = |v: f32| [v, v, v, 1.0];
+ // The defaults: Reds 40, Yellows 60, Greens 40, Cyans 60, Blues 20, Magentas 80 (%).
+ let hues = [
+ ([1.0, 0.0, 0.0], 0.4),
+ ([1.0, 1.0, 0.0], 0.6),
+ ([0.0, 1.0, 0.0], 0.4),
+ ([0.0, 1.0, 1.0], 0.6),
+ ([0.0, 0.0, 1.0], 0.2),
+ ([1.0, 0.0, 1.0], 0.8),
+ // Half as bright, half the gray; orange is halfway from Reds to Yellows.
+ ([0.5, 0.0, 0.0], 0.2),
+ ([1.0, 0.5, 0.0], 0.5),
+ // Neutral pixels keep their value.
+ ([0.3, 0.3, 0.3], 0.3),
+ ([4.0, 4.0, 4.0], 4.0),
+ // An overbright red: its smallest channel plus its chroma at Reds' 40 %.
+ ([1.5, 0.5, 0.5], 0.9),
+ ];
+ for (c, want) in hues {
+ let o = bw(&[], c);
+ assert!(close(o, gray(want), 1e-5), "{c:?}: {o:?}, want {want}");
+ }
+ assert!(close(bw(&[("reds", num(120.0))], [1.0, 0.0, 0.0]), gray(1.2), 1e-5));
+ assert!(close(bw(&[("reds", num(-200.0))], [1.0, 0.0, 0.0]), gray(0.0), 1e-5));
+ assert!(close(bw(&[("blues", num(300.0))], [0.1, 0.1, 0.3]), gray(0.7), 1e-5));
+}
+
+/// #1463: faint colour noise stays faint. The shadows of compressed footage carry a code or
+/// two of colour noise, which Black & White turned into bright and black blocks (the HSL
+/// saturation it scaled is near 1 for any tinted near-black pixel). At 8, 16 and 32 bpc the
+/// gray of a dark ramp with ±2 steps of colour noise stays within 2 steps of the clean ramp's.
+#[test]
+fn black_white_keeps_faint_colour_noise_faint() {
+ // A step of 8 bpc, of 16 bpc (After Effects' 0..32768), and a small 32-bpc float one.
+ for step in [1.0 / 255.0, 1.0 / 32768.0, 1e-3_f32] {
+ let (w, h) = (64u32, 4u32);
+ let (mut clean, mut noisy) = (Image::new(w, h), Image::new(w, h));
+ for y in 0..h {
+ for x in 0..w {
+ // A dark ramp up to a quarter gray, in whole steps...
+ let v = (x as f32 / w as f32 * 0.25 / step).round() * step;
+ // ...and up to ±2 steps of noise per channel, mixed differently in each pixel.
+ let n = |k: u32| (((x * 7 + y * 13 + k * 2) % 5) as f32 - 2.0) * step;
+ clean.set(x, y, [v, v, v, 1.0]);
+ noisy.set(x, y, [(v + n(0)).max(0.0), (v + n(1)).max(0.0), (v + n(2)).max(0.0), 1.0]);
+ }
+ }
+ let bw = |img| run_fx("ec.color.blackwhite", &[], img, 0.0, EffectEnv::default()).img;
+ let (a, b) = (bw(clean), bw(noisy));
+ let worst = a.data.iter().zip(&b.data).map(|(p, q)| (p[0] - q[0]).abs()).fold(0.0, f32::max);
+ assert!(worst <= 2.0 * step + 1e-6, "step {step}: the noise moved the gray by {} steps", worst / step);
+ }
+}
+
+#[test]
+fn levels_clips_black_and_white_independently() {
+ let lv = |vals: &[(&str, Value)], v: f32| px("ec.color.levels", vals, [v, v, v, 1.0])[0];
+ let base = [("inBlack", num(0.2)), ("inWhite", num(0.6)), ("outBlack", num(0.1)), ("outWhite", num(0.9))];
+ assert!((lv(&base, 0.9) - 0.9).abs() < 1e-5);
+ let mut no_white = base.to_vec();
+ no_white.push(("clipToOutputWhite", Value::Enum(0)));
+ assert!(lv(&no_white, 0.9) > 0.9);
+ assert!((lv(&no_white, 0.0) - 0.1).abs() < 1e-5);
+ // The hidden switch of older projects turns both off.
+ let mut legacy = base.to_vec();
+ legacy.push(("noClip", Value::Bool(true)));
+ assert!(lv(&legacy, 0.9) > 0.9);
+}
+
+#[test]
+fn exposure_individual_channels_and_bypass() {
+ let g = [0.5, 0.5, 0.5, 1.0];
+ let one = px("ec.color.exposure", &[("channels", Value::Enum(1)), ("red/redExposure", num(1.0))], g);
+ assert!(one[0] > 0.6 && (one[1] - 0.5).abs() < 1e-5 && (one[2] - 0.5).abs() < 1e-5);
+ // Master values are ignored in Individual Channels mode.
+ assert!(close(px("ec.color.exposure", &[("channels", Value::Enum(1)), ("master/exposure", num(2.0))], g), g, 1e-5));
+ // Bypass Linear Light Conversion: +1 stop doubles the raw value.
+ let raw = px("ec.color.exposure", &[("master/exposure", num(1.0)), ("bypassLinearLight", Value::Bool(true))], [0.25, 0.25, 0.25, 1.0]);
+ assert!((raw[0] - 0.5).abs() < 1e-5);
+ // Negative results are mirrored, not clipped.
+ let neg =
+ px("ec.color.exposure", &[("master/offset", num(-0.5)), ("bypassLinearLight", Value::Bool(true)), ("master/gamma", num(2.0))], [0.25, 0.25, 0.25, 1.0]);
+ assert!((neg[0] + 0.5).abs() < 1e-4, "{neg:?}");
+}
+
+/// After Effects' Exposure ranges for all twelve sliders; a saved value outside them (a gamma
+/// of 0.05, valid before, as in Photoshop) survives loading and still renders.
+#[test]
+fn exposure_has_after_effects_ranges_and_keeps_old_values() {
+ use effectcraft_project::build::Ids;
+ let spec = crate::find("ec.color.exposure").unwrap();
+ let want = [(-100.0, 100.0, -4.0, 4.0, 2), (-2.0, 2.0, -0.5, 0.5, 4), (0.1, 10.0, 0.1, 10.0, 2)];
+ let sliders: Vec<_> = spec
+ .params
+ .iter()
+ .filter_map(|p| match p.ui {
+ ParamUi::Slider { min, max, slider_min, slider_max, decimals } => Some((p.id, (min, max, slider_min, slider_max, decimals))),
+ _ => None,
+ })
+ .collect();
+ assert_eq!(sliders.len(), 12);
+ for (i, (id, r)) in sliders.iter().enumerate() {
+ assert_eq!(*r, want[i % 3], "{id}");
+ }
+ let mut next = 1;
+ let mut g = crate::instantiate(spec, &mut Ids(&mut next), spec.name, [10.0, 10.0]);
+ let gamma = g.prop_mut("master/gamma").unwrap();
+ gamma.value = num(0.05);
+ gamma.ui = slider(0.01, 9.99, 0.1, 3.0, 2);
+ crate::migrate::upgrade_instance(spec, &mut g, &mut Ids(&mut next), [10.0, 10.0]);
+ let gamma = g.prop_mut("master/gamma").unwrap();
+ assert_eq!(gamma.value, num(0.05));
+ assert!(matches!(gamma.ui, ParamUi::Slider { min, .. } if min == 0.1));
+ let o = px("ec.color.exposure", &[("master/gamma", num(0.05)), ("bypassLinearLight", Value::Bool(true))], [0.5, 0.5, 0.5, 1.0]);
+ assert!((o[0] - 0.5f32.powf(20.0)).abs() < 1e-9, "{o:?}");
+}
+
+/// Exposure on a red [1, 0, 0] solid against After Effects 2026 renders (sRGB working space,
+/// not linearised, 32 bpc, 8-bit captures): the linear-light conversion is a pure 2.2 power.
+/// The piecewise sRGB curve gave 2 / 7 / 39 for the three smallest Offsets.
+#[test]
+fn exposure_matches_after_effects_gamma_2_2() {
+ let red = [1.0, 0.0, 0.0, 1.0];
+ let code = |o: [f32; 4], i: usize| o[i] * 255.0;
+ // Master Offset only: G and B carry the curve; R goes over 1 (255 in the 8-bit capture).
+ for (offset, ae) in [(0.0005, 8.0), (0.002, 15.0), (0.02, 43.0), (0.1, 90.0)] {
+ let o = px("ec.color.exposure", &[("master/offset", num(offset))], red);
+ for i in [1, 2] {
+ assert!((code(o, i) - ae).abs() <= 1.0, "offset {offset}: {} vs AE {ae}", code(o, i));
+ }
+ assert!(o[0] >= 1.0, "{o:?}");
+ }
+ // Exposure −2.25: AE 126; with Bypass Linear Light Conversion (gain on encoded values) 54.
+ let o = px("ec.color.exposure", &[("master/exposure", num(-2.25))], red);
+ assert!((code(o, 0) - 126.0).abs() <= 1.0 && o[1] == 0.0, "{o:?}");
+ let o = px("ec.color.exposure", &[("master/exposure", num(-2.25)), ("bypassLinearLight", Value::Bool(true))], red);
+ assert!((code(o, 0) - 54.0).abs() <= 1.0 && o[1] == 0.0, "{o:?}");
+ // Default settings leave 32-bpc values alone, negative and over-range ones included.
+ let hdr = [-0.25, 0.5, 2.0, 1.0];
+ assert!(close(px("ec.color.exposure", &[], hdr), hdr, 1e-5));
+ // A negative Offset pushes black below zero, mirrored, rather than clipping or NaN.
+ let o = px("ec.color.exposure", &[("master/offset", num(-0.02))], [0.0, 0.0, 0.0, 1.0]);
+ assert!((o[0] + 0.02f32.powf(1.0 / 2.2)).abs() < 1e-5, "{o:?}");
+}
+
+#[test]
+fn change_to_color_change_modes_tolerances_and_matte() {
+ let red = [0.8, 0.1, 0.1, 1.0];
+ let green = [0.1, 0.8, 0.1, 1.0];
+ let base = [("from", col(0.8, 0.1, 0.1)), ("to", col(0.1, 0.1, 0.8))];
+ // Hue only: red turns blue with its own lightness / saturation; green is untouched.
+ let o = px("ec.color.changetocolor", &base, red);
+ assert!(o[2] > 0.7 && o[0] < 0.2, "{o:?}");
+ assert!(close(px("ec.color.changetocolor", &base, green), green, 1e-5));
+ // The matte is white where matched, black elsewhere.
+ let mut m = base.to_vec();
+ m.push(("viewCorrectionMatte", Value::Bool(true)));
+ assert!(close(px("ec.color.changetocolor", &m, red), [1.0, 1.0, 1.0, 1.0], 1e-5));
+ assert!(close(px("ec.color.changetocolor", &m, green), [0.0, 0.0, 0.0, 1.0], 1e-5));
+ // A lightness tolerance of 0 rejects a lighter red.
+ let mut strict = m.clone();
+ strict.push(("toleranceGroup/lightness", num(0.0)));
+ strict.push(("softness", num(0.0)));
+ assert!(close(px("ec.color.changetocolor", &strict, [1.0, 0.5, 0.5, 1.0]), [0.0, 0.0, 0.0, 1.0], 1e-5));
+ // Hue, Lightness & Saturation, set: a matched pixel becomes the To colour.
+ let mut all = base.to_vec();
+ all.push(("change", Value::Enum(3)));
+ assert!(close(px("ec.color.changetocolor", &all, red), [0.1, 0.1, 0.8, 1.0], 1e-4));
+}
+
+#[test]
+fn leave_color_tolerance_softness_and_match_mode() {
+ let green = [0.1, 0.8, 0.1, 1.0];
+ let lc = |vals: &[(&str, Value)]| {
+ let mut v = vec![("amount", num(100.0))];
+ v.extend_from_slice(vals);
+ px("ec.color.leavecolor", &v, green)
+ };
+ let g = luminance(0.1, 0.8, 0.1);
+ assert!(close(lc(&[]), [g, g, g, 1.0], 1e-5));
+ assert!(close(lc(&[("tolerance", num(100.0))]), green, 1e-6));
+ // Softness keeps part of the colour.
+ let s = lc(&[("tolerance", num(10.0)), ("edgeSoftness", num(100.0))]);
+ assert!(s[1] > g + 0.05 && s[1] < 0.8);
+ // Using Hue: a dark red still matches pure red.
+ let dark = px("ec.color.leavecolor", &[("amount", num(100.0)), ("tolerance", num(5.0)), ("matchColors", Value::Enum(1))], [0.4, 0.0, 0.0, 1.0]);
+ assert!(close(dark, [0.4, 0.0, 0.0, 1.0], 1e-6));
+}
+
+#[test]
+fn photo_filter_presets_and_custom() {
+ let g = [0.5, 0.5, 0.5, 1.0];
+ let cool = px("ec.color.photofilter", &[("filter", Value::Enum(3)), ("preserveLuminosity", Value::Bool(false))], g);
+ assert!(cool[2] > cool[0], "a cooling filter is blue: {cool:?}");
+ let custom = |c| px("ec.color.photofilter", &[("filter", Value::Enum(PHOTO_FILTER_CUSTOM)), ("color", c)], g);
+ assert!(custom(col(0.0, 1.0, 0.0))[1] > custom(col(1.0, 0.0, 0.0))[1]);
+ // The Color swatch is ignored by the presets.
+ let warm = |c| px("ec.color.photofilter", &[("color", c)], g);
+ assert_eq!(warm(col(0.0, 1.0, 0.0)), warm(col(1.0, 0.0, 0.0)));
+}
+
+#[test]
+fn color_balance_preserve_luminosity_and_black_stretch() {
+ let g = [0.5, 0.5, 0.5, 1.0];
+ let o = px("ec.color.colorbalance", &[("midRed", num(60.0)), ("preserveLuminosity", Value::Bool(true))], g);
+ assert!((luminance(o[0], o[1], o[2]) - 0.5).abs() < 1e-4 && o[0] > o[2]);
+ let dark = [0.1, 0.1, 0.1, 1.0];
+ assert!(px("ec.color.gammapedestalgain", &[("blackStretch", num(4.0))], dark)[0] > 0.15);
+ assert!(close(px("ec.color.gammapedestalgain", &[], dark), dark, 1e-6));
+}
+
+#[test]
+fn levels_channel_controls_act_on_their_channel() {
+ let g = [0.5, 0.5, 0.5, 1.0];
+ assert!(close(px("ec.color.levels", &[("channel", Value::Enum(1))], g), g, 1e-6), "the popup alone changes nothing");
+ let r = px("ec.color.levels", &[("redOutWhite", num(0.5))], g);
+ assert!(close(r, [0.25, 0.5, 0.5, 1.0], 1e-5), "{r:?}");
+ let b = px("ec.color.levels", &[("blueGamma", num(2.0)), ("inWhite", num(0.5))], [0.25, 0.25, 0.25, 1.0]);
+ assert!(close(b, [0.5, 0.5, 0.5f32.sqrt(), 1.0], 1e-5), "RGB first, then blue: {b:?}");
+ let a = px("ec.color.levels", &[("alphaOutWhite", num(0.5))], [0.5, 0.5, 0.5, 1.0]);
+ assert!(close(a, [0.25, 0.25, 0.25, 0.5], 1e-5), "{a:?}");
+ // Per-channel clipping follows its own popups.
+ let hot = [0.9, 0.9, 0.9, 1.0];
+ let c = px("ec.color.levels", &[("greenInWhite", num(0.5))], hot)[1];
+ let nc = px("ec.color.levels", &[("greenInWhite", num(0.5)), ("greenClipToOutputWhite", Value::Enum(0))], hot)[1];
+ assert!((c - 1.0).abs() < 1e-6 && (nc - 1.8).abs() < 1e-5, "{c} {nc}");
+}
+
+#[test]
+fn hue_saturation_ranges_adjust_their_hues_only() {
+ let red = [0.8, 0.1, 0.1, 1.0];
+ let blue = [0.1, 0.1, 0.8, 1.0];
+ let grey = [0.5, 0.5, 0.5, 1.0];
+ let v = [("redsSaturation", num(-100.0))];
+ let r = px("ec.color.huesaturation", &v, red);
+ assert!((r[0] - r[1]).abs() < 1e-4, "reds desaturated: {r:?}");
+ assert!(close(px("ec.color.huesaturation", &v, blue), blue, 1e-5));
+ assert!(close(px("ec.color.huesaturation", &v, grey), grey, 1e-5));
+ // Blues hue +120°: blue becomes red.
+ let b = px("ec.color.huesaturation", &[("bluesHue", num(120.0))], blue);
+ assert!(b[0] > 0.7 && b[2] < 0.2, "{b:?}");
+ // Fall-off: a hue 15° past the range end (Reds: −15..15, fall-off 30) gets half.
+ let orange_ish = {
+ let (r, g, b) = hsl_to_rgb(30.0 / 360.0, 0.8, 0.5);
+ [r, g, b, 1.0]
+ };
+ let o = px("ec.color.huesaturation", &[("redsLightness", num(100.0))], orange_ish);
+ let (_, _, l) = rgb_to_hsl(o[0], o[1], o[2]);
+ assert!((l - 0.75).abs() < 0.01, "half weight: {l}");
+ // Moving the range changes which hues it takes.
+ let o2 = px("ec.color.huesaturation", &[("redsLightness", num(100.0)), ("redsRangeEnd", num(40.0))], orange_ish);
+ assert!(rgb_to_hsl(o2[0], o2[1], o2[2]).2 > 0.99);
+ let params = crate::Params { values: [("redsHue".to_string(), num(10.0))].into_iter().collect() };
+ let ctx = EffectCtx { params: ¶ms, time: 0.0, layer_size: [1.0, 1.0], seed: 0, adjustment: false, env: Default::default() };
+ assert!(!huesat_ranges_identity(&ctx));
+}
+
+#[test]
+fn fill_mask_all_masks_feather_and_invert() {
+ let sq =
+ |x0: f64, x1: f64| crate::MaskShape { name: String::new(), points: vec![[x0, 0.0], [x1, 0.0], [x1, 10.0], [x0, 10.0]], closed: true, inverted: false };
+ let masks = [sq(0.0, 5.0), sq(15.0, 20.0)];
+ let env = EffectEnv { masks: &masks, ..Default::default() };
+ let grey = Image::filled(20, 10, [0.5, 0.5, 0.5, 1.0]);
+ let run = |vals: &[(&str, Value)]| run_fx("ec.generate.fill", vals, grey.clone(), 0.0, env).img;
+ let one = run(&[("fillMask", num(1.0))]);
+ assert_eq!(one.get(2, 5), [1.0, 0.0, 0.0, 1.0]);
+ assert_eq!(one.get(10, 5), [0.5, 0.5, 0.5, 1.0]);
+ assert_eq!(one.get(17, 5), [0.5, 0.5, 0.5, 1.0]);
+ let all = run(&[("allMasks", Value::Bool(true))]);
+ assert_eq!(all.get(17, 5), [1.0, 0.0, 0.0, 1.0]);
+ let inv = run(&[("fillMask", num(1.0)), ("invert", Value::Bool(true))]);
+ assert_eq!(inv.get(2, 5), [0.5, 0.5, 0.5, 1.0]);
+ assert_eq!(inv.get(10, 5), [1.0, 0.0, 0.0, 1.0]);
+ let soft = run(&[("fillMask", num(1.0)), ("horizontalFeather", num(6.0))]);
+ let v = soft.get(6, 5)[1];
+ assert!(v > 0.05 && v < 0.5, "feathered edge {v}");
+ // Without masks, Fill fills the layer as before.
+ let plain = run_fx("ec.generate.fill", &[("fillMask", num(1.0))], grey.clone(), 0.0, EffectEnv::default()).img;
+ assert_eq!(plain.get(10, 5), [1.0, 0.0, 0.0, 1.0]);
+}
+
+/// After Effects 2026: Fill (0, 0.5, 1) at Opacity 50 % on an opaque layer (a Gradient Ramp
+/// on a red solid) renders premultiplied (0, 0.251, 0.502) at alpha 0.502 everywhere: the
+/// fill colour at half the layer's alpha, nothing of the ramp left.
+#[test]
+fn fill_opacity_is_the_layers_opacity_as_in_after_effects() {
+ let mut img = Image::new(16, 4);
+ for x in 0..16 {
+ let v = x as f32 / 15.0;
+ for y in 0..4 {
+ img.set(x, y, [v, 0.0, 0.0, 1.0]);
+ }
+ }
+ let vals = [("color", Value::Color([0.0, 0.5, 1.0, 1.0])), ("opacity", num(50.0))];
+ let out = run_fx("ec.generate.fill", &vals, img, 0.0, EffectEnv::default()).img;
+ for x in [0, 7, 15] {
+ let p = out.get(x, 2);
+ let ae = [0.0, 0.251, 0.502, 0.502];
+ assert!(p.iter().zip(ae).all(|(v, a)| (v - a).abs() < 1.0 / 255.0), "x {x}: {p:?} vs AE {ae:?}");
+ }
+ // A half-transparent pixel ends at a quarter alpha, still the fill colour.
+ let half = run_fx("ec.generate.fill", &vals, Image::filled(2, 2, [0.2, 0.2, 0.2, 0.5]), 0.0, EffectEnv::default()).img;
+ assert_eq!(half.get(0, 0), [0.0, 0.125, 0.25, 0.25]);
+}
+
+#[test]
+fn colorama_palettes_modify_selection_masking_and_add_phase() {
+ let grey = [0.5, 0.5, 0.5, 1.0];
+ let red = [1.0, 0.0, 0.0, 1.0];
+ // Ramp Grayscale: intensity 0.5 maps to mid grey.
+ let g = px("ec.color.colorama", &[("outputCycle/usePresetPalette", Value::Enum(1))], grey);
+ assert!((g[0] - 0.5).abs() < 0.01 && (g[0] - g[2]).abs() < 1e-5, "{g:?}");
+ // Custom palette: two stops, black at 0 and blue at 0.5.
+ let custom = [("outputCycle/usePresetPalette", Value::Enum(8)), ("outputCycle/palette", Value::Str("0:0,0,0 0.5:0,0,1".into()))];
+ let c = px("ec.color.colorama", &custom, grey);
+ assert!(c[2] > 0.99 && c[0] < 0.01, "{c:?}");
+ // Modify Lightness keeps the hue of the pixel (red stays red).
+ let l = px("ec.color.colorama", &[("modify/modify", Value::Enum(5)), ("outputCycle/usePresetPalette", Value::Enum(1))], red);
+ assert!(l[0] > l[1] + 0.2 && l[1] < 0.01 + l[2] + 1e-4, "{l:?}");
+ // Pixel Selection: only colours near Matching Color change.
+ let sel = [
+ ("pixelSelection/matchingMode", Value::Enum(1)),
+ ("pixelSelection/matchingColor", col(1.0, 0.0, 0.0)),
+ ("pixelSelection/matchingTolerance", num(10.0)),
+ ];
+ assert!(close(px("ec.color.colorama", &sel, grey), grey, 1e-6));
+ assert!(!close(px("ec.color.colorama", &sel, red), red, 1e-3));
+ // Composite Over Layer off: unselected pixels vanish.
+ let mut off = sel.to_vec();
+ off.push(("masking/compositeOverLayer", Value::Bool(false)));
+ assert_eq!(px("ec.color.colorama", &off, grey)[3], 0.0);
+ // Modify Alpha takes the palette alpha.
+ let alpha = [
+ ("outputCycle/usePresetPalette", Value::Enum(8)),
+ ("outputCycle/palette", Value::Str("0:1,1,1,0.25".into())),
+ ("modify/modifyAlpha", Value::Bool(true)),
+ ];
+ assert!((px("ec.color.colorama", &alpha, grey)[3] - 0.25).abs() < 1e-5);
+ // Palette parsing and evaluation.
+ let p = ColoramaPalette::parse("0.5:0,0,1 0:1,0,0").unwrap();
+ assert_eq!(p.eval(0.25, true), [0.5, 0.0, 0.5, 1.0]);
+ assert_eq!(p.eval(0.75, true), [0.5, 0.0, 0.5, 1.0], "wraps around");
+ assert_eq!(p.eval(0.25, false), [1.0, 0.0, 0.0, 1.0]);
+}
diff --git a/crates/effects/src/distort3.rs b/crates/effects/src/distort3.rs
index cb389d901..a02ab5743 100644
--- a/crates/effects/src/distort3.rs
+++ b/crates/effects/src/distort3.rs
@@ -1084,337 +1084,4 @@ pub fn specs() -> Vec {
}
#[cfg(test)]
-mod tests {
- use super::*;
- use crate::{EffectEnv, MaskShape, Params};
-
- fn img(w: u32, h: u32) -> Image {
- crate::util::gen_image(w, h, |x, y| [x as f32 / w as f32, y as f32 / h as f32, ((x * 7 + y * 3) % 11) as f32 / 11.0, 1.0])
- }
-
- /// Run with Point defaults scaled to the layer (like `instantiate`).
- fn run(id: &str, set: &[(&str, Value)], im: Image, masks: &[MaskShape]) -> Buf {
- let s = crate::find(id).unwrap();
- let ls = [im.width as f64, im.height as f64];
- let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
- for ps in &s.params {
- if let (ParamUi::Point, Value::Vec2(v)) = (&ps.ui, &ps.default) {
- params.values.insert(ps.id.to_string(), Value::Vec2([v[0] * ls[0], v[1] * ls[1]]));
- }
- }
- for (k, v) in set {
- assert!(params.values.contains_key(*k), "{id}: {k}");
- params.values.insert(k.to_string(), v.clone());
- }
- let env = EffectEnv { masks, ..Default::default() };
- let ctx = EffectCtx { params: ¶ms, time: 0.5, layer_size: ls, seed: 1, adjustment: false, env };
- crate::apply(s, &ctx, Buf { img: im, offset: [0.0, 0.0], scale: 1.0 })
- }
-
- fn maxd(a: &Image, b: &Image) -> f32 {
- assert_eq!((a.width, a.height), (b.width, b.height));
- a.data.iter().zip(&b.data).map(|(p, q)| (0..4).map(|i| (p[i] - q[i]).abs()).fold(0.0, f32::max)).fold(0.0, f32::max)
- }
-
- fn rect_mask(x0: f64, y0: f64, x1: f64, y1: f64) -> MaskShape {
- MaskShape { name: "m".into(), points: vec![[x0, y0], [x1, y0], [x1, y1], [x0, y1]], closed: true, inverted: false }
- }
-
- #[test]
- fn identity_at_neutral_settings() {
- let im = img(40, 30);
- let cases: &[(&str, Vec<(&str, Value)>)] = &[
- ("ec.distort.ccbender", vec![]),
- ("ec.distort.ccpowerpin", vec![]),
- ("ec.distort.ccripplepulse", vec![]),
- ("ec.distort.ccslant", vec![]),
- ("ec.distort.ccsmear", vec![("reach", num(0.0))]),
- ("ec.distort.ccsplit", vec![("split", num(0.0))]),
- ("ec.distort.ccsplit2", vec![("split1", num(0.0)), ("split2", num(0.0))]),
- ("ec.distort.smear", vec![]),
- ("ec.distort.reshape", vec![]),
- ("ec.distort.twirllegacy", vec![]),
- ("ec.distort.warp", vec![("warpStyle", Value::Enum(5))]),
- ("ec.distort.upscale", vec![]),
- ];
- for (id, set) in cases {
- let o = run(id, set, im.clone(), &[]);
- assert!(maxd(&o.img, &im) < 1e-5, "{id} not identity");
- assert_eq!(o.offset, [0.0, 0.0], "{id}");
- }
- // Power pin with perspective 0 at default corners is also identity.
- let o = run("ec.distort.ccpowerpin", &[("perspective", num(0.0))], im.clone(), &[]);
- assert!(maxd(&o.img, &im) < 1e-4);
- }
-
- #[test]
- fn all_deterministic() {
- let im = img(36, 28);
- let masks = [rect_mask(8.0, 8.0, 16.0, 16.0), rect_mask(12.0, 10.0, 22.0, 20.0), rect_mask(2.0, 2.0, 34.0, 26.0)];
- let cases: &[(&str, Vec<(&str, Value)>)] = &[
- ("ec.distort.ccbender", vec![("amount", num(40.0)), ("style", Value::Enum(3))]),
- ("ec.distort.ccblobbylize", vec![]),
- ("ec.distort.ccpowerpin", vec![("topLeft", pt(5.0, 3.0)), ("perspective", num(40.0))]),
- ("ec.distort.ccripplepulse", vec![("pulseLevel", num(80.0))]),
- ("ec.distort.ccslant", vec![("slant", num(30.0)), ("stretching", Value::Bool(true))]),
- ("ec.distort.ccsmear", vec![]),
- ("ec.distort.ccsplit", vec![]),
- ("ec.distort.ccsplit2", vec![("split2", num(10.0))]),
- ("ec.distort.smear", vec![("sourceMask", Value::Enum(1)), ("boundaryMask", Value::Enum(3)), ("maskOffset", pt(4.0, 2.0))]),
- ("ec.distort.reshape", vec![("sourceMask", Value::Enum(1)), ("destinationMask", Value::Enum(2)), ("boundaryMask", Value::Enum(3))]),
- ("ec.distort.twirllegacy", vec![("angle", num(90.0))]),
- ("ec.distort.warp", vec![("bend", num(50.0)), ("horizontalDistortion", num(20.0))]),
- ("ec.distort.upscale", vec![("scale", num(200.0))]),
- ];
- for (id, set) in cases {
- let a = run(id, set, im.clone(), &masks);
- let b = run(id, set, im.clone(), &masks);
- assert_eq!(a.img, b.img, "{id}");
- assert!(a.img.data.iter().all(|p| p.iter().all(|v| v.is_finite())), "{id}");
- assert!(a.img.width != im.width || a.img.height != im.height || maxd(&a.img, &im) > 1e-3, "{id} did nothing");
- }
- }
-
- #[test]
- fn blobbylize_defaults_match_ae() {
- let s = crate::find("ec.distort.ccblobbylize").unwrap();
- let default = |id: &str| s.params.iter().find(|p| p.id == id).unwrap().default.clone();
- assert_eq!(default("property"), Value::Enum(0), "Property defaults to Red");
- assert_eq!(default("softness"), num(20.0));
- assert_eq!(default("cutAway"), num(25.0));
- assert_eq!(default("lightHeight"), num(65.0));
- assert_eq!(default("lightPosition"), pt(0.5, 0.5));
- assert_eq!(default("ambient"), num(75.0));
- assert_eq!(default("diffuse"), num(25.0));
- assert_eq!(default("specular"), num(100.0));
- assert_eq!(default("roughness"), num(0.025));
- assert_eq!(default("metal"), num(100.0));
- }
-
- #[test]
- fn blobbylize_cut_away_thresholds_a_height_ramp() {
- // AE oracle: Cut Away is a linear height threshold with a ~1 px antialiased edge.
- let im = crate::util::gen_image(1920, 8, |x, _| {
- let h = x as f32 / 1920.0;
- [h, h, h, 1.0]
- });
- let o = run("ec.distort.ccblobbylize", &[("property", Value::Enum(0)), ("softness", num(0.0)), ("cutAway", num(25.0))], im, &[]);
- assert_eq!(o.img.get(400, 4)[3], 0.0, "below Cut Away must be transparent");
- assert_eq!(o.img.get(560, 4)[3], 1.0, "above Cut Away must be opaque");
- let edge = o.img.get(480, 4)[3];
- assert!((0.45..=0.55).contains(&edge), "edge alpha {edge} is not a one-pixel threshold");
- let partial = (450..510).filter(|&x| (0.001..0.999).contains(&o.img.get(x, 4)[3])).count();
- assert!(partial <= 2, "{partial} antialiased columns instead of one");
- }
-
- #[test]
- fn blobbylize_cut_away_100_is_empty() {
- // Regression: the old clamp to 0.99 left the top of the ramp opaque at Cut Away 100.
- let im = crate::util::gen_image(1920, 8, |x, _| {
- let h = x as f32 / 1920.0;
- [h, h, h, 1.0]
- });
- let o = run("ec.distort.ccblobbylize", &[("property", Value::Enum(0)), ("softness", num(0.0)), ("cutAway", num(100.0))], im, &[]);
- assert!(o.img.data.iter().all(|p| p[3] == 0.0), "Cut Away 100 left opaque pixels");
- }
-
- #[test]
- fn blobbylize_cut_away_100_clears_an_opaque_edge() {
- // An opaque source reaches h = 1 on the high side of an edge; the gradient antialias
- // used to leave m = 0.5 there, so Cut Away 100 still produced visible pixels.
- let im = crate::util::gen_image(64, 8, |x, _| if x < 32 { [1.0; 4] } else { [0.0; 4] });
- let o = run("ec.distort.ccblobbylize", &[("property", Value::Enum(3)), ("softness", num(0.0)), ("cutAway", num(100.0))], im, &[]);
- assert!(o.img.data.iter().all(|p| p[3] == 0.0), "Cut Away 100 left an opaque edge");
- }
-
- #[test]
- fn blobbylize_softness_warps_a_step_matte_inward() {
- // AE oracle T2: a self alpha step at x = 960, Softness 20, Cut Away 0 puts the matte
- // edge at about x = 946, not at the source edge. The PR's matte-preserving version
- // left it at 960; the effect must warp the source matte.
- let im = crate::util::gen_image(1920, 32, |x, _| if x < 960 { [1.0; 4] } else { [0.0; 4] });
- let o = run(
- "ec.distort.ccblobbylize",
- &[
- ("property", Value::Enum(3)),
- ("softness", num(20.0)),
- ("cutAway", num(0.0)),
- ("ambient", num(100.0)),
- ("diffuse", num(0.0)),
- ("specular", num(0.0)),
- ("metal", num(0.0)),
- ],
- im,
- &[],
- );
- assert!(o.img.get(945, 16)[3] > 0.95, "the matte did not move inward: {}", o.img.get(945, 16)[3]);
- assert!(o.img.get(949, 16)[3] < 0.05, "source alpha leaked past the warped edge");
- assert_eq!(o.img.get(960, 16)[3], 0.0, "the source matte was preserved instead of warped");
- }
-
- /// A text layer's buffer: 20 × 10 opaque pixels at (90, 45)–(110, 55) of its comp-sized
- /// (200 × 100) layer bounds, after `id` with `set`.
- fn on_text(id: &str, set: &[(&str, Value)]) -> Buf {
- let s = crate::find(id).unwrap();
- let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
- for (k, v) in set {
- assert!(params.values.contains_key(*k), "{id}: {k}");
- params.values.insert(k.to_string(), v.clone());
- }
- let mut im = Image::new(20, 10);
- im.data.iter_mut().for_each(|p| *p = [1.0; 4]);
- let ctx = EffectCtx { params: ¶ms, time: 0.0, layer_size: [200.0, 100.0], seed: 1, adjustment: false, env: Default::default() };
- crate::apply(s, &ctx, Buf { img: im, offset: [-90.0, -45.0], scale: 1.0 })
- }
-
- /// Alpha at layer point `p` (0 outside the buffer).
- fn alpha_at(b: &Buf, p: [f64; 2]) -> f32 {
- let (x, y) = b.to_px(p);
- b.img.get(x.floor() as i64, y.floor() as i64)[3]
- }
-
- /// #659: CC Smear and CC Tiler on a text layer reach past the text's box to the layer bounds
- /// (comp-sized, as in After Effects), not cut off where the glyphs end.
- #[test]
- fn effects_on_text_reach_past_its_box() {
- let smear = on_text("ec.distort.ccsmear", &[("from", pt(100.0, 50.0)), ("to", pt(140.0, 50.0)), ("reach", num(100.0)), ("radius", num(30.0))]);
- assert!(alpha_at(&smear, [130.0, 50.0]) > 0.9, "the smear is cut off at the text's box");
- assert!(smear.img.width < 200, "it grows only as far as pixels move");
- let tiles = on_text("ec.distort.cctiler", &[("scale", num(50.0)), ("center", pt(100.0, 50.0))]);
- assert!(alpha_at(&tiles, [100.0, 50.0]) > 0.9);
- assert!(alpha_at(&tiles, [2.0, 50.0]) > 0.9, "tiles fill the layer bounds");
- assert!(alpha_at(&tiles, [50.0, 50.0]) < 0.1);
- // A footage layer's buffer is its bounds already: no change.
- let o = run("ec.distort.ccsmear", &[], img(40, 30), &[]);
- assert_eq!((o.img.width, o.img.height, o.offset), (40, 30, [0.0, 0.0]));
- }
-
- #[test]
- fn every_warp_style_runs_and_bends() {
- let im = img(40, 30);
- for s in 0..WARP_STYLES.len() as u32 {
- for axis in 0..2 {
- let o = run("ec.distort.warp", &[("warpStyle", Value::Enum(s)), ("warpAxis", Value::Enum(axis)), ("bend", num(50.0))], im.clone(), &[]);
- let pad = o.offset[0] as u32;
- // The layer centre's neighbourhood is still made of source pixels.
- assert!(o.img.get(pad as i64 + 20, pad as i64 + 15)[3] > 0.5, "style {s}");
- assert!(o.img.width > im.width);
- }
- }
- // Arc with positive bend raises the middle of the layer: the top edge in the middle
- // moves up (opaque pixels above the original top).
- let o = run("ec.distort.warp", &[("warpStyle", Value::Enum(3)), ("bend", num(50.0))], im.clone(), &[]);
- let pad = o.offset[1] as i64;
- assert!(o.img.get(o.offset[0] as i64 + 20, pad - 3)[3] > 0.5);
- assert!(o.img.get(o.offset[0] as i64 + 1, pad - 3)[3] < 0.5);
- }
-
- #[test]
- fn power_pin_moves_corners() {
- let im = img(20, 20);
- // Pin to the right half: output x in 10..20 shows the whole layer squeezed.
- let set = [("topLeft", pt(10.0, 0.0)), ("bottomLeft", pt(10.0, 20.0))];
- let o = run("ec.distort.ccpowerpin", &set, im.clone(), &[]);
- assert_eq!(o.img.get(3, 10)[3], 0.0);
- let px = o.img.get(15, 10);
- assert!((px[0] - 0.5).abs() < 0.1, "{px:?}");
- }
-
- #[test]
- fn power_pin_unstretch_expands_pinned_region() {
- let im = crate::util::gen_image(24, 16, |_, _| [1.0, 0.0, 0.0, 1.0]);
- let inset = [("topLeft", pt(6.0, 4.0)), ("topRight", pt(18.0, 4.0)), ("bottomRight", pt(18.0, 12.0)), ("bottomLeft", pt(6.0, 12.0))];
- let opaque = |o: &Buf| o.img.data.iter().filter(|p| p[3] > 0.99).count();
- let off = run("ec.distort.ccpowerpin", &inset, im.clone(), &[]);
- assert_eq!(opaque(&off), 96);
- let mut set = inset.to_vec();
- set.push(("unstretch", Value::Bool(true)));
- let on = run("ec.distort.ccpowerpin", &set, im.clone(), &[]);
- assert_eq!(opaque(&on), 24 * 16);
- assert!(on.img.get(0, 0)[3] > 0.99);
- // Default corners are the identity either way.
- let id = run("ec.distort.ccpowerpin", &[("unstretch", Value::Bool(true))], im.clone(), &[]);
- assert!(maxd(&id.img, &im) < 1e-4);
- }
-
- #[test]
- fn split_opens_a_gap() {
- let im = img(40, 30);
- let o = run("ec.distort.ccsplit", &[("split", num(40.0))], im.clone(), &[]);
- assert_eq!(o.img.get(20, 15)[3], 0.0);
- assert_eq!(o.img.get(2, 2), im.get(2, 2));
- }
-
- #[test]
- fn slant_shears_from_floor() {
- let im = img(20, 20);
- let o = run("ec.distort.ccslant", &[("slant", num(50.0))], im.clone(), &[]);
- let pad = o.offset[0] as i64;
- // Bottom row stays put; the top row shifts right by ~10 px.
- assert!((o.img.get(pad + 5, pad + 19)[0] - im.get(5, 19)[0]).abs() < 0.05);
- assert!((o.img.get(pad + 15, pad)[0] - im.get(5, 0)[0]).abs() < 0.08);
- }
-
- #[test]
- fn reshape_moves_source_to_destination() {
- // A bright square at the source mask; reshape to a shifted destination mask.
- let im = crate::util::gen_image(40, 40, |x, y| if (10..20).contains(&x) && (10..20).contains(&y) { [1.0; 4] } else { [0.0, 0.0, 0.0, 1.0] });
- let masks = [rect_mask(10.0, 10.0, 20.0, 20.0), rect_mask(16.0, 10.0, 26.0, 20.0), rect_mask(0.0, 0.0, 40.0, 40.0)];
- let o = run("ec.distort.reshape", &[("sourceMask", Value::Enum(1)), ("destinationMask", Value::Enum(2)), ("boundaryMask", Value::Enum(3))], im, &masks);
- assert!(o.img.get(24, 15)[0] > 0.8, "{:?}", o.img.get(24, 15));
- assert!(o.img.get(11, 15)[0] < 0.3, "{:?}", o.img.get(11, 15));
- }
-
- #[test]
- fn reshape_correspondence_points_steer_the_match() {
- // Matching outlines with a zero pair change nothing; a quarter-turn offset twists.
- let im = img(40, 40);
- let masks = [rect_mask(10.0, 10.0, 30.0, 30.0), rect_mask(10.0, 10.0, 30.0, 30.0), rect_mask(0.0, 0.0, 40.0, 40.0)];
- let base = [("sourceMask", Value::Enum(1)), ("destinationMask", Value::Enum(2)), ("boundaryMask", Value::Enum(3))];
- let same = run("ec.distort.reshape", &[base.as_slice(), &[("correspondencePoints", Value::Str("0,0".into()))]].concat(), im.clone(), &masks);
- assert!(maxd(&same.img, &im) < 1e-3, "matching outlines: no change");
- let twisted = run("ec.distort.reshape", &[base.as_slice(), &[("correspondencePoints", Value::Str("0.25,0".into()))]].concat(), im.clone(), &masks);
- assert!(maxd(&twisted.img, &im) > 0.1);
- // Fraction mapping.
- assert!((map_fraction(&[(0.0, 0.0), (0.5, 0.25)], 0.125, true) - 0.25).abs() < 1e-9);
- assert!((map_fraction(&[(0.2, 0.0)], 0.9, true) - 0.1).abs() < 1e-9);
- assert!((map_fraction(&[(0.5, 0.5)], 0.25, false) - 0.25).abs() < 1e-9);
- }
-
- #[test]
- fn upscale_grows_about_centre() {
- let im = img(20, 10);
- let o = run("ec.distort.upscale", &[("scale", num(200.0)), ("detail", num(0.0))], im.clone(), &[]);
- assert_eq!((o.img.width, o.img.height), (40, 20));
- // Grown about the layer centre: layer point (0,0) now sits at buffer pixel (10,5), so the
- // centre (10,5) lands in the middle of the 40×20 buffer.
- assert_eq!(o.offset, [10.0, 5.0]);
- let c = o.img.sample_bilinear(20.0, 10.0);
- assert!((c[0] - im.sample_bilinear(10.0, 5.0)[0]).abs() < 0.03);
- }
-
- #[test]
- fn twirl_legacy_rotates_inside_radius() {
- let im = img(40, 40);
- let o = run("ec.distort.twirllegacy", &[("angle", num(180.0)), ("radius", num(100.0))], im.clone(), &[]);
- assert!(maxd(&o.img, &im) > 0.1);
- // Corners lie outside the radius.
- assert_eq!(o.img.get(0, 0), im.get(0, 0));
- }
-
- #[test]
- fn half_resolution_matches_scaled_geometry() {
- // Bender at scale 0.5: the buffer is half size, parameters in layer pixels.
- let s = crate::find("ec.distort.ccbender").unwrap();
- let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
- params.values.insert("amount".into(), num(30.0));
- params.values.insert("top".into(), pt(20.0, 0.0));
- params.values.insert("base".into(), pt(20.0, 40.0));
- let ctx = EffectCtx { params: ¶ms, time: 0.0, layer_size: [40.0, 40.0], seed: 1, adjustment: false, env: Default::default() };
- let full = crate::apply(s, &ctx, Buf { img: img(40, 40), offset: [0.0; 2], scale: 1.0 });
- let half = crate::apply(s, &ctx, Buf { img: effectcraft_raster::resample(&img(40, 40), 20, 20), offset: [0.0; 2], scale: 0.5 });
- let a = full.img.sample_bilinear(20.0, 4.0)[3];
- let b = half.img.sample_bilinear(10.0, 2.0)[3];
- assert!((a - b).abs() < 0.3);
- }
-}
+mod tests;
diff --git a/crates/effects/src/distort3/tests.rs b/crates/effects/src/distort3/tests.rs
new file mode 100644
index 000000000..b50d6b450
--- /dev/null
+++ b/crates/effects/src/distort3/tests.rs
@@ -0,0 +1,332 @@
+use super::*;
+use crate::{EffectEnv, MaskShape, Params};
+
+fn img(w: u32, h: u32) -> Image {
+ crate::util::gen_image(w, h, |x, y| [x as f32 / w as f32, y as f32 / h as f32, ((x * 7 + y * 3) % 11) as f32 / 11.0, 1.0])
+}
+
+/// Run with Point defaults scaled to the layer (like `instantiate`).
+fn run(id: &str, set: &[(&str, Value)], im: Image, masks: &[MaskShape]) -> Buf {
+ let s = crate::find(id).unwrap();
+ let ls = [im.width as f64, im.height as f64];
+ let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+ for ps in &s.params {
+ if let (ParamUi::Point, Value::Vec2(v)) = (&ps.ui, &ps.default) {
+ params.values.insert(ps.id.to_string(), Value::Vec2([v[0] * ls[0], v[1] * ls[1]]));
+ }
+ }
+ for (k, v) in set {
+ assert!(params.values.contains_key(*k), "{id}: {k}");
+ params.values.insert(k.to_string(), v.clone());
+ }
+ let env = EffectEnv { masks, ..Default::default() };
+ let ctx = EffectCtx { params: ¶ms, time: 0.5, layer_size: ls, seed: 1, adjustment: false, env };
+ crate::apply(s, &ctx, Buf { img: im, offset: [0.0, 0.0], scale: 1.0 })
+}
+
+fn maxd(a: &Image, b: &Image) -> f32 {
+ assert_eq!((a.width, a.height), (b.width, b.height));
+ a.data.iter().zip(&b.data).map(|(p, q)| (0..4).map(|i| (p[i] - q[i]).abs()).fold(0.0, f32::max)).fold(0.0, f32::max)
+}
+
+fn rect_mask(x0: f64, y0: f64, x1: f64, y1: f64) -> MaskShape {
+ MaskShape { name: "m".into(), points: vec![[x0, y0], [x1, y0], [x1, y1], [x0, y1]], closed: true, inverted: false }
+}
+
+#[test]
+fn identity_at_neutral_settings() {
+ let im = img(40, 30);
+ let cases: &[(&str, Vec<(&str, Value)>)] = &[
+ ("ec.distort.ccbender", vec![]),
+ ("ec.distort.ccpowerpin", vec![]),
+ ("ec.distort.ccripplepulse", vec![]),
+ ("ec.distort.ccslant", vec![]),
+ ("ec.distort.ccsmear", vec![("reach", num(0.0))]),
+ ("ec.distort.ccsplit", vec![("split", num(0.0))]),
+ ("ec.distort.ccsplit2", vec![("split1", num(0.0)), ("split2", num(0.0))]),
+ ("ec.distort.smear", vec![]),
+ ("ec.distort.reshape", vec![]),
+ ("ec.distort.twirllegacy", vec![]),
+ ("ec.distort.warp", vec![("warpStyle", Value::Enum(5))]),
+ ("ec.distort.upscale", vec![]),
+ ];
+ for (id, set) in cases {
+ let o = run(id, set, im.clone(), &[]);
+ assert!(maxd(&o.img, &im) < 1e-5, "{id} not identity");
+ assert_eq!(o.offset, [0.0, 0.0], "{id}");
+ }
+ // Power pin with perspective 0 at default corners is also identity.
+ let o = run("ec.distort.ccpowerpin", &[("perspective", num(0.0))], im.clone(), &[]);
+ assert!(maxd(&o.img, &im) < 1e-4);
+}
+
+#[test]
+fn all_deterministic() {
+ let im = img(36, 28);
+ let masks = [rect_mask(8.0, 8.0, 16.0, 16.0), rect_mask(12.0, 10.0, 22.0, 20.0), rect_mask(2.0, 2.0, 34.0, 26.0)];
+ let cases: &[(&str, Vec<(&str, Value)>)] = &[
+ ("ec.distort.ccbender", vec![("amount", num(40.0)), ("style", Value::Enum(3))]),
+ ("ec.distort.ccblobbylize", vec![]),
+ ("ec.distort.ccpowerpin", vec![("topLeft", pt(5.0, 3.0)), ("perspective", num(40.0))]),
+ ("ec.distort.ccripplepulse", vec![("pulseLevel", num(80.0))]),
+ ("ec.distort.ccslant", vec![("slant", num(30.0)), ("stretching", Value::Bool(true))]),
+ ("ec.distort.ccsmear", vec![]),
+ ("ec.distort.ccsplit", vec![]),
+ ("ec.distort.ccsplit2", vec![("split2", num(10.0))]),
+ ("ec.distort.smear", vec![("sourceMask", Value::Enum(1)), ("boundaryMask", Value::Enum(3)), ("maskOffset", pt(4.0, 2.0))]),
+ ("ec.distort.reshape", vec![("sourceMask", Value::Enum(1)), ("destinationMask", Value::Enum(2)), ("boundaryMask", Value::Enum(3))]),
+ ("ec.distort.twirllegacy", vec![("angle", num(90.0))]),
+ ("ec.distort.warp", vec![("bend", num(50.0)), ("horizontalDistortion", num(20.0))]),
+ ("ec.distort.upscale", vec![("scale", num(200.0))]),
+ ];
+ for (id, set) in cases {
+ let a = run(id, set, im.clone(), &masks);
+ let b = run(id, set, im.clone(), &masks);
+ assert_eq!(a.img, b.img, "{id}");
+ assert!(a.img.data.iter().all(|p| p.iter().all(|v| v.is_finite())), "{id}");
+ assert!(a.img.width != im.width || a.img.height != im.height || maxd(&a.img, &im) > 1e-3, "{id} did nothing");
+ }
+}
+
+#[test]
+fn blobbylize_defaults_match_ae() {
+ let s = crate::find("ec.distort.ccblobbylize").unwrap();
+ let default = |id: &str| s.params.iter().find(|p| p.id == id).unwrap().default.clone();
+ assert_eq!(default("property"), Value::Enum(0), "Property defaults to Red");
+ assert_eq!(default("softness"), num(20.0));
+ assert_eq!(default("cutAway"), num(25.0));
+ assert_eq!(default("lightHeight"), num(65.0));
+ assert_eq!(default("lightPosition"), pt(0.5, 0.5));
+ assert_eq!(default("ambient"), num(75.0));
+ assert_eq!(default("diffuse"), num(25.0));
+ assert_eq!(default("specular"), num(100.0));
+ assert_eq!(default("roughness"), num(0.025));
+ assert_eq!(default("metal"), num(100.0));
+}
+
+#[test]
+fn blobbylize_cut_away_thresholds_a_height_ramp() {
+ // AE oracle: Cut Away is a linear height threshold with a ~1 px antialiased edge.
+ let im = crate::util::gen_image(1920, 8, |x, _| {
+ let h = x as f32 / 1920.0;
+ [h, h, h, 1.0]
+ });
+ let o = run("ec.distort.ccblobbylize", &[("property", Value::Enum(0)), ("softness", num(0.0)), ("cutAway", num(25.0))], im, &[]);
+ assert_eq!(o.img.get(400, 4)[3], 0.0, "below Cut Away must be transparent");
+ assert_eq!(o.img.get(560, 4)[3], 1.0, "above Cut Away must be opaque");
+ let edge = o.img.get(480, 4)[3];
+ assert!((0.45..=0.55).contains(&edge), "edge alpha {edge} is not a one-pixel threshold");
+ let partial = (450..510).filter(|&x| (0.001..0.999).contains(&o.img.get(x, 4)[3])).count();
+ assert!(partial <= 2, "{partial} antialiased columns instead of one");
+}
+
+#[test]
+fn blobbylize_cut_away_100_is_empty() {
+ // Regression: the old clamp to 0.99 left the top of the ramp opaque at Cut Away 100.
+ let im = crate::util::gen_image(1920, 8, |x, _| {
+ let h = x as f32 / 1920.0;
+ [h, h, h, 1.0]
+ });
+ let o = run("ec.distort.ccblobbylize", &[("property", Value::Enum(0)), ("softness", num(0.0)), ("cutAway", num(100.0))], im, &[]);
+ assert!(o.img.data.iter().all(|p| p[3] == 0.0), "Cut Away 100 left opaque pixels");
+}
+
+#[test]
+fn blobbylize_cut_away_100_clears_an_opaque_edge() {
+ // An opaque source reaches h = 1 on the high side of an edge; the gradient antialias
+ // used to leave m = 0.5 there, so Cut Away 100 still produced visible pixels.
+ let im = crate::util::gen_image(64, 8, |x, _| if x < 32 { [1.0; 4] } else { [0.0; 4] });
+ let o = run("ec.distort.ccblobbylize", &[("property", Value::Enum(3)), ("softness", num(0.0)), ("cutAway", num(100.0))], im, &[]);
+ assert!(o.img.data.iter().all(|p| p[3] == 0.0), "Cut Away 100 left an opaque edge");
+}
+
+#[test]
+fn blobbylize_softness_warps_a_step_matte_inward() {
+ // AE oracle T2: a self alpha step at x = 960, Softness 20, Cut Away 0 puts the matte
+ // edge at about x = 946, not at the source edge. The PR's matte-preserving version
+ // left it at 960; the effect must warp the source matte.
+ let im = crate::util::gen_image(1920, 32, |x, _| if x < 960 { [1.0; 4] } else { [0.0; 4] });
+ let o = run(
+ "ec.distort.ccblobbylize",
+ &[
+ ("property", Value::Enum(3)),
+ ("softness", num(20.0)),
+ ("cutAway", num(0.0)),
+ ("ambient", num(100.0)),
+ ("diffuse", num(0.0)),
+ ("specular", num(0.0)),
+ ("metal", num(0.0)),
+ ],
+ im,
+ &[],
+ );
+ assert!(o.img.get(945, 16)[3] > 0.95, "the matte did not move inward: {}", o.img.get(945, 16)[3]);
+ assert!(o.img.get(949, 16)[3] < 0.05, "source alpha leaked past the warped edge");
+ assert_eq!(o.img.get(960, 16)[3], 0.0, "the source matte was preserved instead of warped");
+}
+
+/// A text layer's buffer: 20 × 10 opaque pixels at (90, 45)–(110, 55) of its comp-sized
+/// (200 × 100) layer bounds, after `id` with `set`.
+fn on_text(id: &str, set: &[(&str, Value)]) -> Buf {
+ let s = crate::find(id).unwrap();
+ let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+ for (k, v) in set {
+ assert!(params.values.contains_key(*k), "{id}: {k}");
+ params.values.insert(k.to_string(), v.clone());
+ }
+ let mut im = Image::new(20, 10);
+ im.data.iter_mut().for_each(|p| *p = [1.0; 4]);
+ let ctx = EffectCtx { params: ¶ms, time: 0.0, layer_size: [200.0, 100.0], seed: 1, adjustment: false, env: Default::default() };
+ crate::apply(s, &ctx, Buf { img: im, offset: [-90.0, -45.0], scale: 1.0 })
+}
+
+/// Alpha at layer point `p` (0 outside the buffer).
+fn alpha_at(b: &Buf, p: [f64; 2]) -> f32 {
+ let (x, y) = b.to_px(p);
+ b.img.get(x.floor() as i64, y.floor() as i64)[3]
+}
+
+/// #659: CC Smear and CC Tiler on a text layer reach past the text's box to the layer bounds
+/// (comp-sized, as in After Effects), not cut off where the glyphs end.
+#[test]
+fn effects_on_text_reach_past_its_box() {
+ let smear = on_text("ec.distort.ccsmear", &[("from", pt(100.0, 50.0)), ("to", pt(140.0, 50.0)), ("reach", num(100.0)), ("radius", num(30.0))]);
+ assert!(alpha_at(&smear, [130.0, 50.0]) > 0.9, "the smear is cut off at the text's box");
+ assert!(smear.img.width < 200, "it grows only as far as pixels move");
+ let tiles = on_text("ec.distort.cctiler", &[("scale", num(50.0)), ("center", pt(100.0, 50.0))]);
+ assert!(alpha_at(&tiles, [100.0, 50.0]) > 0.9);
+ assert!(alpha_at(&tiles, [2.0, 50.0]) > 0.9, "tiles fill the layer bounds");
+ assert!(alpha_at(&tiles, [50.0, 50.0]) < 0.1);
+ // A footage layer's buffer is its bounds already: no change.
+ let o = run("ec.distort.ccsmear", &[], img(40, 30), &[]);
+ assert_eq!((o.img.width, o.img.height, o.offset), (40, 30, [0.0, 0.0]));
+}
+
+#[test]
+fn every_warp_style_runs_and_bends() {
+ let im = img(40, 30);
+ for s in 0..WARP_STYLES.len() as u32 {
+ for axis in 0..2 {
+ let o = run("ec.distort.warp", &[("warpStyle", Value::Enum(s)), ("warpAxis", Value::Enum(axis)), ("bend", num(50.0))], im.clone(), &[]);
+ let pad = o.offset[0] as u32;
+ // The layer centre's neighbourhood is still made of source pixels.
+ assert!(o.img.get(pad as i64 + 20, pad as i64 + 15)[3] > 0.5, "style {s}");
+ assert!(o.img.width > im.width);
+ }
+ }
+ // Arc with positive bend raises the middle of the layer: the top edge in the middle
+ // moves up (opaque pixels above the original top).
+ let o = run("ec.distort.warp", &[("warpStyle", Value::Enum(3)), ("bend", num(50.0))], im.clone(), &[]);
+ let pad = o.offset[1] as i64;
+ assert!(o.img.get(o.offset[0] as i64 + 20, pad - 3)[3] > 0.5);
+ assert!(o.img.get(o.offset[0] as i64 + 1, pad - 3)[3] < 0.5);
+}
+
+#[test]
+fn power_pin_moves_corners() {
+ let im = img(20, 20);
+ // Pin to the right half: output x in 10..20 shows the whole layer squeezed.
+ let set = [("topLeft", pt(10.0, 0.0)), ("bottomLeft", pt(10.0, 20.0))];
+ let o = run("ec.distort.ccpowerpin", &set, im.clone(), &[]);
+ assert_eq!(o.img.get(3, 10)[3], 0.0);
+ let px = o.img.get(15, 10);
+ assert!((px[0] - 0.5).abs() < 0.1, "{px:?}");
+}
+
+#[test]
+fn power_pin_unstretch_expands_pinned_region() {
+ let im = crate::util::gen_image(24, 16, |_, _| [1.0, 0.0, 0.0, 1.0]);
+ let inset = [("topLeft", pt(6.0, 4.0)), ("topRight", pt(18.0, 4.0)), ("bottomRight", pt(18.0, 12.0)), ("bottomLeft", pt(6.0, 12.0))];
+ let opaque = |o: &Buf| o.img.data.iter().filter(|p| p[3] > 0.99).count();
+ let off = run("ec.distort.ccpowerpin", &inset, im.clone(), &[]);
+ assert_eq!(opaque(&off), 96);
+ let mut set = inset.to_vec();
+ set.push(("unstretch", Value::Bool(true)));
+ let on = run("ec.distort.ccpowerpin", &set, im.clone(), &[]);
+ assert_eq!(opaque(&on), 24 * 16);
+ assert!(on.img.get(0, 0)[3] > 0.99);
+ // Default corners are the identity either way.
+ let id = run("ec.distort.ccpowerpin", &[("unstretch", Value::Bool(true))], im.clone(), &[]);
+ assert!(maxd(&id.img, &im) < 1e-4);
+}
+
+#[test]
+fn split_opens_a_gap() {
+ let im = img(40, 30);
+ let o = run("ec.distort.ccsplit", &[("split", num(40.0))], im.clone(), &[]);
+ assert_eq!(o.img.get(20, 15)[3], 0.0);
+ assert_eq!(o.img.get(2, 2), im.get(2, 2));
+}
+
+#[test]
+fn slant_shears_from_floor() {
+ let im = img(20, 20);
+ let o = run("ec.distort.ccslant", &[("slant", num(50.0))], im.clone(), &[]);
+ let pad = o.offset[0] as i64;
+ // Bottom row stays put; the top row shifts right by ~10 px.
+ assert!((o.img.get(pad + 5, pad + 19)[0] - im.get(5, 19)[0]).abs() < 0.05);
+ assert!((o.img.get(pad + 15, pad)[0] - im.get(5, 0)[0]).abs() < 0.08);
+}
+
+#[test]
+fn reshape_moves_source_to_destination() {
+ // A bright square at the source mask; reshape to a shifted destination mask.
+ let im = crate::util::gen_image(40, 40, |x, y| if (10..20).contains(&x) && (10..20).contains(&y) { [1.0; 4] } else { [0.0, 0.0, 0.0, 1.0] });
+ let masks = [rect_mask(10.0, 10.0, 20.0, 20.0), rect_mask(16.0, 10.0, 26.0, 20.0), rect_mask(0.0, 0.0, 40.0, 40.0)];
+ let o = run("ec.distort.reshape", &[("sourceMask", Value::Enum(1)), ("destinationMask", Value::Enum(2)), ("boundaryMask", Value::Enum(3))], im, &masks);
+ assert!(o.img.get(24, 15)[0] > 0.8, "{:?}", o.img.get(24, 15));
+ assert!(o.img.get(11, 15)[0] < 0.3, "{:?}", o.img.get(11, 15));
+}
+
+#[test]
+fn reshape_correspondence_points_steer_the_match() {
+ // Matching outlines with a zero pair change nothing; a quarter-turn offset twists.
+ let im = img(40, 40);
+ let masks = [rect_mask(10.0, 10.0, 30.0, 30.0), rect_mask(10.0, 10.0, 30.0, 30.0), rect_mask(0.0, 0.0, 40.0, 40.0)];
+ let base = [("sourceMask", Value::Enum(1)), ("destinationMask", Value::Enum(2)), ("boundaryMask", Value::Enum(3))];
+ let same = run("ec.distort.reshape", &[base.as_slice(), &[("correspondencePoints", Value::Str("0,0".into()))]].concat(), im.clone(), &masks);
+ assert!(maxd(&same.img, &im) < 1e-3, "matching outlines: no change");
+ let twisted = run("ec.distort.reshape", &[base.as_slice(), &[("correspondencePoints", Value::Str("0.25,0".into()))]].concat(), im.clone(), &masks);
+ assert!(maxd(&twisted.img, &im) > 0.1);
+ // Fraction mapping.
+ assert!((map_fraction(&[(0.0, 0.0), (0.5, 0.25)], 0.125, true) - 0.25).abs() < 1e-9);
+ assert!((map_fraction(&[(0.2, 0.0)], 0.9, true) - 0.1).abs() < 1e-9);
+ assert!((map_fraction(&[(0.5, 0.5)], 0.25, false) - 0.25).abs() < 1e-9);
+}
+
+#[test]
+fn upscale_grows_about_centre() {
+ let im = img(20, 10);
+ let o = run("ec.distort.upscale", &[("scale", num(200.0)), ("detail", num(0.0))], im.clone(), &[]);
+ assert_eq!((o.img.width, o.img.height), (40, 20));
+ // Grown about the layer centre: layer point (0,0) now sits at buffer pixel (10,5), so the
+ // centre (10,5) lands in the middle of the 40×20 buffer.
+ assert_eq!(o.offset, [10.0, 5.0]);
+ let c = o.img.sample_bilinear(20.0, 10.0);
+ assert!((c[0] - im.sample_bilinear(10.0, 5.0)[0]).abs() < 0.03);
+}
+
+#[test]
+fn twirl_legacy_rotates_inside_radius() {
+ let im = img(40, 40);
+ let o = run("ec.distort.twirllegacy", &[("angle", num(180.0)), ("radius", num(100.0))], im.clone(), &[]);
+ assert!(maxd(&o.img, &im) > 0.1);
+ // Corners lie outside the radius.
+ assert_eq!(o.img.get(0, 0), im.get(0, 0));
+}
+
+#[test]
+fn half_resolution_matches_scaled_geometry() {
+ // Bender at scale 0.5: the buffer is half size, parameters in layer pixels.
+ let s = crate::find("ec.distort.ccbender").unwrap();
+ let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+ params.values.insert("amount".into(), num(30.0));
+ params.values.insert("top".into(), pt(20.0, 0.0));
+ params.values.insert("base".into(), pt(20.0, 40.0));
+ let ctx = EffectCtx { params: ¶ms, time: 0.0, layer_size: [40.0, 40.0], seed: 1, adjustment: false, env: Default::default() };
+ let full = crate::apply(s, &ctx, Buf { img: img(40, 40), offset: [0.0; 2], scale: 1.0 });
+ let half = crate::apply(s, &ctx, Buf { img: effectcraft_raster::resample(&img(40, 40), 20, 20), offset: [0.0; 2], scale: 0.5 });
+ let a = full.img.sample_bilinear(20.0, 4.0)[3];
+ let b = half.img.sample_bilinear(10.0, 2.0)[3];
+ assert!((a - b).abs() < 0.3);
+}
diff --git a/crates/effects/src/generate2.rs b/crates/effects/src/generate2.rs
index 80d32ce0e..62bce1706 100644
--- a/crates/effects/src/generate2.rs
+++ b/crates/effects/src/generate2.rs
@@ -61,7 +61,7 @@ const CELL_PATTERNS: [&str; 12] = [
"Tubular",
];
-/// Shaping used for Cell Pattern option `i` (see [`cell_value`]).
+/// Shaping used for Cell Pattern option `i` (see `cell_value`).
pub fn pattern_kind(i: u32) -> u32 {
match i {
0..=5 => i,
@@ -1223,315 +1223,4 @@ pub fn specs() -> Vec {
}
#[cfg(test)]
-mod tests {
- use super::*;
- use crate::Params;
- use effectcraft_raster::Image;
-
- fn run(id: &str, set: &[(&str, Value)], img: Image) -> Buf {
- let s = crate::find(id).unwrap();
- let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
- let ls = [img.width as f64, img.height as f64];
- for p in &s.params {
- if let (ParamUi::Point, Value::Vec2(v)) = (&p.ui, &p.default) {
- params.values.insert(p.id.to_string(), Value::Vec2([v[0] * ls[0], v[1] * ls[1]]));
- }
- }
- for (k, v) in set {
- params.values.insert(k.to_string(), v.clone());
- }
- let ctx = EffectCtx { params: ¶ms, time: 0.5, layer_size: ls, seed: 3, adjustment: false, env: Default::default() };
- crate::apply(s, &ctx, Buf { img, offset: [0.0, 0.0], scale: 1.0 })
- }
-
- #[test]
- fn cell_pattern_is_deterministic_and_seeded() {
- let a = run("ec.generate.cellpattern", &[("size", num(10.0))], Image::new(40, 30));
- let b2 = run("ec.generate.cellpattern", &[("size", num(10.0))], Image::new(40, 30));
- assert_eq!(a.img, b2.img);
- let c = run("ec.generate.cellpattern", &[("size", num(10.0)), ("evolutionOptions/randomSeed", num(5.0))], Image::new(40, 30));
- assert_ne!(a.img, c.img);
- assert!(a.img.data.iter().all(|p| p[3] == 1.0 && (0.0..=1.0).contains(&p[0])));
- }
-
- #[test]
- fn ellipse_ring_coverage() {
- let o = run("ec.generate.ellipse", &[("width", num(40.0)), ("height", num(40.0)), ("thickness", num(6.0))], Image::new(64, 64));
- // Ring passes through (32 + 20, 32); centre is empty.
- assert!(o.img.get(51, 32)[3] > 0.9, "{:?}", o.img.get(51, 32));
- assert!(o.img.get(32, 32)[3] < 1e-3);
- assert!(o.img.get(2, 2)[3] < 1e-3);
- }
-
- #[test]
- fn lightning_is_deterministic_per_conductivity() {
- let a = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
- let b2 = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
- assert_eq!(a.img, b2.img);
- assert!(a.img.data.iter().any(|p| p[3] > 0.5));
- let c = run("ec.generate.advancedlightning", &[("conductivityState", num(11.0))], Image::new(64, 48));
- assert_ne!(a.img, c.img);
- }
-
- #[test]
- fn beam_draws_between_points() {
- let o = run("ec.generate.beam", &[("length", num(100.0)), ("softness", num(0.0))], Image::new(64, 32));
- assert!(o.img.get(32, 16)[3] > 0.99);
- assert!(o.img.get(32, 2)[3] < 1e-3);
- assert!(o.img.get(2, 16)[3] < 1e-3);
- }
-
- #[test]
- fn cell_pattern_tiles() {
- // 4×4-cell tiles of 8 px: the pattern repeats every 32 px.
- let set = [
- ("size", num(8.0)),
- ("tilingOptions/enableTiling", Value::Bool(true)),
- ("tilingOptions/cellsHorizontal", num(4.0)),
- ("tilingOptions/cellsVertical", num(4.0)),
- ];
- let o = run("ec.generate.cellpattern", &set, Image::new(64, 64));
- for (x, y) in [(3, 5), (10, 20), (17, 2)] {
- let (a, b2) = (o.img.get(x, y), o.img.get(x + 32, y + 32));
- assert!((a[0] - b2[0]).abs() < 1e-4, "{x},{y}: {a:?} vs {b2:?}");
- }
- }
-
- #[test]
- fn radio_waves_expansion_velocity_and_star() {
- let r = |set: &[(&str, Value)], t: f64| {
- let s = crate::find("ec.generate.radiowaves").unwrap();
- let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
- params.values.insert("producerPoint".into(), Value::Vec2([32.0, 32.0]));
- for (k, v) in set {
- params.values.insert(k.to_string(), v.clone());
- }
- let ctx = EffectCtx { params: ¶ms, time: t, layer_size: [64.0, 64.0], seed: 3, adjustment: false, env: Default::default() };
- crate::apply(s, &ctx, Buf { img: Image::new(64, 64), offset: [0.0, 0.0], scale: 1.0 })
- };
- // One wave born at t = 0, 0.2 s old: radius = Expansion × age = 20 px.
- let base = [("waveMotion/expansion", num(100.0)), ("waveMotion/frequency", num(0.5))];
- let o = r(&base, 0.2);
- assert!(o.img.get(52, 32)[3] > 0.9, "{:?}", o.img.get(52, 32));
- assert!(o.img.get(32, 32)[3] < 0.01);
- // Velocity moves the wave toward Direction (90° = right).
- let mut moving = base.to_vec();
- moving.push(("waveMotion/velocity", num(50.0)));
- let o = r(&moving, 0.2);
- assert!(o.img.get(62, 32)[3] > 0.9 && o.img.get(52, 32)[3] < 0.5, "{:?}", o.img.get(62, 32));
- // A 4-point star: the outline dips toward the centre between the points.
- let mut star = base.to_vec();
- star.extend([("polygon/sides", num(4.0)), ("polygon/star", Value::Bool(true)), ("polygon/starDepth", num(-0.5))]);
- let o = r(&star, 0.2);
- assert!(o.img.get(32, 12)[3] > 0.9, "point straight up");
- // Between points (45°) the outline sits near half the radius.
- assert!(o.img.get(39, 24)[3] > 0.5, "{:?}", o.img.get(39, 24));
- assert!(o.img.get(46, 18)[3] < 0.01, "no circle there");
- }
-
- #[test]
- fn lightning_alpha_obstacle_and_expert_settings() {
- let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::();
- let alpha_in = |img: &Image, src: &Image| img.data.iter().zip(&src.data).filter(|(_, s)| s[3] > 0.5).map(|(p, _)| p[3]).sum::();
- // A wall of opaque pixels across the middle of the bolt's path.
- let mut wall = Image::new(64, 48);
- for y in 0..48 {
- for x in 0..64 {
- if (18..30).contains(&y) && x < 50 {
- wall.set(x, y, [0.0, 0.0, 0.0, 1.0]);
- }
- }
- }
- let opts = |o: f64| {
- vec![("alphaObstacle", num(o)), ("compositeOnOriginal", Value::Bool(false)), ("glowSettings/glowRadius", num(0.0)), ("forking", num(60.0))]
- };
- let free = run("ec.generate.advancedlightning", &opts(0.0), wall.clone());
- let avoid = run("ec.generate.advancedlightning", &opts(10.0), wall.clone());
- assert!(alpha_in(&avoid.img, &wall) < alpha_in(&free.img, &wall), "{} vs {}", alpha_in(&avoid.img, &wall), alpha_in(&free.img, &wall));
- // Fractal Type, Core Drain, Fork Strength, Termination Threshold, Min Fork Distance.
- let base = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
- for (id, v) in [
- ("expertSettings/fractalType", Value::Enum(2)),
- ("expertSettings/coreDrain", num(100.0)),
- ("expertSettings/forkStrength", num(100.0)),
- ("expertSettings/forkVariation", num(100.0)),
- ] {
- assert_ne!(run("ec.generate.advancedlightning", &[(id, v)], Image::new(64, 48)).img, base.img, "{id}");
- }
- let drained = run("ec.generate.advancedlightning", &[("expertSettings/coreDrain", num(100.0))], Image::new(64, 48));
- assert!(sum(&drained.img) < sum(&base.img));
- let no_forks = run("ec.generate.advancedlightning", &[("expertSettings/minForkDistance", num(1000.0))], Image::new(64, 48));
- let term = run("ec.generate.advancedlightning", &[("expertSettings/terminationThreshold", num(100.0))], Image::new(64, 48));
- assert_eq!(no_forks.img, term.img, "no forks either way");
- assert!(sum(&no_forks.img) < sum(&base.img));
- }
-
- #[test]
- fn lightning_types_and_decay_main_core() {
- let a = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
- let strike = run("ec.generate.advancedlightning", &[("lightningType", Value::Enum(1))], Image::new(64, 48));
- assert_eq!(a.img, strike.img, "Strike is the default");
- for t in 0..8 {
- let o = run("ec.generate.advancedlightning", &[("lightningType", Value::Enum(t))], Image::new(64, 48));
- assert!(o.img.data.iter().any(|p| p[3] > 0.3), "type {t} draws");
- }
- let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::();
- let d = run("ec.generate.advancedlightning", &[("decayMainCore", Value::Bool(true)), ("decay", num(0.9))], Image::new(64, 48));
- let n = run("ec.generate.advancedlightning", &[("decay", num(0.9))], Image::new(64, 48));
- assert!(sum(&d.img) < sum(&n.img));
- }
-
- #[test]
- fn beam_3d_perspective_controls_thickness() {
- // Short beam near the start: with 3D Perspective its thickness comes from its position
- // (thin, near the start); without, its head takes the full ending thickness.
- let set = |p: bool| {
- vec![
- ("length", num(20.0)),
- ("time", num(0.0)),
- ("softness", num(0.0)),
- ("startThickness", num(2.0)),
- ("endThickness", num(20.0)),
- ("perspective3d", Value::Bool(p)),
- ]
- };
- let on = run("ec.generate.beam", &set(true), Image::new(64, 32));
- let off = run("ec.generate.beam", &set(false), Image::new(64, 32));
- let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::();
- assert!(sum(&off.img) > sum(&on.img) * 1.5, "{} {}", sum(&off.img), sum(&on.img));
- }
-
- #[test]
- fn lens_flare_brightest_at_center() {
- let o = run("ec.generate.lensflare", &[], Image::new(64, 64));
- let c = o.img.get(16, 16)[0];
- assert!(c > o.img.get(60, 4)[0]);
- assert!(c > 0.5);
- }
-
- fn rw(set: &[(&str, Value)], t: f64, env: crate::EffectEnv) -> Image {
- let mut v: Vec<(&str, Value)> =
- vec![("producerPoint", Value::Vec2([32.0, 32.0])), ("waveMotion/frequency", num(0.5)), ("waveMotion/expansion", num(100.0))];
- v.extend_from_slice(set);
- crate::run_fx("ec.generate.radiowaves", &v, Image::new(64, 64), t, env).img
- }
-
- #[test]
- fn signed_distance_of_a_square() {
- let (w, h) = (20, 20);
- let inside: Vec = (0..w * h).map(|i| (5..15).contains(&(i % w)) && (5..15).contains(&(i / w))).collect();
- let d = crate::util::signed_distance(&inside, w, h);
- assert!((d.get(10, 10) + 4.5).abs() < 1e-4, "{}", d.get(10, 10));
- assert!((d.get(0, 10) - 4.5).abs() < 1e-4, "{}", d.get(0, 10));
- assert!((d.get(0, 0) - (50f32.sqrt() - 0.5)).abs() < 1e-4);
- }
-
- #[test]
- fn radio_waves_mask_contours_profile_reflection_and_birth() {
- // Mask waves: a 10×10 square mask; after 0.1 s (10 px) the wave is 10 px outside it.
- let sq = crate::MaskShape { name: String::new(), points: vec![[27.0, 27.0], [37.0, 27.0], [37.0, 37.0], [27.0, 37.0]], closed: true, inverted: false };
- let masks = [sq];
- let env = crate::EffectEnv { masks: &masks, ..Default::default() };
- let m = rw(&[("waveType", Value::Enum(2)), ("waveMask/mask", num(1.0))], 0.1, env);
- assert!(m.get(47, 32)[3] > 0.9, "{:?}", m.get(47, 32));
- assert!(m.get(32, 32)[3] < 0.01 && m.get(40, 32)[3] < 0.01);
- // Rounded corner: diagonal distance 10 from (37, 37).
- assert!(m.get(44, 44)[3] > 0.5, "{:?}", m.get(44, 44));
- // No mask chosen: nothing drawn.
- assert!(rw(&[("waveType", Value::Enum(2))], 0.1, env).data.iter().all(|p| p[3] == 0.0));
- // Image Contours: the bright square of a source layer.
- struct Src;
- impl crate::EffectHost for Src {
- fn layer(&self, _: u64, _: bool) -> Option {
- let mut img = Image::new(64, 64);
- for y in 27..37 {
- for x in 27..37 {
- img.set(x, y, [1.0, 1.0, 1.0, 1.0]);
- }
- }
- Some(crate::LayerPixels { buf: Buf { img, offset: [0.0; 2], scale: 1.0 }, size: [64.0, 64.0] })
- }
- fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option> {
- None
- }
- fn params_at(&self, t: f64) -> Option {
- // Colour animates from red (born at 0) to green (born later).
- let s = crate::find("ec.generate.radiowaves").unwrap();
- let mut p = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
- p.values.insert("producerPoint".into(), Value::Vec2([32.0, 32.0]));
- p.values.insert("waveMotion/frequency".into(), num(1.0));
- p.values.insert("waveMotion/expansion".into(), num(20.0));
- p.values.insert("waveStroke/color".into(), if t < 0.5 { col(1.0, 0.0, 0.0) } else { col(0.0, 1.0, 0.0) });
- Some(p)
- }
- }
- let env = crate::EffectEnv { host: Some(&Src), ..Default::default() };
- let ic = rw(
- &[
- ("waveType", Value::Enum(1)),
- ("imageContour/sourceLayer", Value::Layer(Some(1))),
- ("imageContour/preBlur", num(0.0)),
- ("imageContour/tolerance", num(0.0)),
- ],
- 0.1,
- env,
- );
- assert!(ic.get(47, 32)[3] > 0.9 && ic.get(32, 32)[3] < 0.01, "{:?}", ic.get(47, 32));
- // Source Center off the square shifts the contour onto the producer point accordingly.
- let sh = rw(
- &[
- ("waveType", Value::Enum(1)),
- ("imageContour/sourceLayer", Value::Layer(Some(1))),
- ("imageContour/sourceCenter", Value::Vec2([22.0, 32.0])),
- ("imageContour/preBlur", num(0.0)),
- ("imageContour/tolerance", num(0.0)),
- ],
- 0.1,
- env,
- );
- assert!(sh.get(57, 32)[3] > 0.9, "{:?}", sh.get(57, 32));
- // Profile: Taper Both thins the stroke edges; Square is solid across.
- let wide = [("waveStroke/startWidth", num(10.0)), ("waveStroke/endWidth", num(10.0))];
- let sqr = rw(&wide, 0.2, crate::EffectEnv::default());
- let mut tap = wide.to_vec();
- tap.push(("waveStroke/profile", Value::Enum(3)));
- let tap = rw(&tap, 0.2, crate::EffectEnv::default());
- assert!(sqr.get(55, 32)[3] > 0.9 && tap.get(55, 32)[3] < 0.6, "{:?} {:?}", sqr.get(55, 32), tap.get(55, 32));
- assert!(tap.get(52, 32)[3] > 0.8);
- // Reflection: a fast wave bounces back off the right edge.
- let fast = [("waveMotion/velocity", num(200.0)), ("waveMotion/expansion", num(10.0))];
- let gone = rw(&fast, 0.3, crate::EffectEnv::default());
- let mut rf = fast.to_vec();
- rf.push(("waveMotion/reflection", Value::Bool(true)));
- let back = rw(&rf, 0.3, crate::EffectEnv::default());
- let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::();
- assert!(sum(&back) > sum(&gone) + 5.0, "{} vs {}", sum(&back), sum(&gone));
- // Parameters Are Set At Birth: the older wave keeps red, the newer one is green.
- let both = rw(&[("parametersAreSetAt", Value::Enum(0)), ("waveMotion/frequency", num(1.0)), ("waveMotion/expansion", num(20.0))], 1.15, env);
- let (old, new) = (both.get(55, 32), both.get(35, 32));
- assert!(old[0] > 0.9 && old[1] < 0.1, "{old:?}");
- assert!(new[1] > 0.9 && new[0] < 0.1, "{new:?}");
- }
-
- #[test]
- fn cell_pattern_hq_variants_antialias() {
- let s = crate::find("ec.generate.cellpattern").unwrap();
- let r = |pat: u32| {
- let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
- params.values.insert("cellPattern".into(), Value::Enum(pat));
- params.values.insert("size".into(), num(12.0));
- let ctx = EffectCtx { params: ¶ms, time: 0.0, layer_size: [48.0, 48.0], seed: 1, adjustment: false, env: Default::default() };
- crate::apply(s, &ctx, Buf { img: Image::new(48, 48), offset: [0.0; 2], scale: 1.0 }).img
- };
- let distinct = |img: &Image| {
- let mut v: Vec = img.data.iter().map(|p| (p[0] * 10000.0) as u32).collect();
- v.sort_unstable();
- v.dedup();
- v.len()
- };
- let (std, hq) = (r(4), r(9));
- assert_eq!(CELL_PATTERNS[9], "Crystallize HQ");
- assert_ne!(std, hq);
- assert!(distinct(&hq) > distinct(&std) * 2, "{} vs {}", distinct(&hq), distinct(&std));
- }
-}
+mod tests;
diff --git a/crates/effects/src/generate2/tests.rs b/crates/effects/src/generate2/tests.rs
new file mode 100644
index 000000000..c2acff446
--- /dev/null
+++ b/crates/effects/src/generate2/tests.rs
@@ -0,0 +1,309 @@
+use super::*;
+use crate::Params;
+use effectcraft_raster::Image;
+
+fn run(id: &str, set: &[(&str, Value)], img: Image) -> Buf {
+ let s = crate::find(id).unwrap();
+ let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+ let ls = [img.width as f64, img.height as f64];
+ for p in &s.params {
+ if let (ParamUi::Point, Value::Vec2(v)) = (&p.ui, &p.default) {
+ params.values.insert(p.id.to_string(), Value::Vec2([v[0] * ls[0], v[1] * ls[1]]));
+ }
+ }
+ for (k, v) in set {
+ params.values.insert(k.to_string(), v.clone());
+ }
+ let ctx = EffectCtx { params: ¶ms, time: 0.5, layer_size: ls, seed: 3, adjustment: false, env: Default::default() };
+ crate::apply(s, &ctx, Buf { img, offset: [0.0, 0.0], scale: 1.0 })
+}
+
+#[test]
+fn cell_pattern_is_deterministic_and_seeded() {
+ let a = run("ec.generate.cellpattern", &[("size", num(10.0))], Image::new(40, 30));
+ let b2 = run("ec.generate.cellpattern", &[("size", num(10.0))], Image::new(40, 30));
+ assert_eq!(a.img, b2.img);
+ let c = run("ec.generate.cellpattern", &[("size", num(10.0)), ("evolutionOptions/randomSeed", num(5.0))], Image::new(40, 30));
+ assert_ne!(a.img, c.img);
+ assert!(a.img.data.iter().all(|p| p[3] == 1.0 && (0.0..=1.0).contains(&p[0])));
+}
+
+#[test]
+fn ellipse_ring_coverage() {
+ let o = run("ec.generate.ellipse", &[("width", num(40.0)), ("height", num(40.0)), ("thickness", num(6.0))], Image::new(64, 64));
+ // Ring passes through (32 + 20, 32); centre is empty.
+ assert!(o.img.get(51, 32)[3] > 0.9, "{:?}", o.img.get(51, 32));
+ assert!(o.img.get(32, 32)[3] < 1e-3);
+ assert!(o.img.get(2, 2)[3] < 1e-3);
+}
+
+#[test]
+fn lightning_is_deterministic_per_conductivity() {
+ let a = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
+ let b2 = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
+ assert_eq!(a.img, b2.img);
+ assert!(a.img.data.iter().any(|p| p[3] > 0.5));
+ let c = run("ec.generate.advancedlightning", &[("conductivityState", num(11.0))], Image::new(64, 48));
+ assert_ne!(a.img, c.img);
+}
+
+#[test]
+fn beam_draws_between_points() {
+ let o = run("ec.generate.beam", &[("length", num(100.0)), ("softness", num(0.0))], Image::new(64, 32));
+ assert!(o.img.get(32, 16)[3] > 0.99);
+ assert!(o.img.get(32, 2)[3] < 1e-3);
+ assert!(o.img.get(2, 16)[3] < 1e-3);
+}
+
+#[test]
+fn cell_pattern_tiles() {
+ // 4×4-cell tiles of 8 px: the pattern repeats every 32 px.
+ let set = [
+ ("size", num(8.0)),
+ ("tilingOptions/enableTiling", Value::Bool(true)),
+ ("tilingOptions/cellsHorizontal", num(4.0)),
+ ("tilingOptions/cellsVertical", num(4.0)),
+ ];
+ let o = run("ec.generate.cellpattern", &set, Image::new(64, 64));
+ for (x, y) in [(3, 5), (10, 20), (17, 2)] {
+ let (a, b2) = (o.img.get(x, y), o.img.get(x + 32, y + 32));
+ assert!((a[0] - b2[0]).abs() < 1e-4, "{x},{y}: {a:?} vs {b2:?}");
+ }
+}
+
+#[test]
+fn radio_waves_expansion_velocity_and_star() {
+ let r = |set: &[(&str, Value)], t: f64| {
+ let s = crate::find("ec.generate.radiowaves").unwrap();
+ let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+ params.values.insert("producerPoint".into(), Value::Vec2([32.0, 32.0]));
+ for (k, v) in set {
+ params.values.insert(k.to_string(), v.clone());
+ }
+ let ctx = EffectCtx { params: ¶ms, time: t, layer_size: [64.0, 64.0], seed: 3, adjustment: false, env: Default::default() };
+ crate::apply(s, &ctx, Buf { img: Image::new(64, 64), offset: [0.0, 0.0], scale: 1.0 })
+ };
+ // One wave born at t = 0, 0.2 s old: radius = Expansion × age = 20 px.
+ let base = [("waveMotion/expansion", num(100.0)), ("waveMotion/frequency", num(0.5))];
+ let o = r(&base, 0.2);
+ assert!(o.img.get(52, 32)[3] > 0.9, "{:?}", o.img.get(52, 32));
+ assert!(o.img.get(32, 32)[3] < 0.01);
+ // Velocity moves the wave toward Direction (90° = right).
+ let mut moving = base.to_vec();
+ moving.push(("waveMotion/velocity", num(50.0)));
+ let o = r(&moving, 0.2);
+ assert!(o.img.get(62, 32)[3] > 0.9 && o.img.get(52, 32)[3] < 0.5, "{:?}", o.img.get(62, 32));
+ // A 4-point star: the outline dips toward the centre between the points.
+ let mut star = base.to_vec();
+ star.extend([("polygon/sides", num(4.0)), ("polygon/star", Value::Bool(true)), ("polygon/starDepth", num(-0.5))]);
+ let o = r(&star, 0.2);
+ assert!(o.img.get(32, 12)[3] > 0.9, "point straight up");
+ // Between points (45°) the outline sits near half the radius.
+ assert!(o.img.get(39, 24)[3] > 0.5, "{:?}", o.img.get(39, 24));
+ assert!(o.img.get(46, 18)[3] < 0.01, "no circle there");
+}
+
+#[test]
+fn lightning_alpha_obstacle_and_expert_settings() {
+ let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::();
+ let alpha_in = |img: &Image, src: &Image| img.data.iter().zip(&src.data).filter(|(_, s)| s[3] > 0.5).map(|(p, _)| p[3]).sum::();
+ // A wall of opaque pixels across the middle of the bolt's path.
+ let mut wall = Image::new(64, 48);
+ for y in 0..48 {
+ for x in 0..64 {
+ if (18..30).contains(&y) && x < 50 {
+ wall.set(x, y, [0.0, 0.0, 0.0, 1.0]);
+ }
+ }
+ }
+ let opts =
+ |o: f64| vec![("alphaObstacle", num(o)), ("compositeOnOriginal", Value::Bool(false)), ("glowSettings/glowRadius", num(0.0)), ("forking", num(60.0))];
+ let free = run("ec.generate.advancedlightning", &opts(0.0), wall.clone());
+ let avoid = run("ec.generate.advancedlightning", &opts(10.0), wall.clone());
+ assert!(alpha_in(&avoid.img, &wall) < alpha_in(&free.img, &wall), "{} vs {}", alpha_in(&avoid.img, &wall), alpha_in(&free.img, &wall));
+ // Fractal Type, Core Drain, Fork Strength, Termination Threshold, Min Fork Distance.
+ let base = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
+ for (id, v) in [
+ ("expertSettings/fractalType", Value::Enum(2)),
+ ("expertSettings/coreDrain", num(100.0)),
+ ("expertSettings/forkStrength", num(100.0)),
+ ("expertSettings/forkVariation", num(100.0)),
+ ] {
+ assert_ne!(run("ec.generate.advancedlightning", &[(id, v)], Image::new(64, 48)).img, base.img, "{id}");
+ }
+ let drained = run("ec.generate.advancedlightning", &[("expertSettings/coreDrain", num(100.0))], Image::new(64, 48));
+ assert!(sum(&drained.img) < sum(&base.img));
+ let no_forks = run("ec.generate.advancedlightning", &[("expertSettings/minForkDistance", num(1000.0))], Image::new(64, 48));
+ let term = run("ec.generate.advancedlightning", &[("expertSettings/terminationThreshold", num(100.0))], Image::new(64, 48));
+ assert_eq!(no_forks.img, term.img, "no forks either way");
+ assert!(sum(&no_forks.img) < sum(&base.img));
+}
+
+#[test]
+fn lightning_types_and_decay_main_core() {
+ let a = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
+ let strike = run("ec.generate.advancedlightning", &[("lightningType", Value::Enum(1))], Image::new(64, 48));
+ assert_eq!(a.img, strike.img, "Strike is the default");
+ for t in 0..8 {
+ let o = run("ec.generate.advancedlightning", &[("lightningType", Value::Enum(t))], Image::new(64, 48));
+ assert!(o.img.data.iter().any(|p| p[3] > 0.3), "type {t} draws");
+ }
+ let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::();
+ let d = run("ec.generate.advancedlightning", &[("decayMainCore", Value::Bool(true)), ("decay", num(0.9))], Image::new(64, 48));
+ let n = run("ec.generate.advancedlightning", &[("decay", num(0.9))], Image::new(64, 48));
+ assert!(sum(&d.img) < sum(&n.img));
+}
+
+#[test]
+fn beam_3d_perspective_controls_thickness() {
+ // Short beam near the start: with 3D Perspective its thickness comes from its position
+ // (thin, near the start); without, its head takes the full ending thickness.
+ let set = |p: bool| {
+ vec![
+ ("length", num(20.0)),
+ ("time", num(0.0)),
+ ("softness", num(0.0)),
+ ("startThickness", num(2.0)),
+ ("endThickness", num(20.0)),
+ ("perspective3d", Value::Bool(p)),
+ ]
+ };
+ let on = run("ec.generate.beam", &set(true), Image::new(64, 32));
+ let off = run("ec.generate.beam", &set(false), Image::new(64, 32));
+ let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::();
+ assert!(sum(&off.img) > sum(&on.img) * 1.5, "{} {}", sum(&off.img), sum(&on.img));
+}
+
+#[test]
+fn lens_flare_brightest_at_center() {
+ let o = run("ec.generate.lensflare", &[], Image::new(64, 64));
+ let c = o.img.get(16, 16)[0];
+ assert!(c > o.img.get(60, 4)[0]);
+ assert!(c > 0.5);
+}
+
+fn rw(set: &[(&str, Value)], t: f64, env: crate::EffectEnv) -> Image {
+ let mut v: Vec<(&str, Value)> =
+ vec![("producerPoint", Value::Vec2([32.0, 32.0])), ("waveMotion/frequency", num(0.5)), ("waveMotion/expansion", num(100.0))];
+ v.extend_from_slice(set);
+ crate::run_fx("ec.generate.radiowaves", &v, Image::new(64, 64), t, env).img
+}
+
+#[test]
+fn signed_distance_of_a_square() {
+ let (w, h) = (20, 20);
+ let inside: Vec = (0..w * h).map(|i| (5..15).contains(&(i % w)) && (5..15).contains(&(i / w))).collect();
+ let d = crate::util::signed_distance(&inside, w, h);
+ assert!((d.get(10, 10) + 4.5).abs() < 1e-4, "{}", d.get(10, 10));
+ assert!((d.get(0, 10) - 4.5).abs() < 1e-4, "{}", d.get(0, 10));
+ assert!((d.get(0, 0) - (50f32.sqrt() - 0.5)).abs() < 1e-4);
+}
+
+#[test]
+fn radio_waves_mask_contours_profile_reflection_and_birth() {
+ // Mask waves: a 10×10 square mask; after 0.1 s (10 px) the wave is 10 px outside it.
+ let sq = crate::MaskShape { name: String::new(), points: vec![[27.0, 27.0], [37.0, 27.0], [37.0, 37.0], [27.0, 37.0]], closed: true, inverted: false };
+ let masks = [sq];
+ let env = crate::EffectEnv { masks: &masks, ..Default::default() };
+ let m = rw(&[("waveType", Value::Enum(2)), ("waveMask/mask", num(1.0))], 0.1, env);
+ assert!(m.get(47, 32)[3] > 0.9, "{:?}", m.get(47, 32));
+ assert!(m.get(32, 32)[3] < 0.01 && m.get(40, 32)[3] < 0.01);
+ // Rounded corner: diagonal distance 10 from (37, 37).
+ assert!(m.get(44, 44)[3] > 0.5, "{:?}", m.get(44, 44));
+ // No mask chosen: nothing drawn.
+ assert!(rw(&[("waveType", Value::Enum(2))], 0.1, env).data.iter().all(|p| p[3] == 0.0));
+ // Image Contours: the bright square of a source layer.
+ struct Src;
+ impl crate::EffectHost for Src {
+ fn layer(&self, _: u64, _: bool) -> Option {
+ let mut img = Image::new(64, 64);
+ for y in 27..37 {
+ for x in 27..37 {
+ img.set(x, y, [1.0, 1.0, 1.0, 1.0]);
+ }
+ }
+ Some(crate::LayerPixels { buf: Buf { img, offset: [0.0; 2], scale: 1.0 }, size: [64.0, 64.0] })
+ }
+ fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option> {
+ None
+ }
+ fn params_at(&self, t: f64) -> Option {
+ // Colour animates from red (born at 0) to green (born later).
+ let s = crate::find("ec.generate.radiowaves").unwrap();
+ let mut p = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+ p.values.insert("producerPoint".into(), Value::Vec2([32.0, 32.0]));
+ p.values.insert("waveMotion/frequency".into(), num(1.0));
+ p.values.insert("waveMotion/expansion".into(), num(20.0));
+ p.values.insert("waveStroke/color".into(), if t < 0.5 { col(1.0, 0.0, 0.0) } else { col(0.0, 1.0, 0.0) });
+ Some(p)
+ }
+ }
+ let env = crate::EffectEnv { host: Some(&Src), ..Default::default() };
+ let ic = rw(
+ &[
+ ("waveType", Value::Enum(1)),
+ ("imageContour/sourceLayer", Value::Layer(Some(1))),
+ ("imageContour/preBlur", num(0.0)),
+ ("imageContour/tolerance", num(0.0)),
+ ],
+ 0.1,
+ env,
+ );
+ assert!(ic.get(47, 32)[3] > 0.9 && ic.get(32, 32)[3] < 0.01, "{:?}", ic.get(47, 32));
+ // Source Center off the square shifts the contour onto the producer point accordingly.
+ let sh = rw(
+ &[
+ ("waveType", Value::Enum(1)),
+ ("imageContour/sourceLayer", Value::Layer(Some(1))),
+ ("imageContour/sourceCenter", Value::Vec2([22.0, 32.0])),
+ ("imageContour/preBlur", num(0.0)),
+ ("imageContour/tolerance", num(0.0)),
+ ],
+ 0.1,
+ env,
+ );
+ assert!(sh.get(57, 32)[3] > 0.9, "{:?}", sh.get(57, 32));
+ // Profile: Taper Both thins the stroke edges; Square is solid across.
+ let wide = [("waveStroke/startWidth", num(10.0)), ("waveStroke/endWidth", num(10.0))];
+ let sqr = rw(&wide, 0.2, crate::EffectEnv::default());
+ let mut tap = wide.to_vec();
+ tap.push(("waveStroke/profile", Value::Enum(3)));
+ let tap = rw(&tap, 0.2, crate::EffectEnv::default());
+ assert!(sqr.get(55, 32)[3] > 0.9 && tap.get(55, 32)[3] < 0.6, "{:?} {:?}", sqr.get(55, 32), tap.get(55, 32));
+ assert!(tap.get(52, 32)[3] > 0.8);
+ // Reflection: a fast wave bounces back off the right edge.
+ let fast = [("waveMotion/velocity", num(200.0)), ("waveMotion/expansion", num(10.0))];
+ let gone = rw(&fast, 0.3, crate::EffectEnv::default());
+ let mut rf = fast.to_vec();
+ rf.push(("waveMotion/reflection", Value::Bool(true)));
+ let back = rw(&rf, 0.3, crate::EffectEnv::default());
+ let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::();
+ assert!(sum(&back) > sum(&gone) + 5.0, "{} vs {}", sum(&back), sum(&gone));
+ // Parameters Are Set At Birth: the older wave keeps red, the newer one is green.
+ let both = rw(&[("parametersAreSetAt", Value::Enum(0)), ("waveMotion/frequency", num(1.0)), ("waveMotion/expansion", num(20.0))], 1.15, env);
+ let (old, new) = (both.get(55, 32), both.get(35, 32));
+ assert!(old[0] > 0.9 && old[1] < 0.1, "{old:?}");
+ assert!(new[1] > 0.9 && new[0] < 0.1, "{new:?}");
+}
+
+#[test]
+fn cell_pattern_hq_variants_antialias() {
+ let s = crate::find("ec.generate.cellpattern").unwrap();
+ let r = |pat: u32| {
+ let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+ params.values.insert("cellPattern".into(), Value::Enum(pat));
+ params.values.insert("size".into(), num(12.0));
+ let ctx = EffectCtx { params: ¶ms, time: 0.0, layer_size: [48.0, 48.0], seed: 1, adjustment: false, env: Default::default() };
+ crate::apply(s, &ctx, Buf { img: Image::new(48, 48), offset: [0.0; 2], scale: 1.0 }).img
+ };
+ let distinct = |img: &Image| {
+ let mut v: Vec = img.data.iter().map(|p| (p[0] * 10000.0) as u32).collect();
+ v.sort_unstable();
+ v.dedup();
+ v.len()
+ };
+ let (std, hq) = (r(4), r(9));
+ assert_eq!(CELL_PATTERNS[9], "Crystallize HQ");
+ assert_ne!(std, hq);
+ assert!(distinct(&hq) > distinct(&std) * 2, "{} vs {}", distinct(&hq), distinct(&std));
+}
diff --git a/crates/effects/src/generate3.rs b/crates/effects/src/generate3.rs
index 6beec4cb7..a61c3f769 100644
--- a/crates/effects/src/generate3.rs
+++ b/crates/effects/src/generate3.rs
@@ -17,2430 +17,26 @@ use rayon::prelude::*;
use crate::util::{Plane, gauss_plane, hash1, layer_or_self, morph_frac, poly_length, premul, smoothstep, unpremul};
use crate::{Buf, EffectCtx, EffectSpec, Params, col, num, p, popup, slider};
-fn spec(id: &'static str, name: &'static str, params: Vec, render: crate::RenderFn) -> EffectSpec {
- EffectSpec { id, name, category: "Generate", params, render, gpu: false, float: true }
-}
-
-fn pt(x: f64, y: f64) -> Value {
- Value::Vec2([x, y])
-}
-
-fn pct() -> ParamUi {
- slider(0.0, 100.0, 0.0, 100.0, 1)
-}
-
-// ---------------------------------------------------------------- shared rasterisation
-
-/// A round-capped line segment in buffer pixels with radius `r` and intensity `v`.
-#[derive(Clone, Copy, Debug)]
-pub struct Seg {
- pub a: [f64; 2],
- pub b: [f64; 2],
- pub r: f64,
- pub v: f32,
-}
-
-/// Rasterise segments into a coverage plane (max-combined). `hardness` (0..1) is the fraction
-/// of the radius that is fully opaque; the rest falls off smoothly.
-pub(crate) fn raster_segs(w: usize, h: usize, segs: &[Seg], hardness: f64) -> Plane {
- let mut out = Plane::new(w, h);
- if w == 0 || h == 0 || segs.is_empty() {
- return out;
- }
- let mut buckets: Vec> = vec![Vec::new(); h];
- for (i, s) in segs.iter().enumerate() {
- let pad = s.r + 1.0;
- let y0 = (s.a[1].min(s.b[1]) - pad).floor().max(0.0) as usize;
- let y1 = (s.a[1].max(s.b[1]) + pad).ceil().min(h as f64);
- if y1 <= 0.0 || y0 >= h {
- continue;
- }
- for row in buckets.iter_mut().take(y1 as usize).skip(y0) {
- row.push(i as u32);
- }
- }
- let hard = hardness.clamp(0.0, 1.0);
- out.data.par_chunks_mut(w).enumerate().for_each(|(y, row)| {
- let py = y as f64 + 0.5;
- for &i in &buckets[y] {
- let s = segs[i as usize];
- let pad = s.r + 1.0;
- let x0 = (s.a[0].min(s.b[0]) - pad).floor().max(0.0) as usize;
- let x1 = ((s.a[0].max(s.b[0]) + pad).ceil().max(0.0) as usize).min(w);
- let (dx, dy) = (s.b[0] - s.a[0], s.b[1] - s.a[1]);
- let l2 = dx * dx + dy * dy;
- let inner = s.r * hard - 0.5;
- let outer = s.r + 0.5;
- for (x, o) in row.iter_mut().enumerate().take(x1).skip(x0) {
- let px = x as f64 + 0.5;
- let t = if l2 > 1e-12 { (((px - s.a[0]) * dx + (py - s.a[1]) * dy) / l2).clamp(0.0, 1.0) } else { 0.0 };
- let d = ((px - s.a[0] - dx * t).powi(2) + (py - s.a[1] - dy * t).powi(2)).sqrt();
- if d >= outer {
- continue;
- }
- let c = if d <= inner { 1.0 } else { 1.0 - smoothstep(inner as f32, outer as f32, d as f32) } * s.v;
- if c > *o {
- *o = c;
- }
- }
- }
- });
- out
-}
-
-/// Segments along a polyline (buffer px).
-pub fn poly_segs(pts: &[[f64; 2]], closed: bool, r: f64, v: f32, out: &mut Vec) {
- let n = pts.len();
- if n == 1 {
- out.push(Seg { a: pts[0], b: pts[0], r, v });
- }
- if n < 2 {
- return;
- }
- let segs = if closed { n } else { n - 1 };
- for i in 0..segs {
- out.push(Seg { a: pts[i], b: pts[(i + 1) % n], r, v });
- }
-}
-
-/// Portion `[s0, s1]` (arc length) of a polyline.
-pub(crate) fn trim_poly(pts: &[[f64; 2]], closed: bool, s0: f64, s1: f64) -> Vec<[f64; 2]> {
- let n = pts.len();
- let mut out = Vec::new();
- if n < 2 || s1 <= s0 {
- return out;
- }
- let segs = if closed { n } else { n - 1 };
- let mut acc = 0.0;
- for i in 0..segs {
- let (a, b) = (pts[i], pts[(i + 1) % n]);
- let l = ((b[0] - a[0]).powi(2) + (b[1] - a[1]).powi(2)).sqrt();
- let (e0, e1) = (acc, acc + l);
- acc = e1;
- if e1 < s0 || e0 > s1 || l <= 0.0 {
- continue;
- }
- let at = |s: f64| {
- let t = ((s - e0) / l).clamp(0.0, 1.0);
- [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]
- };
- let p0 = at(s0.max(e0));
- if out.last() != Some(&p0) {
- out.push(p0);
- }
- out.push(at(s1.min(e1)));
- }
- out
-}
-
-/// How painted coverage meets the layer: 0 On Original Image, 1 On Transparent, 2 Reveal
-/// Original Image.
-pub(crate) fn paint(img: &mut Image, cov: &Plane, color: [f32; 4], opacity: f32, style: u32) {
- img.data.par_iter_mut().zip(cov.data.par_iter()).for_each(|(px, &c)| {
- let a = (c * opacity * color[3]).clamp(0.0, 1.0);
- let s = [color[0] * a, color[1] * a, color[2] * a, a];
- *px = match style {
- 1 => s,
- 2 => [px[0] * a, px[1] * a, px[2] * a, px[3] * a],
- _ => over(*px, s),
- };
- });
-}
-
-/// Coverage of a plan-drawn generator: round-capped segments rasterised by [`raster_segs`]
-/// with `hardness`, or the union of convex polygons ([`raster_convex`]).
-#[derive(Clone, Debug)]
-pub enum Coverage {
- Segs { segs: Vec, hardness: f64 },
- Convex(Vec>),
-}
-
-impl Coverage {
- fn raster(&self, w: usize, h: usize) -> Plane {
- match self {
- Coverage::Segs { segs, hardness } => raster_segs(w, h, segs, *hardness),
- Coverage::Convex(polys) => raster_convex(w, h, polys),
- }
- }
-}
-
-/// Stroke, Scribble, Vegas and Write-on, shared with the GPU compositor (effectcraft-gpu
-/// `fx_gen2`): the coverage and how it is painted. `style` 0–2 as [`paint`] (On Original
-/// Image, On Transparent, Reveal Original Image), 3 = under the layer (Vegas' Composite Under).
-#[derive(Clone, Debug)]
-pub struct PaintPlan {
- pub cov: Coverage,
- pub color: [f32; 4],
- pub opacity: f32,
- pub style: u32,
-}
-
-/// Draw a [`PaintPlan`].
-fn draw_paint(b: &mut Buf, plan: &PaintPlan) {
- let cov = plan.cov.raster(b.img.width as usize, b.img.height as usize);
- if plan.style == 3 {
- let color = plan.color;
- b.img.data.par_iter_mut().zip(cov.data.par_iter()).for_each(|(px, &c)| {
- let a = c * color[3];
- *px = over([color[0] * a, color[1] * a, color[2] * a, a], *px);
- });
- } else {
- paint(&mut b.img, &cov, plan.color, plan.opacity, plan.style);
- }
-}
-
-/// Generators drawn from a plan that need the layer's own pixels (`b.img`) to build it.
-pub fn plan_reads_pixels(id: &str, ctx: &EffectCtx) -> bool {
- match id {
- // Image Contours read the layer itself when no (resolvable) Input Layer is chosen.
- "ec.generate.vegas" => ctx.params.e("stroke") == 0,
- "ec.generate.paintbucket" | "ec.generate.eyedropperfill" => true,
- "ec.generate.advancedlightning" => ctx.params.f("alphaObstacle").clamp(-10.0, 10.0) != 0.0,
- _ => false,
- }
-}
-
-/// [`PaintPlan`] of Stroke, Scribble, Vegas or Write-on on `b`'s geometry (`b.img` is read
-/// only when [`plan_reads_pixels`]). `None`: Scribble without a usable mask (the layer is
-/// cleared when it composites On Transparent, else kept).
-pub fn paint_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option {
- match id {
- "ec.generate.stroke" => Some(stroke_plan(ctx, b)),
- "ec.generate.scribble" => scribble_plan(ctx, b),
- "ec.generate.vegas" => Some(vegas_plan(ctx, b)),
- "ec.generate.writeon" => Some(write_on_plan(ctx, b)),
- _ => None,
- }
-}
-
-/// Scribble's Composite as a [`paint`] style.
-pub fn scribble_style(ctx: &EffectCtx) -> u32 {
- match ctx.params.e("composite") {
- 0 => 0,
- 2 => 2,
- _ => 1,
- }
-}
-
-#[inline]
-fn over(dst: Px, src: Px) -> Px {
- let k = 1.0 - src[3];
- [src[0] + dst[0] * k, src[1] + dst[1] * k, src[2] + dst[2] * k, src[3] + dst[3] * k]
-}
-
-/// Mask `idx` (1-based; 0 = none) mapped to buffer pixels.
-pub(crate) fn mask_px(ctx: &EffectCtx, b: &Buf, idx: usize) -> Option<(Vec<[f64; 2]>, bool, bool)> {
- let m = ctx.env.masks.get(idx.checked_sub(1)?)?;
- if m.points.is_empty() {
- return None;
- }
- Some((m.points.iter().map(|&q| [q[0] * b.scale + b.offset[0], q[1] * b.scale + b.offset[1]]).collect(), m.closed, m.inverted))
-}
-
-/// All masks mapped to buffer pixels.
-fn all_masks_px(ctx: &EffectCtx, b: &Buf) -> Vec<(Vec<[f64; 2]>, bool, bool)> {
- (1..=ctx.env.masks.len()).filter_map(|i| mask_px(ctx, b, i)).collect()
-}
-
-/// Chaikin corner cutting (open polyline, endpoints kept).
-fn chaikin(pts: &[[f64; 2]], iters: usize) -> Vec<[f64; 2]> {
- let mut cur = pts.to_vec();
- for _ in 0..iters {
- if cur.len() < 3 {
- return cur;
- }
- let mut nx = Vec::with_capacity(cur.len() * 2);
- nx.push(cur[0]);
- for w in cur.windows(2) {
- let (a, b) = (w[0], w[1]);
- nx.push([a[0] * 0.75 + b[0] * 0.25, a[1] * 0.75 + b[1] * 0.25]);
- nx.push([a[0] * 0.25 + b[0] * 0.75, a[1] * 0.25 + b[1] * 0.75]);
- }
- nx.push(*cur.last().unwrap_or(&[0.0; 2]));
- cur = nx;
- }
- cur
-}
-
-// ---------------------------------------------------------------- Fractal
-
-#[derive(Clone, Copy)]
-struct FracSet {
- /// Mandelbrot iterations start at the Julia centre (the "Over Julia" set choices).
- over_julia: bool,
- julia: bool,
- inverse: bool,
-}
-
-/// Smooth escape count, or `None` inside the set.
-fn escape(z0: (f64, f64), c: (f64, f64), power: u32, limit: f64, max_iter: u32) -> Option {
- let (mut x, mut y) = z0;
- let lim2 = limit * limit;
- for i in 0..max_iter {
- let (nx, ny) = match power {
- 3 => (x * x * x - 3.0 * x * y * y, 3.0 * x * x * y - y * y * y),
- 4 => {
- let (a, b) = (x * x - y * y, 2.0 * x * y);
- (a * a - b * b, 2.0 * a * b)
- }
- _ => (x * x - y * y, 2.0 * x * y),
- };
- x = nx + c.0;
- y = ny + c.1;
- let m2 = x * x + y * y;
- if m2 > lim2 {
- let lz = m2.ln() * 0.5;
- let nu = (lz / limit.max(1.0001).ln()).max(1e-9).ln() / (power as f64).ln();
- return Some((i as f64 + 1.0 - nu).max(0.0));
- }
- }
- None
-}
-
-/// Fractal Set Choice options.
-pub(crate) const FRACTAL_SETS: [&str; 6] =
- ["Mandelbrot", "Mandelbrot Inverse", "Mandelbrot Over Julia", "Mandelbrot Inverse Over Julia", "Julia", "Julia Inverse"];
-/// Fractal Palette options.
-pub(crate) const FRACTAL_PALETTES: [&str; 4] = ["Lightness Gradient", "Hue Wheel", "Black And White", "Solid Color"];
-/// Fractal Oversample Method options.
-pub(crate) const FRACTAL_OVERSAMPLE: [&str; 2] = ["Edge Detect-Fast-May Miss Pixels", "Brute Force-Slow-Every Pixel"];
-
-fn fractal(ctx: &EffectCtx, mut b: Buf) -> Buf {
- let pr = ctx.params;
- let set_choice = pr.e("setChoice");
- let power = 2 + pr.e("equation").min(2);
- let mc = (pr.f("mandelbrot/mandelbrotX"), pr.f("mandelbrot/mandelbrotY"));
- let mmag = pr.f("mandelbrot/mandelbrotMagnification");
- let mlim = pr.f("mandelbrot/mandelbrotEscapeLimit").max(1.01);
- let jc = (pr.f("julia/juliaX"), pr.f("julia/juliaY"));
- let jmag = pr.f("julia/juliaMagnification");
- let jlim = pr.f("julia/juliaEscapeLimit").max(1.01);
- let post = (pr.f("postInversionOffset/postInversionX"), pr.f("postInversionOffset/postInversionY"));
- let overlay = pr.b("fractalColor/overlay");
- let transparency = pr.b("fractalColor/transparency");
- let transparent_inside = transparency || overlay;
- let palette = pr.e("fractalColor/palette");
- let hue = (pr.f("fractalColor/hue") / 360.0) as f32;
- let steps = pr.f("fractalColor/cycleSteps").max(1.0);
- let cyc_off = pr.f("fractalColor/cycleOffset") / 360.0;
- let edge = pr.b("fractalColor/edgeHighlight");
- let every = pr.e("highQualitySettings/samplingMethod") == 1;
- let factor = pr.f("highQualitySettings/samplingFactor").round().clamp(1.0, 9.0) as usize;
- let (w, h) = (b.img.width as usize, b.img.height as usize);
- let lw = ctx.layer_size[0].max(1.0);
- let lh = ctx.layer_size[1].max(1.0);
- let inv = 1.0 / b.scale.max(1e-9);
- let (off_x, off_y) = (b.offset[0], b.offset[1]);
- // FRACTAL_SETS order.
- let set = |julia, inverse, over_julia| FracSet { over_julia, julia, inverse };
- let sets: (FracSet, Option) = match set_choice {
- 1 => (set(false, true, false), None),
- 2 => (set(false, false, true), None),
- 3 => (set(false, true, true), None),
- 4 => (set(true, false, false), None),
- 5 => (set(true, true, false), None),
- _ => (set(false, false, false), None),
- };
- let iter_for = |mag: f64| (96.0 + 48.0 * mag.max(0.0)).clamp(64.0, 3000.0) as u32;
- let eval_set = |s: FracSet, lx: f64, ly: f64| -> Option {
- let (center, mag, lim) = if s.julia { (jc, jmag, jlim) } else { (mc, mmag, mlim) };
- let span = 3.5 / 2f64.powf(mag);
- let mut u = (lx - lw * 0.5) / lw * span + center.0;
- let mut v = (ly - lh * 0.5) / lw * span + center.1;
- if s.inverse {
- let d = (u * u + v * v).max(1e-12);
- u = u / d + post.0;
- v = -v / d + post.1;
- }
- if s.julia {
- escape((u, v), mc, power, lim, iter_for(mag))
- } else {
- let z0 = if s.over_julia { jc } else { (0.0, 0.0) };
- escape(z0, (u, v), power, lim, iter_for(mag))
- }
- };
- let eval = |lx: f64, ly: f64| -> Option {
- let a = eval_set(sets.0, lx, ly);
- match (a, sets.1) {
- (None, Some(s2)) => eval_set(s2, lx, ly),
- _ => a,
- }
- };
- let shade = |n: Option| -> Px {
- // Solid Color: only the inside of the set is drawn (Transparency flips the sides).
- if palette == 3 {
- let (r, g, bl) = hsl_to_rgb(hue, 1.0, 0.5);
- return if n.is_none() != transparency { [r, g, bl, 1.0] } else { [0.0; 4] };
- }
- let Some(n) = n else {
- return if transparent_inside { [0.0; 4] } else { [0.0, 0.0, 0.0, 1.0] };
- };
- let u = n / steps + cyc_off;
- let band = (u.rem_euclid(1.0)) as f32;
- let (r, g, bl) = match palette {
- // Hue Wheel: the full hue circle at full saturation and brightness.
- 1 => hsl_to_rgb((hue + band).rem_euclid(1.0), 1.0, 0.5),
- // Black And White: alternating bands.
- 2 => {
- let v = if (u.floor() as i64).rem_euclid(2) == 0 { 0.0 } else { 1.0 };
- (v, v, v)
- }
- // Lightness Gradient: black → hue → white, the hue moving 45° each cycle.
- _ => hsl_to_rgb((hue + u.floor() as f32 * 0.125).rem_euclid(1.0), 0.85, band.clamp(0.0, 1.0)),
- };
- let mut c = [r, g, bl];
- if edge && n.fract() < 0.12 {
- c = [c[0] * 0.4 + 0.6, c[1] * 0.4 + 0.6, c[2] * 0.4 + 0.6];
- }
- [c[0], c[1], c[2], 1.0]
- };
- // First pass: one sample per pixel.
- let mut first: Vec> = vec![None; w * h];
- first.par_chunks_mut(w.max(1)).enumerate().for_each(|(y, row)| {
- for (x, v) in row.iter_mut().enumerate() {
- *v = eval((x as f64 + 0.5 - off_x) * inv, (y as f64 + 0.5 - off_y) * inv);
- }
- });
- let src = if overlay { Some(b.img.clone()) } else { None };
- b.img.rows_mut().for_each(|(y, row)| {
- for (x, px) in row.iter_mut().enumerate() {
- let here = first[y * w + x];
- let needs_ss = factor > 1
- && (every || {
- let mut diff = false;
- for (dx, dy) in [(-1i64, 0i64), (1, 0), (0, -1), (0, 1)] {
- let (nx, ny) = (x as i64 + dx, y as i64 + dy);
- if nx < 0 || ny < 0 || nx >= w as i64 || ny >= h as i64 {
- continue;
- }
- let o = first[ny as usize * w + nx as usize];
- diff |= match (here, o) {
- (Some(a), Some(c)) => (a - c).abs() > steps * 0.25,
- (None, None) => false,
- _ => true,
- };
- }
- diff
- });
- let c = if needs_ss {
- let mut acc = [0.0f32; 4];
- for sy in 0..factor {
- for sx in 0..factor {
- let fx = x as f64 + (sx as f64 + 0.5) / factor as f64;
- let fy = y as f64 + (sy as f64 + 0.5) / factor as f64;
- let s = shade(eval((fx - off_x) * inv, (fy - off_y) * inv));
- let a = s[3];
- for k in 0..3 {
- acc[k] += s[k] * a;
- }
- acc[3] += a;
- }
- }
- let n = (factor * factor) as f32;
- [acc[0] / n, acc[1] / n, acc[2] / n, acc[3] / n]
- } else {
- let s = shade(here);
- [s[0] * s[3], s[1] * s[3], s[2] * s[3], s[3]]
- };
- *px = match &src {
- Some(o) => over(o.data[y * w + x], c),
- None => c,
- };
- }
- });
- b
-}
-
-// ---------------------------------------------------------------- Scribble
-
-/// Scan runs (start, end along direction `d`) of the fill region on the line `n·p = s`.
-#[allow(clippy::too_many_arguments)]
-fn scan_runs(polys: &[(Vec<[f64; 2]>, bool, bool)], fill: u32, ew: f64, d: [f64; 2], n: [f64; 2], s: f64, out: &mut Vec<(f64, f64)>) {
- out.clear();
- for (pts, _closed, inverted) in polys {
- let m = pts.len();
- if m < 2 {
- continue;
- }
- // Crossings: (t along d, |sin| of crossing angle).
- let mut xs: Vec<(f64, f64)> = Vec::new();
- for i in 0..m {
- let (a, b) = (pts[i], pts[(i + 1) % m]);
- let (na, nb) = (a[0] * n[0] + a[1] * n[1] - s, b[0] * n[0] + b[1] * n[1] - s);
- if (na > 0.0) == (nb > 0.0) {
- continue;
- }
- let t = na / (na - nb);
- let q = [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
- let (ex, ey) = (b[0] - a[0], b[1] - a[1]);
- let el = (ex * ex + ey * ey).sqrt().max(1e-9);
- let sin = ((ex * n[0] + ey * n[1]) / el).abs().max(0.2);
- xs.push((q[0] * d[0] + q[1] * d[1], sin));
- }
- xs.sort_by(|a, b| a.0.total_cmp(&b.0));
- // Signed area decides which side is "left".
- let area: f64 = (0..m).map(|i| pts[i][0] * pts[(i + 1) % m][1] - pts[(i + 1) % m][0] * pts[i][1]).sum();
- let left_is_inside = area < 0.0;
- let mode = match fill {
- 4 => {
- if left_is_inside {
- 2
- } else {
- 3
- }
- }
- 5 => {
- if left_is_inside {
- 3
- } else {
- 2
- }
- }
- f => f,
- };
- let mode = if *inverted && mode == 0 { 6 } else { mode };
- for (k, &(t, sin)) in xs.iter().enumerate() {
- let entering = k % 2 == 0;
- let l = ew / sin;
- match mode {
- 0 if entering && k + 1 < xs.len() => {
- out.push((t, xs[k + 1].0));
- }
- 1 => out.push((t - l * 0.5, t + l * 0.5)),
- 2 => out.push(if entering { (t, t + l) } else { (t - l, t) }),
- 3 => out.push(if entering { (t - l, t) } else { (t, t + l) }),
- _ => {}
- }
- }
- if mode == 6 {
- // Inverted Inside: outside of the polygon within the bounds.
- let lo = pts.iter().map(|q| q[0] * d[0] + q[1] * d[1]).fold(f64::INFINITY, f64::min) - ew;
- let hi = pts.iter().map(|q| q[0] * d[0] + q[1] * d[1]).fold(f64::NEG_INFINITY, f64::max) + ew;
- let mut cur = lo;
- for pair in xs.chunks(2) {
- out.push((cur, pair[0].0));
- cur = pair.get(1).map(|v| v.0).unwrap_or(hi);
- }
- out.push((cur, hi));
- }
- }
- out.sort_by(|a, b| a.0.total_cmp(&b.0));
- // Merge overlaps.
- let mut merged: Vec<(f64, f64)> = Vec::with_capacity(out.len());
- for &(a, b) in out.iter() {
- if let Some(last) = merged.last_mut()
- && a <= last.1
- {
- last.1 = last.1.max(b);
- continue;
- }
- merged.push((a, b));
- }
- *out = merged;
-}
-
-/// End Cap and Join options (Scribble's Edge Options).
-const END_CAPS: [&str; 3] = ["Round", "Butt", "Projecting"];
-const JOINS: [&str; 3] = ["Round", "Miter", "Bevel"];
-
-/// Convex polygons whose union is the stroke of the polylines `lines` with half width `r`:
-/// one quad per segment, plus the joins (Round discs, Miter wedges up to `miter_limit` × the
-/// half width, Bevel triangles) and the caps (Round discs, Butt none, Projecting square ends).
-pub(crate) fn stroke_outline(lines: &[Vec<[f64; 2]>], r: f64, cap: u32, join: u32, miter_limit: f64) -> Vec> {
- let disc = |c: [f64; 2]| -> Vec<[f64; 2]> {
- (0..16).map(|k| (k as f64 / 16.0 * std::f64::consts::TAU).sin_cos()).map(|(s, co)| [c[0] + co * r, c[1] + s * r]).collect()
- };
- let mut out = Vec::new();
- for l in lines {
- let pts: Vec<[f64; 2]> = l.iter().copied().fold(Vec::new(), |mut v, p| {
- if v.last().is_none_or(|q: &[f64; 2]| (q[0] - p[0]).hypot(q[1] - p[1]) > 1e-9) {
- v.push(p);
- }
- v
- });
- if pts.len() < 2 {
- if let (Some(p), 0) = (pts.first(), cap) {
- out.push(disc(*p));
- }
- continue;
- }
- let dir = |a: [f64; 2], b: [f64; 2]| {
- let (dx, dy) = (b[0] - a[0], b[1] - a[1]);
- let l = dx.hypot(dy).max(1e-12);
- [dx / l, dy / l]
- };
- let n = pts.len();
- for k in 0..n - 1 {
- let (mut a, mut b) = (pts[k], pts[k + 1]);
- let d = dir(a, b);
- // Projecting caps extend the end segments by the half width.
- if cap == 2 && k == 0 {
- a = [a[0] - d[0] * r, a[1] - d[1] * r];
- }
- if cap == 2 && k == n - 2 {
- b = [b[0] + d[0] * r, b[1] + d[1] * r];
- }
- let nn = [-d[1] * r, d[0] * r];
- out.push(vec![[a[0] + nn[0], a[1] + nn[1]], [b[0] + nn[0], b[1] + nn[1]], [b[0] - nn[0], b[1] - nn[1]], [a[0] - nn[0], a[1] - nn[1]]]);
- }
- // Joins.
- for k in 1..n - 1 {
- let (p, d0, d1) = (pts[k], dir(pts[k - 1], pts[k]), dir(pts[k], pts[k + 1]));
- let cross = d0[0] * d1[1] - d0[1] * d1[0];
- if cross.abs() < 1e-9 && d0[0] * d1[0] + d0[1] * d1[1] > 0.0 {
- continue;
- }
- if join == 0 {
- out.push(disc(p));
- continue;
- }
- // The outer side of the turn.
- let s = if cross > 0.0 { -1.0 } else { 1.0 };
- let o0 = [p[0] - d0[1] * r * s, p[1] + d0[0] * r * s];
- let o1 = [p[0] - d1[1] * r * s, p[1] + d1[0] * r * s];
- let bevel = vec![p, o0, o1];
- if join == 1 {
- // Miter point: where the two offset edges meet.
- let bis = [d0[0] - d1[0], d0[1] - d1[1]];
- let bl = bis[0].hypot(bis[1]);
- let cos_half = ((1.0 + d0[0] * d1[0] + d0[1] * d1[1]) * 0.5).max(0.0).sqrt();
- let len = if cos_half > 1e-6 { r / cos_half } else { f64::INFINITY };
- if bl > 1e-9 && len <= miter_limit * r {
- let m = [p[0] + (o0[0] + o1[0] - 2.0 * p[0]) * 0.5, p[1] + (o0[1] + o1[1] - 2.0 * p[1]) * 0.5];
- let ml = (m[0] - p[0]).hypot(m[1] - p[1]).max(1e-12);
- let tip = [p[0] + (m[0] - p[0]) / ml * len, p[1] + (m[1] - p[1]) / ml * len];
- out.push(vec![p, o0, tip, o1]);
- continue;
- }
- }
- out.push(bevel);
- }
- if cap == 0 {
- out.push(disc(pts[0]));
- out.push(disc(pts[n - 1]));
- }
- }
- out
-}
-
-/// Coverage (union, 4×4 samples per pixel) of convex polygons on a `w`×`h` grid.
-pub(crate) fn raster_convex(w: usize, h: usize, polys: &[Vec<[f64; 2]>]) -> Plane {
- let mut out = Plane::new(w, h);
- let inside = |poly: &[[f64; 2]], x: f64, y: f64| {
- let n = poly.len();
- let mut sign = 0.0;
- for i in 0..n {
- let (a, b) = (poly[i], poly[(i + 1) % n]);
- let c = (b[0] - a[0]) * (y - a[1]) - (b[1] - a[1]) * (x - a[0]);
- if c.abs() < 1e-12 {
- continue;
- }
- if sign == 0.0 {
- sign = c.signum();
- } else if c.signum() != sign {
- return false;
- }
- }
- true
- };
- for poly in polys {
- if poly.len() < 3 {
- continue;
- }
- let (mut x0, mut y0, mut x1, mut y1) = (f64::INFINITY, f64::INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY);
- for p in poly {
- x0 = x0.min(p[0]);
- y0 = y0.min(p[1]);
- x1 = x1.max(p[0]);
- y1 = y1.max(p[1]);
- }
- let (xa, xb) = (x0.floor().max(0.0) as usize, (x1.ceil().max(0.0) as usize).min(w));
- let (ya, yb) = (y0.floor().max(0.0) as usize, (y1.ceil().max(0.0) as usize).min(h));
- for y in ya..yb {
- for x in xa..xb {
- let mut hit = 0;
- for sy in 0..4 {
- for sx in 0..4 {
- if inside(poly, x as f64 + (sx as f64 + 0.5) / 4.0, y as f64 + (sy as f64 + 0.5) / 4.0) {
- hit += 1;
- }
- }
- }
- let v = &mut out.data[y * w + x];
- *v = v.max(hit as f32 / 16.0);
- }
- }
- }
- out
-}
-
-fn scribble(ctx: &EffectCtx, mut b: Buf) -> Buf {
- match scribble_plan(ctx, &b) {
- Some(plan) => draw_paint(&mut b, &plan),
- None if scribble_style(ctx) == 1 => b.img = Image::new(b.img.width, b.img.height),
- None => {}
- }
- b
-}
-
-fn scribble_plan(ctx: &EffectCtx, b: &Buf) -> Option {
- let pr = ctx.params;
- let which = pr.e("scribble");
- let polys: Vec<_> = if which == 0 { mask_px(ctx, b, pr.f("mask").round().max(1.0) as usize).into_iter().collect() } else { all_masks_px(ctx, b) };
- let polys: Vec<_> = polys.into_iter().filter(|p| p.0.len() >= 3).map(|(p, c, i)| (p, c, i && which == 2)).collect();
- let style = scribble_style(ctx);
- if polys.is_empty() {
- return None;
- }
- let sc = b.scale;
- let fill = pr.e("fillType");
- let ew = pr.f("edgeOptions/edgeWidth").max(0.1) * sc;
- let ang = pr.f("angle").to_radians();
- let d = [ang.cos(), ang.sin()];
- let n = [-d[1], d[0]];
- let width = (pr.f("strokeWidth") * sc).max(0.1);
- let curv = pr.f("strokeOptions/curviness") / 100.0;
- let curv_var = pr.f("strokeOptions/curvinessVariation") / 100.0;
- let spacing = (pr.f("strokeOptions/spacing") * sc).max(0.75).max(width * 0.25);
- let spacing_var = pr.f("strokeOptions/spacingVariation") / 100.0;
- let overlap = pr.f("strokeOptions/pathOverlap") / 100.0;
- let overlap_var = pr.f("strokeOptions/pathOverlapVariation") / 100.0;
- let start = pr.f("start").clamp(0.0, 100.0) / 100.0;
- let end = pr.f("end").clamp(0.0, 100.0) / 100.0;
- let sequential = pr.b("fillPathsSequentially");
- let wiggle = pr.e("wiggleType");
- let wps = pr.f("wigglesPerSecond").max(0.0);
- let seed = pr.f("randomSeed") as i64 as u32 ^ ctx.seed;
- let (step, frac) = match wiggle {
- 0 => (0u32, 0.0f32),
- 1 => ((ctx.time * wps).floor().max(0.0) as u32, 0.0),
- _ => {
- let u = (ctx.time * wps).max(0.0);
- (u.floor() as u32, smoothstep(0.0, 1.0, u.fract() as f32))
- }
- };
- let rnd = |i: u32, k: u32| {
- let a = hash1(i, k.wrapping_mul(31).wrapping_add(step.wrapping_mul(7919)), seed) * 2.0 - 1.0;
- if frac > 0.0 {
- let c = hash1(i, k.wrapping_mul(31).wrapping_add((step + 1).wrapping_mul(7919)), seed) * 2.0 - 1.0;
- a + (c - a) * frac
- } else {
- a
- }
- };
- let groups: Vec, bool, bool)>> =
- if which == 0 || sequential { vec![polys.clone()] } else { polys.iter().map(|p| vec![p.clone()]).collect() };
- // Per group a zig-zag polyline (in buffer px).
- let mut lines: Vec>> = Vec::new();
- let mut runs = Vec::new();
- for (gi, g) in groups.iter().enumerate() {
- let mut nmin = f64::INFINITY;
- let mut nmax = f64::NEG_INFINITY;
- for (pts, _, _) in g {
- for q in pts {
- let v = q[0] * n[0] + q[1] * n[1];
- nmin = nmin.min(v);
- nmax = nmax.max(v);
- }
- }
- nmin -= ew;
- nmax += ew;
- // Chains of zig-zags: each run joins the nearest chain that ended on the previous
- // scan line (so separate regions get separate strokes).
- let mut chains: Vec<(Vec<[f64; 2]>, u32)> = Vec::new();
- let mut s = nmin + spacing * 0.5;
- let mut li = 0u32;
- let reach = spacing * 3.0 + ew;
- while s < nmax && li < 20_000 {
- scan_runs(g, fill, ew, d, n, s, &mut runs);
- for (ri, &(a, bb)) in runs.iter().enumerate() {
- let k = (gi as u32) << 20 | ri as u32;
- let ov = spacing * (overlap + overlap_var * rnd(li, k * 4) as f64 * 0.5).max(-0.45);
- let ov2 = spacing * (overlap + overlap_var * rnd(li, k * 4 + 1) as f64 * 0.5).max(-0.45);
- let (a, bb) = (a - ov, bb + ov2);
- if bb <= a {
- continue;
- }
- let at = |t: f64| [d[0] * t + n[0] * s, d[1] * t + n[1] * s];
- let (pa, pb) = (at(a), at(bb));
- let dist = |p: [f64; 2], q: [f64; 2]| ((p[0] - q[0]).powi(2) + (p[1] - q[1]).powi(2)).sqrt();
- let best = chains
- .iter()
- .enumerate()
- .filter(|(_, c)| li > 0 && c.1 == li - 1)
- .map(|(i, c)| {
- let last = *c.0.last().unwrap_or(&pa);
- (i, dist(last, pa).min(dist(last, pb)))
- })
- .filter(|&(_, dd)| dd < reach)
- .min_by(|x, y| x.1.total_cmp(&y.1));
- match best {
- Some((ci, _)) => {
- let last = *chains[ci].0.last().unwrap_or(&pa);
- let (p0, p1, dir) = if dist(last, pa) <= dist(last, pb) { (pa, pb, -1.0) } else { (pb, pa, 1.0) };
- // Curved turn: an extra point pushed past the edge.
- let c = (curv + curv_var * rnd(li, k * 4 + 2) as f64 * 0.5).max(0.0);
- let mid = [(last[0] + p0[0]) * 0.5 + d[0] * dir * c * spacing, (last[1] + p0[1]) * 0.5 + d[1] * dir * c * spacing];
- let ch = &mut chains[ci];
- ch.0.extend([mid, p0, p1]);
- ch.1 = li;
- }
- None => chains.push((vec![pa, pb], li)),
- }
- }
- s += spacing * (1.0 + spacing_var * rnd(li, 3) as f64 * 0.5).max(0.25);
- li += 1;
- }
- lines.push(chains.into_iter().map(|(z, _)| if curv > 0.0 { chaikin(&z, 2) } else { z }).collect());
- }
- let r = width * 0.5;
- // Start / End Apply To: all of a mask's strokes as one path, or each stroke on its own.
- let each = pr.e("startEndApplyTo") == 1;
- let mut parts: Vec> = Vec::new();
- for group in &lines {
- let lens: Vec = group.iter().map(|l| poly_length(l, false)).collect();
- let total: f64 = lens.iter().sum();
- let (g0, g1) = (total * start, total * end);
- let mut acc = 0.0;
- for (l, len) in group.iter().zip(lens) {
- let part =
- if each { trim_poly(l, false, len * start, len * end) } else { trim_poly(l, false, (g0 - acc).clamp(0.0, len), (g1 - acc).clamp(0.0, len)) };
- acc += len;
- parts.push(part);
- }
- }
- let cap = pr.e("edgeOptions/endCap");
- let join = pr.e("edgeOptions/join");
- let cov = if cap == 0 && join == 0 {
- let mut segs = Vec::new();
- for part in &parts {
- poly_segs(part, false, r, 1.0, &mut segs);
- }
- Coverage::Segs { segs, hardness: 0.9 }
- } else {
- Coverage::Convex(stroke_outline(&parts, r, cap, join, pr.f("edgeOptions/miterLimit").max(1.0)))
- };
- Some(PaintPlan { cov, color: pr.color("color"), opacity: (pr.f("opacity") / 100.0) as f32, style })
-}
-
-// ---------------------------------------------------------------- Stroke
-
-fn stroke(ctx: &EffectCtx, mut b: Buf) -> Buf {
- let plan = stroke_plan(ctx, &b);
- draw_paint(&mut b, &plan);
- b
-}
-
-fn stroke_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {
- let pr = ctx.params;
- let all = pr.b("allMasks");
- let polys: Vec<_> = if all { all_masks_px(ctx, b) } else { mask_px(ctx, b, pr.f("path").round() as usize).into_iter().collect() };
- let style = pr.e("paintStyle");
- let size = (pr.f("brushSize") * b.scale).max(0.1);
- let r = size * 0.5;
- let hard = pr.f("brushHardness") / 100.0;
- let start = pr.f("start").clamp(0.0, 100.0) / 100.0;
- let end = pr.f("end").clamp(0.0, 100.0) / 100.0;
- let spacing = pr.f("spacing") / 100.0;
- let sequential = pr.b("strokeSequentially");
- let lens: Vec = polys.iter().map(|(p, c, _)| poly_length(p, *c)).collect();
- let total: f64 = lens.iter().sum();
- let mut segs = Vec::new();
- let mut acc = 0.0;
- for ((pts, closed, _), &len) in polys.iter().zip(&lens) {
- let (s0, s1) = if all && sequential {
- let (g0, g1) = (total * start, total * end);
- ((g0 - acc).clamp(0.0, len), (g1 - acc).clamp(0.0, len))
- } else {
- (len * start, len * end)
- };
- acc += len;
- if s1 <= s0 {
- continue;
- }
- if spacing <= 0.5 {
- let part = trim_poly(pts, *closed, s0, s1);
- poly_segs(&part, false, r, 1.0, &mut segs);
- } else {
- let step = (size * spacing).max(0.5);
- let mut s = s0;
- while s <= s1 + 1e-9 && segs.len() < 200_000 {
- let (q, _) = crate::util::poly_point_at(pts, *closed, s);
- segs.push(Seg { a: q, b: q, r, v: 1.0 });
- s += step;
- }
- }
- }
- PaintPlan { cov: Coverage::Segs { segs, hardness: hard }, color: pr.color("color"), opacity: (pr.f("opacity") / 100.0) as f32, style }
-}
-
-// ---------------------------------------------------------------- Vegas
-
-/// Marching-squares iso-contours of `pl` at `thr`, chained into polylines (closed flag).
-fn contours(pl: &Plane, thr: f32) -> Vec<(Vec<[f64; 2]>, bool)> {
- use std::collections::HashMap;
- let (w, h) = (pl.w, pl.h);
- if w < 2 || h < 2 {
- return Vec::new();
- }
- // Edge key: horizontal edge (x,y)-(x+1,y) = 2*(y*w+x), vertical (x,y)-(x,y+1) = 2*(y*w+x)+1.
- let hk = |x: usize, y: usize| 2 * (y * w + x) as u64;
- let vk = |x: usize, y: usize| 2 * (y * w + x) as u64 + 1;
- let mut pos: HashMap = HashMap::new();
- let mut adj: HashMap> = HashMap::new();
- let v = |x: usize, y: usize| pl.data[y * w + x];
- let interp = |a: f32, b: f32| if (b - a).abs() > 1e-9 { ((thr - a) / (b - a)).clamp(0.0, 1.0) as f64 } else { 0.5 };
- for y in 0..h - 1 {
- for x in 0..w - 1 {
- let (a, bb, c, d) = (v(x, y), v(x + 1, y), v(x + 1, y + 1), v(x, y + 1));
- let idx = (a > thr) as u8 | ((bb > thr) as u8) << 1 | ((c > thr) as u8) << 2 | ((d > thr) as u8) << 3;
- if idx == 0 || idx == 15 {
- continue;
- }
- // Edge points (pixel centres at +0.5).
- let top = (hk(x, y), [x as f64 + 0.5 + interp(a, bb), y as f64 + 0.5]);
- let right = (vk(x + 1, y), [x as f64 + 1.5, y as f64 + 0.5 + interp(bb, c)]);
- let bottom = (hk(x, y + 1), [x as f64 + 0.5 + interp(d, c), y as f64 + 1.5]);
- let left = (vk(x, y), [x as f64 + 0.5, y as f64 + 0.5 + interp(a, d)]);
- let pairs: &[(usize, usize)] = match idx {
- 1 | 14 => &[(3, 0)],
- 2 | 13 => &[(0, 1)],
- 3 | 12 => &[(3, 1)],
- 4 | 11 => &[(1, 2)],
- 5 => &[(3, 0), (1, 2)],
- 6 | 9 => &[(0, 2)],
- 7 | 8 => &[(3, 2)],
- 10 => &[(0, 1), (2, 3)],
- _ => &[],
- };
- let e = [top, right, bottom, left];
- for &(i, j) in pairs {
- pos.insert(e[i].0, e[i].1);
- pos.insert(e[j].0, e[j].1);
- adj.entry(e[i].0).or_default().push(e[j].0);
- adj.entry(e[j].0).or_default().push(e[i].0);
- }
- }
- }
- let mut keys: Vec = adj.keys().copied().collect();
- keys.sort_unstable();
- // Start open chains at endpoints (degree 1) first, then closed loops.
- keys.sort_by_key(|k| adj[k].len() != 1);
- let mut used: std::collections::HashSet<(u64, u64)> = std::collections::HashSet::new();
- let mut out = Vec::new();
- for &k0 in &keys {
- for &first in &adj[&k0] {
- if used.contains(&(k0.min(first), k0.max(first))) {
- continue;
- }
- let mut chain = vec![pos[&k0]];
- let (mut prev, mut cur) = (k0, first);
- used.insert((prev.min(cur), prev.max(cur)));
- let mut closed = false;
- loop {
- chain.push(pos[&cur]);
- if cur == k0 {
- closed = true;
- chain.pop();
- break;
- }
- let next = adj[&cur].iter().copied().find(|&n| n != prev && !used.contains(&(cur.min(n), cur.max(n))));
- match next {
- Some(n) => {
- used.insert((cur.min(n), cur.max(n)));
- prev = cur;
- cur = n;
- }
- None => break,
- }
- }
- if chain.len() >= 2 {
- out.push((chain, closed));
- }
- }
- }
- out
-}
-
-fn vegas(ctx: &EffectCtx, mut b: Buf) -> Buf {
- let plan = vegas_plan(ctx, &b);
- draw_paint(&mut b, &plan);
- b
-}
-
-fn vegas_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {
- let pr = ctx.params;
- let (w, h) = (b.img.width as usize, b.img.height as usize);
- let sc = b.scale;
- let paths: Vec<(Vec<[f64; 2]>, bool)> = if pr.e("stroke") == 1 {
- mask_px(ctx, b, pr.f("path").round() as usize).map(|(p, c, _)| vec![(p, c)]).unwrap_or_default()
- } else {
- let src = layer_or_self(ctx, b, "inputLayer", true, pr.e("ifLayerSizesDiffer") == 1);
- let ch = pr.e("channel");
- let inv = pr.b("invertInput");
- let mut pl = Plane::from_image(&src, |px| {
- let (c, a) = unpremul(px);
- let v = match ch {
- 1 => c[0],
- 2 => c[1],
- 3 => c[2],
- 4 => a,
- _ => luminance(c[0], c[1], c[2]) * a,
- };
- if inv { 1.0 - v } else { v }
- });
- let blur = pr.f("preBlur") * sc;
- if blur > 0.05 {
- pl = gauss_plane(&pl, blur, blur);
- }
- let mut cs = contours(&pl, (pr.f("threshold") / 100.0) as f32);
- // Simplify by tolerance (drop points closer than tol × size).
- let tol = pr.f("tolerance").max(0.0) * (w.max(h) as f64) * 0.1;
- if tol > 0.0 {
- for (c, _) in cs.iter_mut() {
- let mut keep: Vec<[f64; 2]> = Vec::with_capacity(c.len());
- for &q in c.iter() {
- if keep.last().is_none_or(|l: &[f64; 2]| ((l[0] - q[0]).powi(2) + (l[1] - q[1]).powi(2)).sqrt() >= tol) {
- keep.push(q);
- }
- }
- *c = keep;
- }
- }
- cs.sort_by(|a, b| poly_length(&b.0, b.1).total_cmp(&poly_length(&a.0, a.1)));
- if pr.e("renderMode") == 1 {
- let sel = (pr.f("selectedContour").round().max(1.0) as usize) - 1;
- cs.into_iter().skip(sel).take(1).collect()
- } else {
- cs
- }
- };
- let nseg = pr.f("segments").round().clamp(1.0, 1000.0) as usize;
- // Shorter Contours Have Fewer Segments: segment count scales with contour length.
- let fewer = pr.e("stroke") == 0 && pr.e("shorterContoursHave") == 1;
- let longest = paths.iter().map(|(p, c)| poly_length(p, *c)).fold(0.0, f64::max);
- let seg_len = pr.f("length").clamp(0.0, 1.0);
- let bunched = pr.e("segmentDistribution") == 0;
- let rot = pr.f("rotation") / 360.0;
- let random_phase = pr.b("randomPhase");
- let seed = pr.f("randomSeed") as i64 as u32 ^ ctx.seed;
- let width = (pr.f("width") * sc).max(0.1);
- let hard = pr.f("hardness").clamp(0.0, 1.0);
- let (o0, om, o1, mp) = (pr.f("startOpacity") as f32, pr.f("midpointOpacity") as f32, pr.f("endOpacity") as f32, pr.f("midpointPosition").clamp(0.01, 0.99));
- let mut segs = Vec::new();
- for (ci, (pts, closed)) in paths.iter().enumerate() {
- let len = poly_length(pts, *closed);
- if len <= 0.0 {
- continue;
- }
- let phase = rot + if random_phase { hash1(ci as u32, 1, seed) as f64 } else { 0.0 };
- let nseg = if fewer && longest > 0.0 { ((nseg as f64 * len / longest).round() as usize).max(1) } else { nseg };
- let each = len / nseg as f64 * seg_len;
- for i in 0..nseg {
- let base = if bunched { (i as f64 + (hash1(ci as u32, i as u32 + 7, seed) as f64 - 0.5) * 0.8) / nseg as f64 } else { i as f64 / nseg as f64 };
- let s0 = (base + phase).rem_euclid(1.0) * len;
- // Sub-sample the segment so opacity can ramp along it.
- let sub = 12usize;
- let mut prev: Option<[f64; 2]> = None;
- for k in 0..=sub {
- let f = k as f64 / sub as f64;
- let mut s = s0 + each * f;
- if *closed {
- s = s.rem_euclid(len);
- } else if s > len {
- break;
- }
- let (q, _) = crate::util::poly_point_at(pts, *closed, s);
- let op = if f < mp { o0 + (om - o0) * (f / mp) as f32 } else { om + (o1 - om) * ((f - mp) / (1.0 - mp)) as f32 };
- if let Some(pv) = prev
- && ((pv[0] - q[0]).powi(2) + (pv[1] - q[1]).powi(2)) < (each * 0.5).powi(2) + 4.0
- {
- segs.push(Seg { a: pv, b: q, r: width * 0.5, v: op.clamp(0.0, 1.0) });
- }
- prev = Some(q);
- }
- }
- }
- let style = match pr.e("blendMode") {
- 1 => 0,
- 2 => 3,
- 3 => 2,
- _ => 1,
- };
- PaintPlan { cov: Coverage::Segs { segs, hardness: hard }, color: pr.color("color"), opacity: 1.0, style }
-}
-
-// ---------------------------------------------------------------- Write-on / Glue Gun
-
-/// Write-on draws a stroke along the animated Brush Position, as in After Effects: a dab every
-/// Brush Spacing seconds from the layer's start up to now, each one lasting Stroke Length
-/// seconds (0: for ever). The dabs' positions come from the host's parameters at their times;
-/// with Paint Time Properties ▸ Opacity or Brush Time Properties ▸ Size each dab keeps its own
-/// opacity or size, else the current ones apply to every dab. (Colour and hardness are one per
-/// stroke: the current ones.) Without a host (or dabs) the current dab draws. Deterministic.
-fn write_on(ctx: &EffectCtx, mut b: Buf) -> Buf {
- let plan = write_on_plan(ctx, &b);
- draw_paint(&mut b, &plan);
- b
-}
-
-/// The most dabs one Write-on frame draws; longer strokes lay them further apart, joined.
-const WRITE_ON_MAX_DABS: i64 = 4096;
-
-fn write_on_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {
- let pr = ctx.params;
- let own_opacity = pr.e("paintTimeProperties") == 1;
- let own_size = matches!(pr.e("brushTimeProperties"), 1 | 3);
- let opacity = |p: &Params| (p.f("brushOpacity") / 100.0).clamp(0.0, 1.0) as f32;
- let radius = |p: &Params| (p.f("brushSize") * b.scale * 0.5).max(0.05);
- let dab = |p: &Params| {
- let q = b.to_px(p.v2("brushPosition"));
- ([q.0, q.1], radius(if own_size { p } else { pr }), if own_opacity { opacity(p) } else { 1.0 })
- };
- let mut segs = vec![];
- let t = ctx.time;
- let spacing = pr.f("brushSpacing").max(0.001);
- let life = pr.f("strokeLength").max(0.0);
- if let Some(host) = ctx.env.host
- && t.is_finite()
- && t >= 0.0
- {
- let start = if life > 0.0 { (t - life).max(0.0) } else { 0.0 };
- let k0 = (start / spacing - 1e-9).ceil().max(0.0) as i64;
- let k1 = (t / spacing + 1e-9).floor().max(0.0) as i64;
- let n = k1.saturating_sub(k0).saturating_add(1);
- let stride = (n / WRITE_ON_MAX_DABS).saturating_add(1).max(1);
- let mut prev: Option<[f64; 2]> = None;
- let mut k = k0;
- while k <= k1 {
- let tk = k as f64 * spacing;
- let at = if (tk - t).abs() < 1e-9 { Some(dab(pr)) } else { host.params_at(tk).map(|p| dab(&p)) };
- if let Some((q, r, v)) = at {
- // Dabs laid further apart than the brush spacing are joined into a line.
- let a = if stride > 1 { prev.unwrap_or(q) } else { q };
- segs.push(Seg { a, b: q, r, v });
- prev = Some(q);
- }
- k = k.saturating_add(stride);
- }
- }
- if segs.is_empty() {
- let (q, r, v) = dab(pr);
- segs.push(Seg { a: q, b: q, r, v });
- }
- PaintPlan {
- cov: Coverage::Segs { segs, hardness: pr.f("brushHardness") / 100.0 },
- color: pr.color("color"),
- opacity: if own_opacity { 1.0 } else { opacity(pr) },
- style: pr.e("paintStyle"),
- }
-}
-
-fn glue_gun(ctx: &EffectCtx, mut b: Buf) -> Buf {
- let pr = ctx.params;
- let q = b.to_px(pr.v2("brushPosition"));
- let rad = (pr.f("strokeWidth") * b.scale * 0.5).max(0.5);
- let density = pr.f("density").max(0.0);
- let refl = pr.f("reflection").to_radians();
- let strength = (pr.f("strength") / 100.0) as f32;
- let glue_only = pr.e("style") == 1;
- let src = b.img.clone();
- let light = [refl.cos() * 0.6, -refl.sin() * 0.6, 0.53];
- let beads = (density.round() as usize).clamp(1, 32);
- let seed = ctx.seed;
- let centers: Vec<([f64; 2], f64)> = (0..beads)
- .map(|i| {
- let a = hash1(i as u32, 1, seed) as f64 * 2.0 * PI;
- let d = if i == 0 { 0.0 } else { hash1(i as u32, 2, seed) as f64 * rad * 0.35 };
- ([q.0 + a.cos() * d, q.1 + a.sin() * d], rad * (0.75 + 0.25 * hash1(i as u32, 3, seed) as f64))
- })
- .collect();
- b.img.rows_mut().for_each(|(y, row)| {
- for (x, px) in row.iter_mut().enumerate() {
- let (fx, fy) = (x as f64 + 0.5, y as f64 + 0.5);
- // Height field: union of hemispheres.
- let mut best = (0.0f64, [0.0f64; 2], 1.0f64);
- for &(c, r) in ¢ers {
- let (dx, dy) = ((fx - c[0]) / r, (fy - c[1]) / r);
- let d2 = dx * dx + dy * dy;
- if d2 < 1.0 {
- let hgt = (1.0 - d2).sqrt();
- if hgt > best.0 {
- best = (hgt, [dx, dy], r);
- }
- }
- }
- if best.0 <= 0.0 {
- if glue_only {
- *px = [0.0; 4];
- }
- continue;
- }
- let nrm = [best.1[0], best.1[1], best.0];
- let ndl = (nrm[0] * light[0] + nrm[1] * light[1] + nrm[2] * light[2]).max(0.0);
- let spec = ndl.powi(24) as f32;
- // Refraction: look through the bead.
- let s = src.sample_bilinear_clamped(fx - nrm[0] * best.2 * 0.5 * strength as f64, fy - nrm[1] * best.2 * 0.5 * strength as f64);
- let edge = smoothstep(0.0, 0.15, best.0 as f32);
- let shade = 0.65 + 0.35 * ndl as f32;
- let g = [s[0] * shade + spec, s[1] * shade + spec, s[2] * shade + spec, s[3].max(0.6)];
- let gp = [g[0].min(g[3] + spec), g[1].min(g[3] + spec), g[2].min(g[3] + spec), g[3].min(1.0)];
- let base = if glue_only { [0.0; 4] } else { *px };
- *px = crate::util::lerp4(base, gp, edge * strength.clamp(0.0, 1.0).max(0.3));
- px[3] = px[3].clamp(0.0, 1.0);
- }
- });
- b
-}
-
-// ---------------------------------------------------------------- Paint Bucket
-
-/// Paint Bucket's filled region (1 inside) on `b`: the flood fill from the Fill Point over the
-/// layer's pixels (shared with the GPU compositor, which reads the layer back for it).
-pub fn paint_bucket_region(ctx: &EffectCtx, b: &Buf) -> Plane {
- let pr = ctx.params;
- let (w, h) = (b.img.width as usize, b.img.height as usize);
- let fp = b.to_px(pr.v2("fillPoint"));
- let (sx, sy) = (fp.0.floor() as i64, fp.1.floor() as i64);
- let sel = pr.e("fillSelector");
- let tol = (pr.f("tolerance") / 255.0) as f32;
- let key = |p: Px| -> [f32; 4] {
- let (c, a) = unpremul(p);
- match sel {
- 1 => [c[0], c[1], c[2], 0.0],
- 2 => [0.0, 0.0, 0.0, if a <= 1e-3 { 0.0 } else { 1.0 }],
- 3 | 4 => [0.0, 0.0, 0.0, a],
- _ => p,
- }
- };
- let mut region = Plane::new(w, h);
- if sx >= 0 && sy >= 0 && (sx as usize) < w && (sy as usize) < h {
- let seed = key(b.img.data[sy as usize * w + sx as usize]);
- let within = |i: usize| {
- let k = key(b.img.data[i]);
- if sel == 2 {
- return k[3] == seed[3];
- }
- (0..4).all(|j| (k[j] - seed[j]).abs() <= tol + 1e-6)
- };
- let mut seen = vec![false; w * h];
- let mut stack = vec![(sx as usize, sy as usize)];
- while let Some((x, y)) = stack.pop() {
- let row = y * w;
- if seen[row + x] || !within(row + x) {
- continue;
- }
- let mut l = x;
- while l > 0 && !seen[row + l - 1] && within(row + l - 1) {
- l -= 1;
- }
- let mut r = x;
- while r + 1 < w && !seen[row + r + 1] && within(row + r + 1) {
- r += 1;
- }
- for i in l..=r {
- seen[row + i] = true;
- region.data[row + i] = 1.0;
- if y > 0 && !seen[row - w + i] {
- stack.push((i, y - 1));
- }
- if y + 1 < h && !seen[row + w + i] {
- stack.push((i, y + 1));
- }
- }
- }
- }
- region
-}
-
-fn paint_bucket(ctx: &EffectCtx, mut b: Buf) -> Buf {
- let pr = ctx.params;
- let (w, h) = (b.img.width as usize, b.img.height as usize);
- if w == 0 || h == 0 {
- return b;
- }
- let region = paint_bucket_region(ctx, &b);
- if pr.b("viewThreshold") {
- b.img.data.par_iter_mut().zip(region.data.par_iter()).for_each(|(px, &v)| *px = [v, v, v, 1.0]);
- return b;
- }
- let sc = b.scale;
- let mut cov = match pr.e("stroke") {
- 1 => {
- let s = pr.f("featherSoftness") * sc * 0.5;
- if s > 0.05 { gauss_plane(®ion, s, s) } else { region.clone() }
- }
- 2 => morph_frac(®ion, pr.f("spreadRadius") * sc, true),
- 3 => morph_frac(®ion, pr.f("spreadRadius") * sc, false),
- 4 => {
- let r = pr.f("strokeWidth") * sc;
- let out = morph_frac(®ion, r * 0.5, true);
- let inn = morph_frac(®ion, r * 0.5, false);
- out.zip_map(&inn, |a, b| (a - b).max(0.0))
- }
- _ => gauss_plane(®ion, 0.5, 0.5),
- };
- if pr.e("stroke") == 0 {
- // Antialias: keep the hard interior, soften only the boundary.
- cov = cov.zip_map(®ion, |a, r| if r > 0.0 { a.max(0.5) } else { a });
- }
- let color = pr.color("color");
- let op = (pr.f("opacity") / 100.0) as f32;
- let mode = pr.e("blendingMode");
- b.img.data.par_iter_mut().zip(cov.data.par_iter()).for_each(|(px, &c)| {
- let k = (c * op * color[3]).clamp(0.0, 1.0);
- if k <= 0.0 {
- if mode == 9 {
- *px = [0.0; 4];
- }
- return;
- }
- let (dc, da) = unpremul(*px);
- let fc = [color[0], color[1], color[2]];
- let mixed = match mode {
- 1 => [dc[0] + fc[0], dc[1] + fc[1], dc[2] + fc[2]],
- 2 => [dc[0] * fc[0], dc[1] * fc[1], dc[2] * fc[2]],
- 3 => [1.0 - (1.0 - dc[0]) * (1.0 - fc[0]), 1.0 - (1.0 - dc[1]) * (1.0 - fc[1]), 1.0 - (1.0 - dc[2]) * (1.0 - fc[2])],
- 4..=7 => {
- let (dh, ds, dl) = rgb_to_hsl(dc[0], dc[1], dc[2]);
- let (fh, fs, fl) = rgb_to_hsl(fc[0], fc[1], fc[2]);
- let (r, g, bl) = match mode {
- 4 => hsl_to_rgb(fh, ds, dl),
- 5 => hsl_to_rgb(dh, fs, dl),
- 6 => hsl_to_rgb(fh, fs, dl),
- _ => hsl_to_rgb(dh, ds, fl),
- };
- [r, g, bl]
- }
- _ => fc,
- };
- *px = match mode {
- 8 => over(premul(fc, k), *px),
- 9 => premul(fc, k),
- 0 => over(*px, premul(fc, k)),
- _ => {
- if da <= 1e-6 {
- return;
- }
- let c3 = crate::util::lerp3(dc, mixed, k);
- premul(c3, da)
- }
- };
- });
- b
-}
-
-// ---------------------------------------------------------------- Eyedropper Fill
-
-fn eyedropper_fill(ctx: &EffectCtx, mut b: Buf) -> Buf {
- let pr = ctx.params;
- let fill = eyedropper_color(ctx, &b);
- let keep_alpha = pr.b("maintainOriginalAlpha");
- let blend = (pr.f("blendWithOriginal") / 100.0) as f32;
- b.img.data.par_iter_mut().for_each(|px| {
- let a = if keep_alpha { px[3] } else { fill[3] };
- let f = premul([fill[0], fill[1], fill[2]], a);
- *px = crate::util::lerp4(f, *px, blend);
- });
- b
-}
-
-/// Eyedropper Fill's sampled colour (straight RGB, alpha) from the layer's pixels (shared with
-/// the GPU compositor, which reads the layer back for it).
-pub fn eyedropper_color(ctx: &EffectCtx, b: &Buf) -> Px {
- let pr = ctx.params;
- let (w, h) = (b.img.width as i64, b.img.height as i64);
- let c = b.to_px(pr.v2("samplePoint"));
- let r = (pr.f("sampleRadius") * b.scale).max(0.0);
- let mode = pr.e("averagePixelColors");
- let (cx, cy) = (c.0.floor() as i64, c.1.floor() as i64);
- let ri = r.ceil() as i64;
- let mut acc = [0.0f64; 4];
- let mut n = 0.0f64;
- for y in (cy - ri).max(0)..=(cy + ri).min(h - 1) {
- for x in (cx - ri).max(0)..=(cx + ri).min(w - 1) {
- if ((x - cx).pow(2) + (y - cy).pow(2)) as f64 > r * r + 0.5 {
- continue;
- }
- let px = b.img.data[(y * w + x) as usize];
- match mode {
- 0 => {
- if px[3] > 1e-4 {
- let (s, _) = unpremul(px);
- for k in 0..3 {
- acc[k] += s[k] as f64;
- }
- acc[3] += 1.0;
- n += 1.0;
- }
- }
- 1 => {
- let (s, _) = unpremul(px);
- for k in 0..3 {
- acc[k] += s[k] as f64;
- }
- acc[3] += 1.0;
- n += 1.0;
- }
- 2 => {
- for k in 0..3 {
- acc[k] += px[k] as f64;
- }
- acc[3] += 1.0;
- n += 1.0;
- }
- _ => {
- for k in 0..4 {
- acc[k] += px[k] as f64;
- }
- n += 1.0;
- }
- }
- }
- }
- if n > 0.0 {
- if mode == 3 {
- let a = (acc[3] / n) as f32;
- let s = if a > 1e-6 { [(acc[0] / n) as f32 / a, (acc[1] / n) as f32 / a, (acc[2] / n) as f32 / a] } else { [0.0; 3] };
- [s[0], s[1], s[2], a]
- } else {
- [(acc[0] / n) as f32, (acc[1] / n) as f32, (acc[2] / n) as f32, 1.0]
- }
- } else {
- [0.0, 0.0, 0.0, 0.0]
- }
-}
-
-// ---------------------------------------------------------------- CC Threads
-
-fn threads(ctx: &EffectCtx, mut b: Buf) -> Buf {
- let pr = ctx.params;
- let sc = b.scale;
- let tw = (pr.f("width") * sc).max(1.0);
- let th = (pr.f("height") * sc).max(1.0);
- let overlaps = pr.f("overlaps").round().clamp(1.0, 20.0) as i64;
- let ang = pr.f("direction").to_radians();
- let (sn, cs) = ang.sin_cos();
- let c = b.to_px(pr.v2("center"));
- let coverage = (pr.f("coverage") / 100.0).clamp(0.0, 1.0);
- let shadow = (pr.f("shadowing") / 100.0) as f32;
- let texture = (pr.f("texture") / 100.0) as f32;
- let src = b.img.clone();
- let to_px = |u: f64, v: f64| (c.0 + u * cs - v * sn, c.1 + u * sn + v * cs);
- b.img.rows_mut().for_each(|(y, row)| {
- for (x, px) in row.iter_mut().enumerate() {
- let (dx, dy) = (x as f64 + 0.5 - c.0, y as f64 + 0.5 - c.1);
- let u = dx * cs + dy * sn;
- let v = -dx * sn + dy * cs;
- let (ci, cj) = ((u / tw).floor() as i64, (v / th).floor() as i64);
- let (fu, fv) = (u / tw - ci as f64, v / th - cj as f64);
- // Horizontal thread j occupies the band |fv-0.5| < coverage/2; vertical thread i the
- // band |fu-0.5| < coverage/2.
- let in_h = (fv - 0.5).abs() < coverage * 0.5;
- let in_v = (fu - 0.5).abs() < coverage * 0.5;
- // Twill: horizontal is on top when (i + j) mod (2·overlaps) < overlaps.
- let h_top = (ci + cj).rem_euclid(2 * overlaps) < overlaps;
- let which = match (in_h, in_v) {
- (true, true) => Some(h_top),
- (true, false) => Some(true),
- (false, true) => Some(false),
- _ => None,
- };
- let Some(horizontal) = which else {
- *px = [0.0; 4];
- continue;
- };
- // Thread colour: the source sampled along the thread centre line.
- let (sx, sy) = if horizontal { to_px(u, (cj as f64 + 0.5) * th) } else { to_px((ci as f64 + 0.5) * tw, v) };
- let s = src.sample_bilinear_clamped(sx, sy);
- // Round profile across the thread + darkening where it dives under its neighbour.
- let across = if horizontal { (fv - 0.5) / (coverage * 0.5).max(1e-6) } else { (fu - 0.5) / (coverage * 0.5).max(1e-6) };
- let along = if horizontal { fu } else { fv };
- let profile = (1.0 - across * across).max(0.0).sqrt() as f32;
- let dive = 1.0 - (along - 0.5).abs() as f32 * 2.0;
- let shade = 1.0 - shadow * (1.0 - profile) * 0.8 - shadow * 0.25 * (1.0 - dive) * if horizontal == h_top { 0.0 } else { 1.0 };
- let fib =
- if texture > 0.0 { 1.0 - texture * 0.3 * hash1((along * 64.0) as u32, (across * 8.0 + 8.0) as u32, ci as u32 ^ (cj as u32) << 8) } else { 1.0 };
- let k = (shade * fib).max(0.0);
- *px = [s[0] * k, s[1] * k, s[2] * k, s[3]];
- }
- });
- b
-}
-
-// ---------------------------------------------------------------- Audio Spectrum / Waveform
-
-/// In-place iterative radix-2 FFT (`re`, `im` lengths a power of two).
-pub(crate) fn fft(re: &mut [f64], im: &mut [f64]) {
- let n = re.len();
- if n < 2 {
- return;
- }
- let mut j = 0;
- for i in 1..n {
- let mut bit = n >> 1;
- while j & bit != 0 {
- j ^= bit;
- bit >>= 1;
- }
- j |= bit;
- if i < j {
- re.swap(i, j);
- im.swap(i, j);
- }
- }
- let mut len = 2;
- while len <= n {
- let ang = -2.0 * PI / len as f64;
- let (ws, wc) = ang.sin_cos();
- for start in (0..n).step_by(len) {
- let (mut cr, mut ci) = (1.0, 0.0);
- for k in 0..len / 2 {
- let (a, bb) = (start + k, start + k + len / 2);
- let tr = re[bb] * cr - im[bb] * ci;
- let ti = re[bb] * ci + im[bb] * cr;
- re[bb] = re[a] - tr;
- im[bb] = im[a] - ti;
- re[a] += tr;
- im[a] += ti;
- let ncr = cr * wc - ci * ws;
- ci = cr * ws + ci * wc;
- cr = ncr;
- }
- }
- len <<= 1;
- }
-}
-
-const AUDIO_RATE: u32 = 48_000;
-
-/// Fetch mono (or one channel) samples of the audio layer around the current time.
-fn audio_window(ctx: &EffectCtx, dur_ms: f64, offset_ms: f64, channel: u32) -> Option> {
- let id = ctx.params.get("audioLayer")?.as_layer()?;
- let host = ctx.env.host?;
- let dur = (dur_ms / 1000.0).max(0.001);
- let frames = ((dur * AUDIO_RATE as f64) as usize).clamp(16, 1 << 16);
- let start = ctx.env.comp_time + offset_ms / 1000.0 - dur * 0.5;
- let s = host.audio(id, start, frames, AUDIO_RATE)?;
- Some(
- (0..frames)
- .map(|i| {
- let (l, r) = (*s.get(2 * i).unwrap_or(&0.0) as f64, *s.get(2 * i + 1).unwrap_or(&0.0) as f64);
- match channel {
- 1 => l,
- 2 => r,
- _ => (l + r) * 0.5,
- }
- })
- .collect(),
- )
-}
-
-/// The drawing baseline: a polyline in buffer px (mask path or start→end line), sampled at
-/// parameter u∈[0,1] → (point, unit normal).
-struct Baseline {
- pts: Vec<[f64; 2]>,
- closed: bool,
- len: f64,
- polar: bool,
- center: [f64; 2],
- radius: f64,
-}
-
-impl Baseline {
- fn new(ctx: &EffectCtx, b: &Buf) -> Baseline {
- let pr = ctx.params;
- let polar = pr.b("usePolarPath");
- let (pts, closed) = match mask_px(ctx, b, pr.f("path").round() as usize) {
- Some((p, c, _)) if !polar => (p, c),
- _ => {
- let s = b.to_px(pr.v2("startPoint"));
- let e = b.to_px(pr.v2("endPoint"));
- (vec![[s.0, s.1], [e.0, e.1]], false)
- }
- };
- let len = poly_length(&pts, closed);
- let center = pts[0];
- let radius = if pts.len() > 1 { ((pts[1][0] - pts[0][0]).powi(2) + (pts[1][1] - pts[0][1]).powi(2)).sqrt() } else { 1.0 };
- Baseline { pts, closed, len, polar, center, radius }
- }
- fn at(&self, u: f64) -> ([f64; 2], [f64; 2]) {
- if self.polar {
- let a = u * 2.0 * PI - PI * 0.5;
- let (s, c) = a.sin_cos();
- return ([self.center[0] + c * self.radius * 0.5, self.center[1] + s * self.radius * 0.5], [c, s]);
- }
- let (q, d) = crate::util::poly_point_at(&self.pts, self.closed, u * self.len);
- (q, [d[1], -d[0]])
- }
-}
-
-/// Draw line/dot marks with core (inside colour) and soft halo (outside colour).
-fn draw_marks(b: &mut Buf, segs_core: &[Seg], thickness: f64, softness: f64, inside: [f32; 4], outside: [f32; 4], composite: bool) {
- let (w, h) = (b.img.width as usize, b.img.height as usize);
- let core = raster_segs(w, h, segs_core, 1.0);
- let halo_segs: Vec = segs_core.iter().map(|s| Seg { r: s.r + thickness * softness.max(0.0) + 0.5, ..*s }).collect();
- let halo = if softness > 0.0 { raster_segs(w, h, &halo_segs, 0.0) } else { core.clone() };
- b.img.data.par_iter_mut().enumerate().for_each(|(i, px)| {
- let (c, hl) = (core.data[i], halo.data[i]);
- let a = c.max(hl);
- let base = if composite { *px } else { [0.0; 4] };
- if a <= 0.0 {
- *px = base;
- return;
- }
- let t = if a > 0.0 { c / a } else { 0.0 };
- let col = crate::util::lerp3([outside[0], outside[1], outside[2]], [inside[0], inside[1], inside[2]], t);
- *px = over(base, premul(col, a));
- });
-}
-
-/// Audio Spectrum / Audio Waveform, shared with the GPU compositor (effectcraft-gpu `fx_gen2`):
-/// the marks (the audio analysis runs on the CPU) and how [`draw_marks`] colours them.
-#[derive(Clone, Debug)]
-pub struct MarksPlan {
- pub segs: Vec,
- pub thickness: f64,
- pub softness: f64,
- pub inside: [f32; 4],
- pub outside: [f32; 4],
- pub composite: bool,
-}
-
-/// [`MarksPlan`] of Audio Spectrum or Audio Waveform on `b`'s geometry (`None` = no audio:
-/// the layer passes through).
-pub fn marks_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option {
- match id {
- "ec.generate.audiospectrum" => spectrum_plan(ctx, b),
- "ec.generate.audiowaveform" => waveform_plan(ctx, b),
- _ => None,
- }
-}
-
-fn marks(ctx: &EffectCtx, segs: Vec, thick: f64, soft: f64) -> MarksPlan {
- let pr = ctx.params;
- MarksPlan {
- segs,
- thickness: thick,
- softness: soft * 2.0,
- inside: pr.color("insideColor"),
- outside: pr.color("outsideColor"),
- composite: pr.b("compositeOnOriginal"),
- }
-}
-
-fn audio_spectrum(ctx: &EffectCtx, mut b: Buf) -> Buf {
- if let Some(m) = spectrum_plan(ctx, &b) {
- draw_marks(&mut b, &m.segs, m.thickness, m.softness, m.inside, m.outside, m.composite);
- }
- b
-}
-
-fn audio_waveform(ctx: &EffectCtx, mut b: Buf) -> Buf {
- if let Some(m) = waveform_plan(ctx, &b) {
- draw_marks(&mut b, &m.segs, m.thickness, m.softness, m.inside, m.outside, m.composite);
- }
- b
-}
-
-fn compute_fft_mags(samples: &[f64]) -> (usize, f64, Vec) {
- let m = samples.len();
- let n = m.next_power_of_two().max(64);
- let mut re = vec![0.0; n];
- let mut im = vec![0.0; n];
- let denom = (m.max(2) - 1) as f64;
- for (i, s) in samples.iter().enumerate() {
- let w = 0.5 - 0.5 * (2.0 * PI * i as f64 / denom).cos();
- if let Some(r) = re.get_mut(i) {
- *r = s * w;
- }
- }
- fft(&mut re, &mut im);
- let hz_per_bin = AUDIO_RATE as f64 / n as f64;
- let scale = 4.0 / m.max(1) as f64;
- let num_bins = n / 2 + 1;
- let mut mags = Vec::with_capacity(num_bins);
- for k in 0..num_bins {
- let r = re.get(k).copied().unwrap_or(0.0);
- let im_val = im.get(k).copied().unwrap_or(0.0);
- let mag = (r * r + im_val * im_val).sqrt() * scale;
- mags.push(mag);
- }
- (n, hz_per_bin, mags)
-}
-
-fn spectrum_plan(ctx: &EffectCtx, b: &Buf) -> Option {
- let pr = ctx.params;
- let samples = audio_window(ctx, pr.f("audioDuration"), pr.f("audioOffset"), 0)?;
- let (_n, hz_per_bin, mags) = compute_fft_mags(&samples);
-
- let bands = pr.f("frequencyBands").round().clamp(1.0, 4096.0) as usize;
- let f0 = pr.f("startFrequency").max(0.0);
- let f1 = pr.f("endFrequency").max(f0 + 1.0);
- let max_bin = mags.len().saturating_sub(1);
-
- let get_band_mag = |fc: f64| -> f64 {
- if mags.is_empty() || hz_per_bin <= 0.0 {
- return 0.0;
- }
- let k_float = (fc / hz_per_bin).clamp(0.0, max_bin as f64);
- let k0 = (k_float.floor() as usize).min(max_bin.saturating_sub(1));
- let k1 = (k0 + 1).min(max_bin);
- let frac = (k_float - k0 as f64).clamp(0.0, 1.0);
- let m0 = mags.get(k0).copied().unwrap_or(0.0);
- let m1 = mags.get(k1).copied().unwrap_or(0.0);
- m0 * (1.0 - frac) + m1 * frac
- };
-
- let max_h = pr.f("maximumHeight") * b.scale;
- let thick = (pr.f("thickness") * b.scale).max(0.1);
- let soft = pr.f("softness") / 100.0;
- let disp = pr.e("displayOptions");
- let side = pr.e("sideOptions");
- let base = Baseline::new(ctx, b);
- let mut tops = Vec::with_capacity(bands);
- let mut segs = Vec::new();
- for i in 0..bands {
- let u = if bands > 1 { i as f64 / (bands - 1) as f64 } else { 0.5 };
- let fc = f0 + (f1 - f0) * u;
- let v = get_band_mag(fc);
- let hgt = if (v * max_h).is_finite() { (v * max_h).clamp(0.0, max_h.max(0.0)) } else { 0.0 };
- let (q, nrm) = base.at(u);
- let (ua, ub) = match side {
- 0 => (0.0, hgt),
- 1 => (-hgt, 0.0),
- _ => (-hgt, hgt),
- };
- let pa = [q[0] + nrm[0] * ua, q[1] + nrm[1] * ua];
- let pb = [q[0] + nrm[0] * ub, q[1] + nrm[1] * ub];
- match disp {
- 0 => segs.push(Seg { a: pa, b: pb, r: thick * 0.5, v: 1.0 }),
- _ => tops.push((pa, pb)),
- }
- }
- if disp == 1 {
- for w2 in tops.windows(2) {
- segs.push(Seg { a: w2[0].1, b: w2[1].1, r: thick * 0.5, v: 1.0 });
- if side == 2 {
- segs.push(Seg { a: w2[0].0, b: w2[1].0, r: thick * 0.5, v: 1.0 });
- }
- }
- } else if disp == 2 {
- for &(pa, pb) in &tops {
- segs.push(Seg { a: pb, b: pb, r: thick * 0.5, v: 1.0 });
- if side == 2 {
- segs.push(Seg { a: pa, b: pa, r: thick * 0.5, v: 1.0 });
- }
- }
- }
- Some(marks(ctx, segs, thick, soft))
-}
-
-fn waveform_plan(ctx: &EffectCtx, b: &Buf) -> Option {
- let pr = ctx.params;
- let samples = audio_window(ctx, pr.f("audioDuration"), pr.f("audioOffset"), pr.e("waveformOptions"))?;
- let count = pr.f("displayedSamples").round().clamp(2.0, 4096.0) as usize;
- let max_h = pr.f("maximumHeight") * b.scale;
- let thick = (pr.f("thickness") * b.scale).max(0.1);
- let soft = pr.f("softness") / 100.0;
- let disp = pr.e("displayOptions");
- let base = Baseline::new(ctx, b);
- let m = samples.len();
- let mut pts = Vec::with_capacity(count);
- let mut segs = Vec::new();
- for i in 0..count {
- let u = i as f64 / (count - 1) as f64;
- let a = ((u * (m - 1) as f64) as usize).min(m - 1);
- let bnd = (((i + 1) as f64 / count as f64 * (m - 1) as f64) as usize).clamp(a, m - 1);
- // Peak with sign of the window for a stable digital display.
- let (mut lo, mut hi) = (0.0f64, 0.0f64);
- for s in &samples[a..=bnd] {
- lo = lo.min(*s);
- hi = hi.max(*s);
- }
- let (q, nrm) = base.at(u);
- match disp {
- 0 => segs.push(Seg {
- a: [q[0] + nrm[0] * lo * max_h, q[1] + nrm[1] * lo * max_h],
- b: [q[0] + nrm[0] * hi * max_h, q[1] + nrm[1] * hi * max_h],
- r: thick * 0.5,
- v: 1.0,
- }),
- _ => {
- let v = samples[a] * max_h;
- pts.push([q[0] + nrm[0] * v, q[1] + nrm[1] * v]);
- }
- }
- }
- if disp == 1 {
- poly_segs(&pts, false, thick * 0.5, 1.0, &mut segs);
- } else if disp == 2 {
- segs.extend(pts.iter().map(|&q| Seg { a: q, b: q, r: thick * 0.5, v: 1.0 }));
- }
- Some(marks(ctx, segs, thick, soft))
-}
-
-// ---------------------------------------------------------------- registry
-
-pub fn specs() -> Vec {
- let ang = || ParamUi::Angle;
- let check = |id: &'static str, name: &'static str, v: bool| p(id, name, Value::Bool(v), ParamUi::Checkbox);
- let paint_style = || popup(&["On Original Image", "On Transparent", "Reveal Original Image"]);
- let mask_idx = |id: &'static str, name: &'static str, d: f64| p(id, name, num(d), ParamUi::Mask);
- let display = || popup(&["Digital", "Analog lines", "Analog dots"]);
- vec![
- spec(
- "ec.generate.fractal",
- "Fractal",
- vec![
- p("setChoice", "Set Choice", Value::Enum(0), popup(&FRACTAL_SETS)),
- p("equation", "Equation", Value::Enum(0), popup(&["z = z^2 + c", "z = z^3 + c", "z = z^4 + c"])),
- p("mandelbrot/mandelbrotX", "X (Real)", num(-0.74), slider(-2.0, 2.0, -2.0, 2.0, 4)),
- p("mandelbrot/mandelbrotY", "Y (Imaginary)", num(0.15), slider(-2.0, 2.0, -2.0, 2.0, 4)),
- p("mandelbrot/mandelbrotMagnification", "Magnification", num(0.0), slider(-5.0, 30.0, -5.0, 30.0, 2)),
- p("mandelbrot/mandelbrotEscapeLimit", "Escape Limit", num(4.0), slider(1.0, 1000.0, 1.0, 100.0, 1)),
- p("julia/juliaX", "X (Real)", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
- p("julia/juliaY", "Y (Imaginary)", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
- p("julia/juliaMagnification", "Magnification", num(0.0), slider(-5.0, 30.0, -5.0, 30.0, 2)),
- p("julia/juliaEscapeLimit", "Escape Limit", num(4.0), slider(1.0, 1000.0, 1.0, 100.0, 1)),
- p("postInversionOffset/postInversionX", "X Offset", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
- p("postInversionOffset/postInversionY", "Y Offset", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
- check("fractalColor/overlay", "Overlay", false),
- check("fractalColor/transparency", "Transparency", false),
- p("fractalColor/palette", "Palette", Value::Enum(0), popup(&FRACTAL_PALETTES)),
- p("fractalColor/hue", "Hue", num(0.0), ang()),
- p("fractalColor/cycleSteps", "Cycle Steps", num(32.0), slider(1.0, 1000.0, 1.0, 256.0, 0)),
- p("fractalColor/cycleOffset", "Cycle Offset", num(0.0), ang()),
- check("fractalColor/edgeHighlight", "Edge Highlight", false),
- p("highQualitySettings/samplingMethod", "Oversample Method", Value::Enum(0), popup(&FRACTAL_OVERSAMPLE)),
- p("highQualitySettings/samplingFactor", "Oversample Factor", num(2.0), slider(1.0, 9.0, 1.0, 9.0, 0)),
- ],
- fractal,
- ),
- spec(
- "ec.generate.scribble",
- "Scribble",
- vec![
- p("scribble", "Scribble", Value::Enum(0), popup(&["Single Mask", "All Masks", "All Masks Using Modes"])),
- mask_idx("mask", "Mask", 1.0),
- p("fillType", "Fill Type", Value::Enum(0), popup(&["Inside", "Centered Edge", "Inside Edge", "Outside Edge", "Left Edge", "Right Edge"])),
- p("edgeOptions/edgeWidth", "Edge Width", num(10.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
- p("edgeOptions/endCap", "End Cap", Value::Enum(0), popup(&END_CAPS)),
- p("edgeOptions/join", "Join", Value::Enum(0), popup(&JOINS)),
- p("edgeOptions/miterLimit", "Miter Limit", num(4.0), slider(1.0, 100.0, 1.0, 20.0, 1)),
- p("color", "Color", col(1.0, 0.0, 0.0), ParamUi::Color),
- p("opacity", "Opacity", num(100.0), pct()),
- p("angle", "Angle", num(45.0), ang()),
- p("strokeWidth", "Stroke Width", num(2.0), slider(0.1, 50.0, 0.1, 50.0, 1)),
- p("strokeOptions/curviness", "Curviness", num(50.0), pct()),
- p("strokeOptions/curvinessVariation", "Curviness Variation", num(50.0), pct()),
- p("strokeOptions/spacing", "Spacing", num(5.0), slider(0.1, 100.0, 0.1, 50.0, 1)),
- p("strokeOptions/spacingVariation", "Spacing Variation", num(50.0), pct()),
- p("strokeOptions/pathOverlap", "Path Overlap", num(0.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
- p("strokeOptions/pathOverlapVariation", "Path Overlap Variation", num(50.0), pct()),
- p("start", "Start", num(0.0), pct()),
- p("end", "End", num(100.0), pct()),
- p("startEndApplyTo", "Start/End Apply To", Value::Enum(0), popup(&["All Strokes", "Each Stroke"])),
- check("fillPathsSequentially", "Fill Paths Sequentially", true),
- p("wiggleType", "Wiggle Type", Value::Enum(1), popup(&["Static", "Jumpy", "Smooth"])),
- p("wigglesPerSecond", "Wiggles/Second", num(5.0), slider(0.0, 100.0, 0.0, 30.0, 2)),
- p("randomSeed", "Random Seed", num(1.0), slider(0.0, 10000.0, 0.0, 100.0, 0)),
- p("composite", "Composite", Value::Enum(1), popup(&["On Original Image", "On Transparent", "Reveal Original Image"])),
- ],
- scribble,
- ),
- spec(
- "ec.generate.stroke",
- "Stroke",
- vec![
- mask_idx("path", "Path", 1.0),
- check("allMasks", "All Masks", false),
- check("strokeSequentially", "Stroke Sequentially", true),
- p("color", "Color", col(1.0, 1.0, 1.0), ParamUi::Color),
- p("brushSize", "Brush Size", num(2.0), slider(0.0, 50.0, 0.0, 50.0, 1)),
- p("brushHardness", "Brush Hardness", num(75.0), pct()),
- p("opacity", "Opacity", num(100.0), pct()),
- p("start", "Start", num(0.0), pct()),
- p("end", "End", num(100.0), pct()),
- p("spacing", "Spacing", num(15.0), slider(0.0, 100.0, 0.0, 100.0, 1)),
- p("paintStyle", "Paint Style", Value::Enum(0), paint_style()),
- ],
- stroke,
- ),
- spec(
- "ec.generate.vegas",
- "Vegas",
- vec![
- p("stroke", "Stroke", Value::Enum(0), popup(&["Image Contours", "Mask/Path"])),
- p("inputLayer", "Image Contours: Input Layer", Value::Layer(None), ParamUi::Layer),
- check("invertInput", "Image Contours: Invert Input", false),
- p("ifLayerSizesDiffer", "Image Contours: If Layer Sizes Differ", Value::Enum(0), popup(&["Center", "Stretch to Fit"])),
- p("channel", "Image Contours: Channel", Value::Enum(0), popup(&["Intensity", "Red", "Green", "Blue", "Alpha"])),
- p("threshold", "Image Contours: Threshold", num(50.0), pct()),
- p("preBlur", "Image Contours: Pre-Blur", num(1.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
- p("tolerance", "Image Contours: Tolerance", num(0.01), slider(0.0, 1.0, 0.0, 0.1, 3)),
- p("renderMode", "Image Contours: Render", Value::Enum(0), popup(&["All Contours", "Selected Contour"])),
- p("selectedContour", "Image Contours: Selected Contour", num(1.0), slider(1.0, 1000.0, 1.0, 20.0, 0)),
- p("shorterContoursHave", "Image Contours: Shorter Contours Have", Value::Enum(0), popup(&["Same Number of Segments", "Fewer Segments"])),
- mask_idx("path", "Mask/Path: Path", 1.0),
- p("segments", "Segments: Segments", num(32.0), slider(1.0, 1000.0, 1.0, 100.0, 0)),
- p("length", "Segments: Length", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
- p("segmentDistribution", "Segments: Segment Distribution", Value::Enum(0), popup(&["Bunched", "Even"])),
- p("rotation", "Segments: Rotation", num(0.0), ang()),
- check("randomPhase", "Segments: Random Phase", false),
- p("randomSeed", "Segments: Random Seed", num(1.0), slider(1.0, 10000.0, 1.0, 100.0, 0)),
- p("blendMode", "Rendering: Blend Mode", Value::Enum(1), popup(&["Transparent", "Over", "Under", "Stencil"])),
- p("color", "Rendering: Color", col(1.0, 1.0, 1.0), ParamUi::Color),
- p("width", "Rendering: Width", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 2)),
- p("hardness", "Rendering: Hardness", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
- p("startOpacity", "Rendering: Start Opacity", num(1.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
- p("midpointOpacity", "Rendering: Mid-point Opacity", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
- p("midpointPosition", "Rendering: Mid-point Position", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
- p("endOpacity", "Rendering: End Opacity", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
- ],
- vegas,
- ),
- spec(
- "ec.generate.writeon",
- "Write-on",
- vec![
- p("brushPosition", "Brush Position", pt(0.5, 0.5), ParamUi::Point),
- p("color", "Color", col(1.0, 1.0, 1.0), ParamUi::Color),
- p("brushSize", "Brush Size", num(6.0), slider(0.0, 50.0, 0.0, 50.0, 1)),
- p("brushHardness", "Brush Hardness", num(75.0), pct()),
- p("brushOpacity", "Brush Opacity", num(100.0), pct()),
- p("strokeLength", "Stroke Length (secs)", num(0.0), slider(0.0, 30.0, 0.0, 30.0, 1)),
- p("brushSpacing", "Brush Spacing (secs)", num(0.001), slider(0.001, 5.0, 0.001, 5.0, 3)),
- p("paintTimeProperties", "Paint Time Properties", Value::Enum(0), popup(&["None", "Opacity", "Color"])),
- p("brushTimeProperties", "Brush Time Properties", Value::Enum(0), popup(&["None", "Size", "Hardness", "Size & Hardness"])),
- p("paintStyle", "Paint Style", Value::Enum(0), paint_style()),
- ],
- write_on,
- ),
- spec(
- "ec.generate.paintbucket",
- "Paint Bucket",
- vec![
- p("fillPoint", "Fill Point", pt(0.5, 0.5), ParamUi::Point),
- p("fillSelector", "Fill Selector", Value::Enum(0), popup(&["Color & Alpha", "Straight Color", "Transparency", "Opacity", "Alpha Channel"])),
- p("tolerance", "Tolerance", num(10.0), slider(0.0, 255.0, 0.0, 100.0, 1)),
- check("viewThreshold", "View Threshold", false),
- p("stroke", "Stroke", Value::Enum(0), popup(&["Antialias", "Feather", "Spread", "Choke", "Stroke"])),
- p("featherSoftness", "Feather Softness", num(10.0), slider(0.0, 100.0, 0.0, 50.0, 1)),
- p("spreadRadius", "Spread Radius", num(3.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
- p("strokeWidth", "Stroke Width", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
- p("color", "Color", col(1.0, 0.0, 0.0), ParamUi::Color),
- p("opacity", "Opacity", num(100.0), pct()),
- p(
- "blendingMode",
- "Blending Mode",
- Value::Enum(0),
- popup(&["Normal", "Add", "Multiply", "Screen", "Hue", "Saturation", "Color", "Luminosity", "Behind", "Fill Only"]),
- ),
- ],
- paint_bucket,
- ),
- spec(
- "ec.generate.eyedropperfill",
- "Eyedropper Fill",
- vec![
- p("samplePoint", "Sample Point", pt(0.5, 0.5), ParamUi::Point),
- p("sampleRadius", "Sample Radius", num(0.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
- p("averagePixelColors", "Average Pixel Colors", Value::Enum(0), popup(&["Skip Empty", "All", "All Premultiplied", "Including Alpha"])),
- check("maintainOriginalAlpha", "Maintain Original Alpha", false),
- p("blendWithOriginal", "Blend With Original", num(0.0), pct()),
- ],
- eyedropper_fill,
- ),
- spec(
- "ec.generate.ccgluegun",
- "CC Glue Gun",
- vec![
- p("brushPosition", "Brush Position", pt(0.5, 0.5), ParamUi::Point),
- p("strokeWidth", "Stroke Width", num(25.0), slider(0.0, 500.0, 0.0, 100.0, 1)),
- p("density", "Density", num(5.0), slider(0.0, 32.0, 0.0, 32.0, 1)),
- p("timeSpan", "Time Span (sec)", num(1.0), slider(0.0, 60.0, 0.0, 10.0, 2)),
- p("reflection", "Reflection", num(45.0), ang()),
- p("strength", "Strength", num(100.0), pct()),
- p("style", "Style", Value::Enum(0), popup(&["Over Layer", "Glue Only"])),
- ],
- glue_gun,
- ),
- spec(
- "ec.generate.ccthreads",
- "CC Threads",
- vec![
- p("width", "Width", num(50.0), slider(1.0, 1000.0, 1.0, 200.0, 1)),
- p("height", "Height", num(50.0), slider(1.0, 1000.0, 1.0, 200.0, 1)),
- p("overlaps", "Overlaps", num(1.0), slider(1.0, 20.0, 1.0, 10.0, 0)),
- p("direction", "Direction", num(0.0), ang()),
- p("center", "Center", pt(0.5, 0.5), ParamUi::Point),
- p("coverage", "Coverage", num(80.0), pct()),
- p("shadowing", "Shadowing", num(50.0), pct()),
- p("texture", "Texture", num(10.0), pct()),
- ],
- threads,
- ),
- spec(
- "ec.generate.audiospectrum",
- "Audio Spectrum",
- vec![
- p("audioLayer", "Audio Layer", Value::Layer(None), ParamUi::Layer),
- p("startPoint", "Start Point", pt(0.1, 0.5), ParamUi::Point),
- p("endPoint", "End Point", pt(0.9, 0.5), ParamUi::Point),
- mask_idx("path", "Path", 0.0),
- check("usePolarPath", "Use Polar Path", false),
- p("startFrequency", "Start Frequency", num(20.0), slider(1.0, 20000.0, 1.0, 2000.0, 0)),
- p("endFrequency", "End Frequency", num(2000.0), slider(1.0, 20000.0, 1.0, 10000.0, 0)),
- p("frequencyBands", "Frequency bands", num(64.0), slider(1.0, 4096.0, 1.0, 256.0, 0)),
- p("maximumHeight", "Maximum Height", num(50.0), slider(0.0, 10000.0, 0.0, 500.0, 1)),
- p("audioDuration", "Audio Duration (milliseconds)", num(90.0), slider(1.0, 30000.0, 1.0, 1000.0, 1)),
- p("audioOffset", "Audio Offset (milliseconds)", num(0.0), slider(-30000.0, 30000.0, -1000.0, 1000.0, 1)),
- p("thickness", "Thickness", num(3.0), slider(0.0, 1000.0, 0.0, 50.0, 2)),
- p("softness", "Softness", num(50.0), pct()),
- p("insideColor", "Inside Color", col(1.0, 1.0, 1.0), ParamUi::Color),
- p("outsideColor", "Outside Color", col(0.2, 0.4, 1.0), ParamUi::Color),
- check("blendOverlappingColors", "Blend Overlapping Colors", true),
- p("hueInterpolation", "Hue Interpolation", num(0.0), ang()),
- check("dynamicHuePhase", "Dynamic Hue Phase", false),
- check("colorSymmetry", "Color Symmetry", false),
- p("displayOptions", "Display Options", Value::Enum(0), display()),
- p("sideOptions", "Side Options", Value::Enum(0), popup(&["Side A", "Side B", "Side A & B"])),
- check("durationAveraging", "Duration Averaging", false),
- check("compositeOnOriginal", "Composite On Original", false),
- ],
- audio_spectrum,
- ),
- spec(
- "ec.generate.audiowaveform",
- "Audio Waveform",
- vec![
- p("audioLayer", "Audio Layer", Value::Layer(None), ParamUi::Layer),
- p("startPoint", "Start Point", pt(0.1, 0.5), ParamUi::Point),
- p("endPoint", "End Point", pt(0.9, 0.5), ParamUi::Point),
- mask_idx("path", "Path", 0.0),
- check("usePolarPath", "Use Polar Path", false),
- p("displayedSamples", "Displayed Samples", num(200.0), slider(2.0, 4096.0, 2.0, 1000.0, 0)),
- p("maximumHeight", "Maximum Height", num(100.0), slider(0.0, 10000.0, 0.0, 500.0, 1)),
- p("audioDuration", "Audio Duration (milliseconds)", num(200.0), slider(1.0, 30000.0, 1.0, 1000.0, 1)),
- p("audioOffset", "Audio Offset (milliseconds)", num(0.0), slider(-30000.0, 30000.0, -1000.0, 1000.0, 1)),
- p("thickness", "Thickness", num(2.0), slider(0.0, 1000.0, 0.0, 50.0, 2)),
- p("softness", "Softness", num(10.0), pct()),
- p("randomSeed", "Random Seed (Analog)", num(1.0), slider(1.0, 10000.0, 1.0, 100.0, 0)),
- p("insideColor", "Inside Color", col(1.0, 1.0, 1.0), ParamUi::Color),
- p("outsideColor", "Outside Color", col(0.2, 0.4, 1.0), ParamUi::Color),
- p("waveformOptions", "Waveform Options", Value::Enum(0), popup(&["Mono", "Left", "Right"])),
- p("displayOptions", "Display Options", Value::Enum(1), display()),
- check("compositeOnOriginal", "Composite On Original", false),
- ],
- audio_waveform,
- ),
- ]
-}
+mod audio;
+mod common;
+mod fill;
+mod fractal;
+mod paths;
+mod raster;
+mod registry;
#[cfg(test)]
-mod tests {
- use super::*;
- use crate::{EffectEnv, EffectHost, LayerPixels, MaskShape, Params};
+pub(crate) use audio::fft;
+pub use audio::{MarksPlan, marks_plan};
+pub use fill::{eyedropper_color, paint_bucket_region};
+#[cfg(test)]
+use paths::contours;
+pub use paths::{Coverage, PaintPlan, paint_plan, plan_reads_pixels, scribble_style};
+pub use raster::{Seg, poly_segs};
+pub(crate) use raster::{mask_px, raster_segs};
+#[cfg(test)]
+pub(crate) use raster::{raster_convex, stroke_outline};
+pub use registry::specs;
- /// Run with point defaults scaled to the layer size.
- pub(crate) fn run_env(id: &str, set: &[(&str, Value)], img: Image, time: f64, env: EffectEnv) -> Buf {
- let s = crate::find(id).unwrap();
- let ls = [img.width as f64, img.height as f64];
- let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
- for p in &s.params {
- if let (ParamUi::Point, Value::Vec2(v)) = (&p.ui, &p.default) {
- params.values.insert(p.id.to_string(), Value::Vec2([v[0] * ls[0], v[1] * ls[1]]));
- }
- }
- for (k, v) in set {
- assert!(params.values.contains_key(*k), "{id}: unknown {k}");
- params.values.insert(k.to_string(), v.clone());
- }
- let ctx = EffectCtx { params: ¶ms, time, layer_size: ls, seed: 3, adjustment: false, env };
- crate::apply(s, &ctx, Buf { img, offset: [0.0, 0.0], scale: 1.0 })
- }
-
- fn run(id: &str, set: &[(&str, Value)], img: Image) -> Buf {
- run_env(id, set, img, 0.5, EffectEnv::default())
- }
-
- fn square_mask() -> Vec {
- vec![MaskShape { name: "Mask 1".into(), points: vec![[16.0, 16.0], [48.0, 16.0], [48.0, 48.0], [16.0, 48.0]], closed: true, inverted: false }]
- }
-
- fn alpha_sum(img: &Image, x0: usize, y0: usize, x1: usize, y1: usize) -> f32 {
- let mut s = 0.0;
- for y in y0..y1 {
- for x in x0..x1 {
- s += img.data[y * img.width as usize + x][3];
- }
- }
- s
- }
-
- #[test]
- fn audio_spectrum_linear_frequency_and_linear_amplitude() {
- let host = Tone; // Tone produces 440 Hz
- let env = EffectEnv { host: Some(&host), comp_time: 1.0, ..Default::default() };
- let img = Image::new(200, 100);
- let out = run_env(
- "ec.generate.audiospectrum",
- &[
- ("audioLayer", Value::Layer(Some(1))),
- ("startPoint", Value::Vec2([0.0, 50.0])),
- ("endPoint", Value::Vec2([200.0, 50.0])),
- ("startFrequency", num(20.0)),
- ("endFrequency", num(2000.0)),
- ("frequencyBands", num(100.0)),
- ("maximumHeight", num(40.0)),
- ("thickness", num(2.0)),
- ("softness", num(0.0)),
- ],
- img,
- 1.0,
- env,
- );
- // Verify 440 Hz tone produces a peak above baseline, while high frequencies have zero bar height
- let peak_zone = alpha_sum(&out.img, 36, 10, 48, 48);
- let high_zone = alpha_sum(&out.img, 120, 10, 150, 48);
- let silent_zone = alpha_sum(&out.img, 170, 10, 195, 48);
- assert!(peak_zone > 5.0, "peak zone has energy: {peak_zone}");
- assert!(peak_zone > high_zone * 2.0, "linear peak is distinctly taller than far frequencies: {peak_zone} vs {high_zone}");
- assert_eq!(silent_zone, 0.0, "silent end has zero height, not boosted by dB scale");
- }
-
- #[test]
- fn fractal_deterministic_and_has_inside_set() {
- let img = Image::new(64, 48);
- let a = run("ec.generate.fractal", &[], img.clone());
- let b = run("ec.generate.fractal", &[], img.clone());
- assert_eq!(a.img.data, b.img.data);
- // The default view contains the main cardioid (black, opaque) and escaped (coloured) points.
- assert!(a.img.data.iter().any(|p| p[3] > 0.99 && p[0] + p[1] + p[2] < 0.01));
- assert!(a.img.data.iter().any(|p| p[0] + p[1] + p[2] > 0.3));
- let t = run("ec.generate.fractal", &[("fractalColor/transparency", Value::Bool(true))], img);
- assert!(t.img.data.iter().any(|p| p[3] == 0.0));
- }
-
- #[test]
- fn fractal_palettes_and_set_choices() {
- let img = Image::new(64, 48);
- // Solid Color: only the inside of the set is drawn; Transparency flips it.
- let solid = run("ec.generate.fractal", &[("fractalColor/palette", Value::Enum(3))], img.clone());
- assert!(solid.img.data.iter().any(|p| p[3] == 0.0) && solid.img.data.iter().any(|p| p[3] > 0.99 && p[0] > 0.9));
- let flipped = run("ec.generate.fractal", &[("fractalColor/palette", Value::Enum(3)), ("fractalColor/transparency", Value::Bool(true))], img.clone());
- for (a, b) in solid.img.data.iter().zip(&flipped.img.data) {
- assert!((a[3] > 0.5) != (b[3] > 0.5) || (a[3] - 0.5).abs() < 0.49);
- }
- // Black And White: escaped pixels are pure black or white (away from supersampled edges).
- let bw = run("ec.generate.fractal", &[("fractalColor/palette", Value::Enum(2)), ("highQualitySettings/samplingFactor", num(1.0))], img.clone());
- assert!(bw.img.data.iter().all(|p| p[0] == p[1] && p[1] == p[2] && (p[0] == 0.0 || p[0] == 1.0)));
- // Mandelbrot Over Julia depends on the Julia centre.
- let o1 = run("ec.generate.fractal", &[("setChoice", Value::Enum(2)), ("julia/juliaX", num(0.3))], img.clone());
- let o2 = run("ec.generate.fractal", &[("setChoice", Value::Enum(2)), ("julia/juliaX", num(-0.2))], img.clone());
- assert_ne!(o1.img.data, o2.img.data);
- let plain = run("ec.generate.fractal", &[("julia/juliaX", num(0.3))], img);
- assert_ne!(o1.img.data, plain.img.data);
- }
-
- #[test]
- fn scribble_fills_mask_and_animates() {
- let masks = square_mask();
- let env = EffectEnv { masks: &masks, ..Default::default() };
- let img = Image::filled(64, 64, [0.0, 0.0, 1.0, 1.0]);
- let a = run_env("ec.generate.scribble", &[], img.clone(), 0.5, env);
- let b = run_env("ec.generate.scribble", &[], img.clone(), 0.5, env);
- assert_eq!(a.img.data, b.img.data);
- let inside = alpha_sum(&a.img, 18, 18, 46, 46);
- let outside = alpha_sum(&a.img, 0, 0, 10, 64);
- assert!(inside > 100.0 && outside < 1.0, "{inside} {outside}");
- let c = run_env("ec.generate.scribble", &[], img.clone(), 1.5, env);
- assert_ne!(a.img.data, c.img.data, "jumpy wiggle changes over time");
- let s = run_env("ec.generate.scribble", &[("wiggleType", Value::Enum(0))], img.clone(), 0.5, env);
- let s2 = run_env("ec.generate.scribble", &[("wiggleType", Value::Enum(0))], img.clone(), 3.5, env);
- assert_eq!(s.img.data, s2.img.data, "static wiggle is constant");
- let half = run_env("ec.generate.scribble", &[("end", num(50.0))], img, 0.5, env);
- assert!(alpha_sum(&half.img, 0, 0, 64, 64) < alpha_sum(&a.img, 0, 0, 64, 64));
- }
-
- #[test]
- fn scribble_edge_types() {
- let masks = square_mask();
- let env = EffectEnv { masks: &masks, ..Default::default() };
- let img = Image::new(64, 64);
- let o = run_env("ec.generate.scribble", &[("fillType", Value::Enum(3)), ("edgeOptions/edgeWidth", num(6.0))], img, 0.5, env);
- // Outside edge: paint near the border outside, nothing in the centre.
- assert!(alpha_sum(&o.img, 26, 26, 38, 38) < 0.5);
- assert!(alpha_sum(&o.img, 8, 8, 16, 56) > 5.0);
- }
-
- #[test]
- fn stroke_draws_along_mask() {
- let masks = square_mask();
- let env = EffectEnv { masks: &masks, ..Default::default() };
- let img = Image::new(64, 64);
- let a = run_env("ec.generate.stroke", &[("brushSize", num(4.0)), ("paintStyle", Value::Enum(1))], img.clone(), 0.0, env);
- assert!(a.img.get(32, 16)[3] > 0.9, "on the top edge");
- assert!(a.img.get(32, 32)[3] < 0.01, "centre empty");
- let b = run_env("ec.generate.stroke", &[("brushSize", num(4.0)), ("end", num(25.0))], img.clone(), 0.0, env);
- assert!(b.img.get(32, 16)[3] > 0.9 && b.img.get(48, 32)[3] < 0.01, "first quarter only");
- let d = run_env("ec.generate.stroke", &[("brushSize", num(4.0)), ("spacing", num(300.0))], img, 0.0, env);
- assert!(alpha_sum(&d.img, 0, 0, 64, 64) < alpha_sum(&a.img, 0, 0, 64, 64), "spaced dabs");
- // No masks: unchanged.
- let src = Image::filled(8, 8, [0.2, 0.3, 0.4, 1.0]);
- assert_eq!(run("ec.generate.stroke", &[], src.clone()).img.data, src.data);
- }
-
- #[test]
- fn vegas_traces_contours() {
- let mut img = Image::new(64, 64);
- for y in 16..48 {
- for x in 16..48 {
- img.set(x, y, [1.0, 1.0, 1.0, 1.0]);
- }
- }
- let a = run(
- "ec.generate.vegas",
- &[("blendMode", Value::Enum(0)), ("length", num(1.0)), ("midpointOpacity", num(1.0)), ("endOpacity", num(1.0))],
- img.clone(),
- );
- let b = run(
- "ec.generate.vegas",
- &[("blendMode", Value::Enum(0)), ("length", num(1.0)), ("midpointOpacity", num(1.0)), ("endOpacity", num(1.0))],
- img.clone(),
- );
- assert_eq!(a.img.data, b.img.data);
- assert!(alpha_sum(&a.img, 14, 14, 50, 50) > 50.0, "edges drawn");
- assert!(alpha_sum(&a.img, 26, 26, 38, 38) < 0.5, "interior untouched");
- let r = run("ec.generate.vegas", &[("blendMode", Value::Enum(0)), ("rotation", num(90.0))], img);
- assert_ne!(r.img.data, a.img.data);
- }
-
- #[test]
- fn contours_of_square_are_closed() {
- let mut pl = Plane::new(20, 20);
- for y in 5..15 {
- for x in 5..15 {
- pl.data[y * 20 + x] = 1.0;
- }
- }
- let c = contours(&pl, 0.5);
- assert_eq!(c.len(), 1);
- assert!(c[0].1);
- let l = poly_length(&c[0].0, true);
- assert!((l - 40.0).abs() < 4.0, "{l}");
- }
-
- #[test]
- fn write_on_and_glue_gun_draw_at_brush() {
- let img = Image::new(32, 32);
- let a = run("ec.generate.writeon", &[], img.clone());
- assert!(a.img.get(16, 16)[3] > 0.9 && a.img.get(2, 2)[3] == 0.0);
- assert_eq!(a.img.data, run("ec.generate.writeon", &[], img.clone()).img.data);
- let src = Image::filled(32, 32, [0.5, 0.2, 0.1, 1.0]);
- let g = run("ec.generate.ccgluegun", &[], src.clone());
- assert_eq!(g.img.data, run("ec.generate.ccgluegun", &[], src.clone()).img.data);
- assert_ne!(g.img.get(16, 16), src.get(16, 16));
- assert_eq!(g.img.get(0, 0), src.get(0, 0));
- }
-
- /// #536: an animated Brush Position draws a stroke that stays (Stroke Length 0), expires
- /// after Stroke Length, and lays its dabs Brush Spacing seconds apart.
- #[test]
- fn write_on_accumulates_a_stroke_along_the_animated_brush() {
- // Brush Position from [8, 16] at 0 s to [56, 16] at 1 s; red, hard, 6 px.
- struct Brush(Vec<(&'static str, Value)>);
- impl Brush {
- fn at(&self, t: f64) -> Vec<(&'static str, Value)> {
- let mut v = self.0.clone();
- v.push(("brushPosition", Value::Vec2([8.0 + 48.0 * t.clamp(0.0, 1.0), 16.0])));
- v
- }
- }
- impl EffectHost for Brush {
- fn layer(&self, _: u64, _: bool) -> Option {
- None
- }
- fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option> {
- None
- }
- fn params_at(&self, t: f64) -> Option {
- let s = crate::find("ec.generate.writeon").unwrap();
- let mut p = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
- for (k, v) in self.at(t) {
- p.values.insert(k.to_string(), v);
- }
- Some(p)
- }
- }
- let render = |extra: &[(&'static str, Value)], t: f64| {
- let mut set = vec![("color", col(1.0, 0.0, 0.0)), ("brushSize", num(6.0)), ("brushHardness", num(100.0)), ("brushSpacing", num(0.05))];
- set.extend(extra.iter().cloned());
- let host = Brush(set);
- let env = EffectEnv { host: Some(&host), ..Default::default() };
- let at = host.at(t);
- run_env("ec.generate.writeon", &at, Image::new(64, 32), t, env).img
- };
- let on = |img: &Image, x: i64| img.get(x, 16)[3] > 0.9;
- let half = render(&[], 0.5);
- assert!(on(&half, 8) && on(&half, 20) && on(&half, 32) && !on(&half, 44) && !on(&half, 56));
- let end = render(&[], 1.0);
- assert!([8, 20, 32, 44, 56].iter().all(|x| on(&end, *x)));
- // Stroke Length 0.25 s: only the last quarter second's trail.
- let trail = render(&[("strokeLength", num(0.25))], 1.0);
- assert!(!on(&trail, 8) && !on(&trail, 32) && on(&trail, 48) && on(&trail, 56));
- // Brush Spacing 0.5 s: three separate marks.
- let spaced = render(&[("brushSpacing", num(0.5))], 1.0);
- assert!(on(&spaced, 8) && on(&spaced, 32) && on(&spaced, 56) && !on(&spaced, 20) && !on(&spaced, 44));
- // Paint Time Properties ▸ Opacity: each dab keeps the opacity it was laid with.
- struct Fade;
- impl EffectHost for Fade {
- fn layer(&self, _: u64, _: bool) -> Option {
- None
- }
- fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option> {
- None
- }
- fn params_at(&self, t: f64) -> Option {
- let mut p = Brush(vec![("brushHardness", num(100.0)), ("brushSpacing", num(0.05)), ("paintTimeProperties", Value::Enum(1))]).params_at(t)?;
- p.values.insert("brushOpacity".into(), num(if t < 0.5 { 100.0 } else { 20.0 }));
- Some(p)
- }
- }
- let p1 = Fade.params_at(1.0).unwrap();
- let set: Vec<(&str, Value)> = p1.values.iter().map(|(k, v)| (k.as_str(), v.clone())).collect();
- let faded = run_env("ec.generate.writeon", &set, Image::new(64, 32), 1.0, EffectEnv { host: Some(&Fade), ..Default::default() }).img;
- assert!(faded.get(8, 16)[3] > 0.9 && (faded.get(56, 16)[3] - 0.2).abs() < 0.05, "{:?} {:?}", faded.get(8, 16), faded.get(56, 16));
- }
-
- #[test]
- fn paint_bucket_fills_enclosed_region_only() {
- let mut img = Image::filled(32, 32, [1.0, 1.0, 1.0, 1.0]);
- for i in 8..24 {
- for &(x, y) in &[(i, 8), (i, 23), (8, i), (23, i)] {
- img.set(x, y, [0.0, 0.0, 0.0, 1.0]);
- }
- }
- let out = run("ec.generate.paintbucket", &[], img.clone());
- let inside = out.img.get(16, 16);
- assert!(inside[0] > 0.99 && inside[1] < 0.01, "{inside:?}");
- assert_eq!(out.img.get(2, 2), [1.0, 1.0, 1.0, 1.0], "outside untouched");
- assert_eq!(out.img.get(8, 16), [0.0, 0.0, 0.0, 1.0], "border untouched");
- assert_eq!(out.img.data, run("ec.generate.paintbucket", &[], img).img.data);
- }
-
- #[test]
- fn eyedropper_fill_uses_sample() {
- let mut img = Image::filled(16, 16, [0.0, 0.0, 1.0, 1.0]);
- img.set(8, 8, [1.0, 0.0, 0.0, 1.0]);
- let out = run("ec.generate.eyedropperfill", &[], img.clone());
- assert!(out.img.data.iter().all(|p| *p == [1.0, 0.0, 0.0, 1.0]));
- let blended = run("ec.generate.eyedropperfill", &[("blendWithOriginal", num(100.0))], img.clone());
- assert_eq!(blended.img.data, img.data);
- }
-
- #[test]
- fn threads_weave_is_deterministic_and_gappy() {
- let src = Image::filled(64, 64, [0.4, 0.6, 0.2, 1.0]);
- let a = run("ec.generate.ccthreads", &[("width", num(16.0)), ("height", num(16.0)), ("coverage", num(50.0))], src.clone());
- assert_eq!(a.img.data, run("ec.generate.ccthreads", &[("width", num(16.0)), ("height", num(16.0)), ("coverage", num(50.0))], src).img.data);
- assert!(a.img.data.iter().any(|p| p[3] == 0.0), "gaps between threads");
- assert!(a.img.data.iter().any(|p| p[3] > 0.99), "threads");
- }
-
- struct Tone;
- impl EffectHost for Tone {
- fn layer(&self, _: u64, _: bool) -> Option {
- None
- }
- fn audio(&self, _: u64, start: f64, frames: usize, rate: u32) -> Option> {
- Some(
- (0..frames)
- .flat_map(|i| {
- let t = start + i as f64 / rate as f64;
- let v = (2.0 * PI * 440.0 * t).sin() as f32 * 0.8;
- [v, v]
- })
- .collect(),
- )
- }
- }
-
- #[test]
- fn audio_effects_without_audio_pass_through() {
- let src = Image::filled(16, 16, [0.3, 0.3, 0.3, 1.0]);
- for id in ["ec.generate.audiospectrum", "ec.generate.audiowaveform"] {
- assert_eq!(run(id, &[], src.clone()).img.data, src.data, "{id}");
- }
- }
-
- #[test]
- fn audio_effects_draw_with_host() {
- let host = Tone;
- let env = EffectEnv { host: Some(&host), comp_time: 1.0, ..Default::default() };
- let img = Image::new(96, 64);
- for id in ["ec.generate.audiospectrum", "ec.generate.audiowaveform"] {
- let a = run_env(id, &[("audioLayer", Value::Layer(Some(1)))], img.clone(), 1.0, env);
- let b = run_env(id, &[("audioLayer", Value::Layer(Some(1)))], img.clone(), 1.0, env);
- assert_eq!(a.img.data, b.img.data, "{id}");
- assert!(alpha_sum(&a.img, 0, 0, 96, 64) > 10.0, "{id} drew nothing");
- }
- }
-
- #[test]
- fn fft_finds_tone() {
- let n = 256;
- let mut re: Vec = (0..n).map(|i| (2.0 * PI * 8.0 * i as f64 / n as f64).cos()).collect();
- let mut im = vec![0.0; n];
- fft(&mut re, &mut im);
- let mags: Vec = (0..n / 2).map(|k| (re[k] * re[k] + im[k] * im[k]).sqrt()).collect();
- let peak = mags.iter().enumerate().max_by(|a, b| a.1.total_cmp(b.1)).unwrap().0;
- assert_eq!(peak, 8);
- }
-
- #[test]
- fn stroke_outline_caps_and_joins() {
- let line = vec![vec![[10.0, 10.0], [30.0, 10.0]]];
- let cov = |cap: u32| raster_convex(40, 20, &stroke_outline(&line, 3.0, cap, 0, 4.0));
- // Round caps reach 3 px past the ends (on the axis), Butt stops there, Projecting is square.
- let (round, butt, proj) = (cov(0), cov(1), cov(2));
- assert!(round.get(8, 10) > 0.9 && butt.get(8, 10) < 0.1 && proj.get(8, 10) > 0.9);
- assert!(proj.get(7, 7) > 0.9 && round.get(7, 7) < 0.5, "square corner");
- // A right-angle turn: Miter fills the outer corner, Bevel cuts it.
- let corner = vec![vec![[5.0, 30.0], [30.0, 30.0], [30.0, 5.0]]];
- let j = |join: u32| raster_convex(40, 40, &stroke_outline(&corner, 3.0, 1, join, 4.0));
- let (miter, bevel) = (j(1), j(2));
- assert!(miter.get(32, 32) > 0.9 && bevel.get(32, 32) < 0.1, "{} {}", miter.get(32, 32), bevel.get(32, 32));
- // A tight miter limit falls back to a bevel.
- let limited = raster_convex(40, 40, &stroke_outline(&corner, 3.0, 1, 1, 1.0));
- assert!(limited.get(32, 32) < 0.1);
- }
-
- #[test]
- fn scribble_caps_and_start_end_apply_to() {
- let masks = square_mask();
- let env = EffectEnv { masks: &masks, ..Default::default() };
- let img = Image::new(64, 64);
- let base = [("wiggleType", Value::Enum(0)), ("strokeWidth", num(3.0))];
- let round = run_env("ec.generate.scribble", &base, img.clone(), 0.0, env);
- let butt = run_env(
- "ec.generate.scribble",
- &[base.as_slice(), &[("edgeOptions/endCap", Value::Enum(1)), ("edgeOptions/join", Value::Enum(2))]].concat(),
- img.clone(),
- 0.0,
- env,
- );
- assert_ne!(round.img.data, butt.img.data);
- // Each Stroke: every stroke is trimmed on its own, so the half-way image has ink all over.
- let two = vec![
- crate::MaskShape { name: String::new(), points: vec![[4.0, 4.0], [28.0, 4.0], [28.0, 60.0], [4.0, 60.0]], closed: true, inverted: false },
- crate::MaskShape { name: String::new(), points: vec![[36.0, 4.0], [60.0, 4.0], [60.0, 60.0], [36.0, 60.0]], closed: true, inverted: false },
- ];
- let env2 = EffectEnv { masks: &two, ..Default::default() };
- let seq = [("scribble", Value::Enum(1)), ("end", num(50.0))];
- let all = run_env("ec.generate.scribble", &[base.as_slice(), &seq].concat(), img.clone(), 0.0, env2);
- let each = run_env("ec.generate.scribble", &[base.as_slice(), &seq, &[("startEndApplyTo", Value::Enum(1))]].concat(), img, 0.0, env2);
- assert_ne!(all.img.data, each.img.data);
- }
-}
+#[cfg(test)]
+mod tests;
diff --git a/crates/effects/src/generate3/audio.rs b/crates/effects/src/generate3/audio.rs
new file mode 100644
index 000000000..f1ac54db8
--- /dev/null
+++ b/crates/effects/src/generate3/audio.rs
@@ -0,0 +1,314 @@
+use super::raster::{Seg, mask_px, over, poly_segs, raster_segs};
+use super::*;
+
+// ---------------------------------------------------------------- Audio Spectrum / Waveform
+
+/// In-place iterative radix-2 FFT (`re`, `im` lengths a power of two).
+pub(crate) fn fft(re: &mut [f64], im: &mut [f64]) {
+ let n = re.len();
+ if n < 2 {
+ return;
+ }
+ let mut j = 0;
+ for i in 1..n {
+ let mut bit = n >> 1;
+ while j & bit != 0 {
+ j ^= bit;
+ bit >>= 1;
+ }
+ j |= bit;
+ if i < j {
+ re.swap(i, j);
+ im.swap(i, j);
+ }
+ }
+ let mut len = 2;
+ while len <= n {
+ let ang = -2.0 * PI / len as f64;
+ let (ws, wc) = ang.sin_cos();
+ for start in (0..n).step_by(len) {
+ let (mut cr, mut ci) = (1.0, 0.0);
+ for k in 0..len / 2 {
+ let (a, bb) = (start + k, start + k + len / 2);
+ let tr = re[bb] * cr - im[bb] * ci;
+ let ti = re[bb] * ci + im[bb] * cr;
+ re[bb] = re[a] - tr;
+ im[bb] = im[a] - ti;
+ re[a] += tr;
+ im[a] += ti;
+ let ncr = cr * wc - ci * ws;
+ ci = cr * ws + ci * wc;
+ cr = ncr;
+ }
+ }
+ len <<= 1;
+ }
+}
+
+const AUDIO_RATE: u32 = 48_000;
+
+/// Fetch mono (or one channel) samples of the audio layer around the current time.
+fn audio_window(ctx: &EffectCtx, dur_ms: f64, offset_ms: f64, channel: u32) -> Option> {
+ let id = ctx.params.get("audioLayer")?.as_layer()?;
+ let host = ctx.env.host?;
+ let dur = (dur_ms / 1000.0).max(0.001);
+ let frames = ((dur * AUDIO_RATE as f64) as usize).clamp(16, 1 << 16);
+ let start = ctx.env.comp_time + offset_ms / 1000.0 - dur * 0.5;
+ let s = host.audio(id, start, frames, AUDIO_RATE)?;
+ Some(
+ (0..frames)
+ .map(|i| {
+ let (l, r) = (*s.get(2 * i).unwrap_or(&0.0) as f64, *s.get(2 * i + 1).unwrap_or(&0.0) as f64);
+ match channel {
+ 1 => l,
+ 2 => r,
+ _ => (l + r) * 0.5,
+ }
+ })
+ .collect(),
+ )
+}
+
+/// The drawing baseline: a polyline in buffer px (mask path or start→end line), sampled at
+/// parameter u∈[0,1] → (point, unit normal).
+struct Baseline {
+ pts: Vec<[f64; 2]>,
+ closed: bool,
+ len: f64,
+ polar: bool,
+ center: [f64; 2],
+ radius: f64,
+}
+
+impl Baseline {
+ fn new(ctx: &EffectCtx, b: &Buf) -> Baseline {
+ let pr = ctx.params;
+ let polar = pr.b("usePolarPath");
+ let (pts, closed) = match mask_px(ctx, b, pr.f("path").round() as usize) {
+ Some((p, c, _)) if !polar => (p, c),
+ _ => {
+ let s = b.to_px(pr.v2("startPoint"));
+ let e = b.to_px(pr.v2("endPoint"));
+ (vec![[s.0, s.1], [e.0, e.1]], false)
+ }
+ };
+ let len = poly_length(&pts, closed);
+ let center = pts[0];
+ let radius = if pts.len() > 1 { ((pts[1][0] - pts[0][0]).powi(2) + (pts[1][1] - pts[0][1]).powi(2)).sqrt() } else { 1.0 };
+ Baseline { pts, closed, len, polar, center, radius }
+ }
+ fn at(&self, u: f64) -> ([f64; 2], [f64; 2]) {
+ if self.polar {
+ let a = u * 2.0 * PI - PI * 0.5;
+ let (s, c) = a.sin_cos();
+ return ([self.center[0] + c * self.radius * 0.5, self.center[1] + s * self.radius * 0.5], [c, s]);
+ }
+ let (q, d) = crate::util::poly_point_at(&self.pts, self.closed, u * self.len);
+ (q, [d[1], -d[0]])
+ }
+}
+
+/// Draw line/dot marks with core (inside colour) and soft halo (outside colour).
+fn draw_marks(b: &mut Buf, segs_core: &[Seg], thickness: f64, softness: f64, inside: [f32; 4], outside: [f32; 4], composite: bool) {
+ let (w, h) = (b.img.width as usize, b.img.height as usize);
+ let core = raster_segs(w, h, segs_core, 1.0);
+ let halo_segs: Vec = segs_core.iter().map(|s| Seg { r: s.r + thickness * softness.max(0.0) + 0.5, ..*s }).collect();
+ let halo = if softness > 0.0 { raster_segs(w, h, &halo_segs, 0.0) } else { core.clone() };
+ b.img.data.par_iter_mut().enumerate().for_each(|(i, px)| {
+ let (c, hl) = (core.data[i], halo.data[i]);
+ let a = c.max(hl);
+ let base = if composite { *px } else { [0.0; 4] };
+ if a <= 0.0 {
+ *px = base;
+ return;
+ }
+ let t = if a > 0.0 { c / a } else { 0.0 };
+ let col = crate::util::lerp3([outside[0], outside[1], outside[2]], [inside[0], inside[1], inside[2]], t);
+ *px = over(base, premul(col, a));
+ });
+}
+
+/// Audio Spectrum / Audio Waveform, shared with the GPU compositor (effectcraft-gpu `fx_gen2`):
+/// the marks (the audio analysis runs on the CPU) and how `draw_marks` colours them.
+#[derive(Clone, Debug)]
+pub struct MarksPlan {
+ pub segs: Vec,
+ pub thickness: f64,
+ pub softness: f64,
+ pub inside: [f32; 4],
+ pub outside: [f32; 4],
+ pub composite: bool,
+}
+
+/// [`MarksPlan`] of Audio Spectrum or Audio Waveform on `b`'s geometry (`None` = no audio:
+/// the layer passes through).
+pub fn marks_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option {
+ match id {
+ "ec.generate.audiospectrum" => spectrum_plan(ctx, b),
+ "ec.generate.audiowaveform" => waveform_plan(ctx, b),
+ _ => None,
+ }
+}
+
+fn marks(ctx: &EffectCtx, segs: Vec, thick: f64, soft: f64) -> MarksPlan {
+ let pr = ctx.params;
+ MarksPlan {
+ segs,
+ thickness: thick,
+ softness: soft * 2.0,
+ inside: pr.color("insideColor"),
+ outside: pr.color("outsideColor"),
+ composite: pr.b("compositeOnOriginal"),
+ }
+}
+
+pub(super) fn audio_spectrum(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ if let Some(m) = spectrum_plan(ctx, &b) {
+ draw_marks(&mut b, &m.segs, m.thickness, m.softness, m.inside, m.outside, m.composite);
+ }
+ b
+}
+
+pub(super) fn audio_waveform(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ if let Some(m) = waveform_plan(ctx, &b) {
+ draw_marks(&mut b, &m.segs, m.thickness, m.softness, m.inside, m.outside, m.composite);
+ }
+ b
+}
+
+fn compute_fft_mags(samples: &[f64]) -> (usize, f64, Vec) {
+ let m = samples.len();
+ let n = m.next_power_of_two().max(64);
+ let mut re = vec![0.0; n];
+ let mut im = vec![0.0; n];
+ let denom = (m.max(2) - 1) as f64;
+ for (i, s) in samples.iter().enumerate() {
+ let w = 0.5 - 0.5 * (2.0 * PI * i as f64 / denom).cos();
+ if let Some(r) = re.get_mut(i) {
+ *r = s * w;
+ }
+ }
+ fft(&mut re, &mut im);
+ let hz_per_bin = AUDIO_RATE as f64 / n as f64;
+ let scale = 4.0 / m.max(1) as f64;
+ let num_bins = n / 2 + 1;
+ let mut mags = Vec::with_capacity(num_bins);
+ for k in 0..num_bins {
+ let r = re.get(k).copied().unwrap_or(0.0);
+ let im_val = im.get(k).copied().unwrap_or(0.0);
+ let mag = (r * r + im_val * im_val).sqrt() * scale;
+ mags.push(mag);
+ }
+ (n, hz_per_bin, mags)
+}
+
+fn spectrum_plan(ctx: &EffectCtx, b: &Buf) -> Option {
+ let pr = ctx.params;
+ let samples = audio_window(ctx, pr.f("audioDuration"), pr.f("audioOffset"), 0)?;
+ let (_n, hz_per_bin, mags) = compute_fft_mags(&samples);
+
+ let bands = pr.f("frequencyBands").round().clamp(1.0, 4096.0) as usize;
+ let f0 = pr.f("startFrequency").max(0.0);
+ let f1 = pr.f("endFrequency").max(f0 + 1.0);
+ let max_bin = mags.len().saturating_sub(1);
+
+ let get_band_mag = |fc: f64| -> f64 {
+ if mags.is_empty() || hz_per_bin <= 0.0 {
+ return 0.0;
+ }
+ let k_float = (fc / hz_per_bin).clamp(0.0, max_bin as f64);
+ let k0 = (k_float.floor() as usize).min(max_bin.saturating_sub(1));
+ let k1 = (k0 + 1).min(max_bin);
+ let frac = (k_float - k0 as f64).clamp(0.0, 1.0);
+ let m0 = mags.get(k0).copied().unwrap_or(0.0);
+ let m1 = mags.get(k1).copied().unwrap_or(0.0);
+ m0 * (1.0 - frac) + m1 * frac
+ };
+
+ let max_h = pr.f("maximumHeight") * b.scale;
+ let thick = (pr.f("thickness") * b.scale).max(0.1);
+ let soft = pr.f("softness") / 100.0;
+ let disp = pr.e("displayOptions");
+ let side = pr.e("sideOptions");
+ let base = Baseline::new(ctx, b);
+ let mut tops = Vec::with_capacity(bands);
+ let mut segs = Vec::new();
+ for i in 0..bands {
+ let u = if bands > 1 { i as f64 / (bands - 1) as f64 } else { 0.5 };
+ let fc = f0 + (f1 - f0) * u;
+ let v = get_band_mag(fc);
+ let hgt = if (v * max_h).is_finite() { (v * max_h).clamp(0.0, max_h.max(0.0)) } else { 0.0 };
+ let (q, nrm) = base.at(u);
+ let (ua, ub) = match side {
+ 0 => (0.0, hgt),
+ 1 => (-hgt, 0.0),
+ _ => (-hgt, hgt),
+ };
+ let pa = [q[0] + nrm[0] * ua, q[1] + nrm[1] * ua];
+ let pb = [q[0] + nrm[0] * ub, q[1] + nrm[1] * ub];
+ match disp {
+ 0 => segs.push(Seg { a: pa, b: pb, r: thick * 0.5, v: 1.0 }),
+ _ => tops.push((pa, pb)),
+ }
+ }
+ if disp == 1 {
+ for w2 in tops.windows(2) {
+ segs.push(Seg { a: w2[0].1, b: w2[1].1, r: thick * 0.5, v: 1.0 });
+ if side == 2 {
+ segs.push(Seg { a: w2[0].0, b: w2[1].0, r: thick * 0.5, v: 1.0 });
+ }
+ }
+ } else if disp == 2 {
+ for &(pa, pb) in &tops {
+ segs.push(Seg { a: pb, b: pb, r: thick * 0.5, v: 1.0 });
+ if side == 2 {
+ segs.push(Seg { a: pa, b: pa, r: thick * 0.5, v: 1.0 });
+ }
+ }
+ }
+ Some(marks(ctx, segs, thick, soft))
+}
+
+fn waveform_plan(ctx: &EffectCtx, b: &Buf) -> Option {
+ let pr = ctx.params;
+ let samples = audio_window(ctx, pr.f("audioDuration"), pr.f("audioOffset"), pr.e("waveformOptions"))?;
+ let count = pr.f("displayedSamples").round().clamp(2.0, 4096.0) as usize;
+ let max_h = pr.f("maximumHeight") * b.scale;
+ let thick = (pr.f("thickness") * b.scale).max(0.1);
+ let soft = pr.f("softness") / 100.0;
+ let disp = pr.e("displayOptions");
+ let base = Baseline::new(ctx, b);
+ let m = samples.len();
+ let mut pts = Vec::with_capacity(count);
+ let mut segs = Vec::new();
+ for i in 0..count {
+ let u = i as f64 / (count - 1) as f64;
+ let a = ((u * (m - 1) as f64) as usize).min(m - 1);
+ let bnd = (((i + 1) as f64 / count as f64 * (m - 1) as f64) as usize).clamp(a, m - 1);
+ // Peak with sign of the window for a stable digital display.
+ let (mut lo, mut hi) = (0.0f64, 0.0f64);
+ for s in &samples[a..=bnd] {
+ lo = lo.min(*s);
+ hi = hi.max(*s);
+ }
+ let (q, nrm) = base.at(u);
+ match disp {
+ 0 => segs.push(Seg {
+ a: [q[0] + nrm[0] * lo * max_h, q[1] + nrm[1] * lo * max_h],
+ b: [q[0] + nrm[0] * hi * max_h, q[1] + nrm[1] * hi * max_h],
+ r: thick * 0.5,
+ v: 1.0,
+ }),
+ _ => {
+ let v = samples[a] * max_h;
+ pts.push([q[0] + nrm[0] * v, q[1] + nrm[1] * v]);
+ }
+ }
+ }
+ if disp == 1 {
+ poly_segs(&pts, false, thick * 0.5, 1.0, &mut segs);
+ } else if disp == 2 {
+ segs.extend(pts.iter().map(|&q| Seg { a: q, b: q, r: thick * 0.5, v: 1.0 }));
+ }
+ Some(marks(ctx, segs, thick, soft))
+}
diff --git a/crates/effects/src/generate3/common.rs b/crates/effects/src/generate3/common.rs
new file mode 100644
index 000000000..b996cdc99
--- /dev/null
+++ b/crates/effects/src/generate3/common.rs
@@ -0,0 +1,13 @@
+use super::*;
+
+pub(super) fn spec(id: &'static str, name: &'static str, params: Vec, render: crate::RenderFn) -> EffectSpec {
+ EffectSpec { id, name, category: "Generate", params, render, gpu: false, float: true }
+}
+
+pub(super) fn pt(x: f64, y: f64) -> Value {
+ Value::Vec2([x, y])
+}
+
+pub(super) fn pct() -> ParamUi {
+ slider(0.0, 100.0, 0.0, 100.0, 1)
+}
diff --git a/crates/effects/src/generate3/fill.rs b/crates/effects/src/generate3/fill.rs
new file mode 100644
index 000000000..a86f123ee
--- /dev/null
+++ b/crates/effects/src/generate3/fill.rs
@@ -0,0 +1,334 @@
+use super::raster::over;
+use super::*;
+
+pub(super) fn glue_gun(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ let pr = ctx.params;
+ let q = b.to_px(pr.v2("brushPosition"));
+ let rad = (pr.f("strokeWidth") * b.scale * 0.5).max(0.5);
+ let density = pr.f("density").max(0.0);
+ let refl = pr.f("reflection").to_radians();
+ let strength = (pr.f("strength") / 100.0) as f32;
+ let glue_only = pr.e("style") == 1;
+ let src = b.img.clone();
+ let light = [refl.cos() * 0.6, -refl.sin() * 0.6, 0.53];
+ let beads = (density.round() as usize).clamp(1, 32);
+ let seed = ctx.seed;
+ let centers: Vec<([f64; 2], f64)> = (0..beads)
+ .map(|i| {
+ let a = hash1(i as u32, 1, seed) as f64 * 2.0 * PI;
+ let d = if i == 0 { 0.0 } else { hash1(i as u32, 2, seed) as f64 * rad * 0.35 };
+ ([q.0 + a.cos() * d, q.1 + a.sin() * d], rad * (0.75 + 0.25 * hash1(i as u32, 3, seed) as f64))
+ })
+ .collect();
+ b.img.rows_mut().for_each(|(y, row)| {
+ for (x, px) in row.iter_mut().enumerate() {
+ let (fx, fy) = (x as f64 + 0.5, y as f64 + 0.5);
+ // Height field: union of hemispheres.
+ let mut best = (0.0f64, [0.0f64; 2], 1.0f64);
+ for &(c, r) in ¢ers {
+ let (dx, dy) = ((fx - c[0]) / r, (fy - c[1]) / r);
+ let d2 = dx * dx + dy * dy;
+ if d2 < 1.0 {
+ let hgt = (1.0 - d2).sqrt();
+ if hgt > best.0 {
+ best = (hgt, [dx, dy], r);
+ }
+ }
+ }
+ if best.0 <= 0.0 {
+ if glue_only {
+ *px = [0.0; 4];
+ }
+ continue;
+ }
+ let nrm = [best.1[0], best.1[1], best.0];
+ let ndl = (nrm[0] * light[0] + nrm[1] * light[1] + nrm[2] * light[2]).max(0.0);
+ let spec = ndl.powi(24) as f32;
+ // Refraction: look through the bead.
+ let s = src.sample_bilinear_clamped(fx - nrm[0] * best.2 * 0.5 * strength as f64, fy - nrm[1] * best.2 * 0.5 * strength as f64);
+ let edge = smoothstep(0.0, 0.15, best.0 as f32);
+ let shade = 0.65 + 0.35 * ndl as f32;
+ let g = [s[0] * shade + spec, s[1] * shade + spec, s[2] * shade + spec, s[3].max(0.6)];
+ let gp = [g[0].min(g[3] + spec), g[1].min(g[3] + spec), g[2].min(g[3] + spec), g[3].min(1.0)];
+ let base = if glue_only { [0.0; 4] } else { *px };
+ *px = crate::util::lerp4(base, gp, edge * strength.clamp(0.0, 1.0).max(0.3));
+ px[3] = px[3].clamp(0.0, 1.0);
+ }
+ });
+ b
+}
+
+// ---------------------------------------------------------------- Paint Bucket
+
+/// Paint Bucket's filled region (1 inside) on `b`: the flood fill from the Fill Point over the
+/// layer's pixels (shared with the GPU compositor, which reads the layer back for it).
+pub fn paint_bucket_region(ctx: &EffectCtx, b: &Buf) -> Plane {
+ let pr = ctx.params;
+ let (w, h) = (b.img.width as usize, b.img.height as usize);
+ let fp = b.to_px(pr.v2("fillPoint"));
+ let (sx, sy) = (fp.0.floor() as i64, fp.1.floor() as i64);
+ let sel = pr.e("fillSelector");
+ let tol = (pr.f("tolerance") / 255.0) as f32;
+ let key = |p: Px| -> [f32; 4] {
+ let (c, a) = unpremul(p);
+ match sel {
+ 1 => [c[0], c[1], c[2], 0.0],
+ 2 => [0.0, 0.0, 0.0, if a <= 1e-3 { 0.0 } else { 1.0 }],
+ 3 | 4 => [0.0, 0.0, 0.0, a],
+ _ => p,
+ }
+ };
+ let mut region = Plane::new(w, h);
+ if sx >= 0 && sy >= 0 && (sx as usize) < w && (sy as usize) < h {
+ let seed = key(b.img.data[sy as usize * w + sx as usize]);
+ let within = |i: usize| {
+ let k = key(b.img.data[i]);
+ if sel == 2 {
+ return k[3] == seed[3];
+ }
+ (0..4).all(|j| (k[j] - seed[j]).abs() <= tol + 1e-6)
+ };
+ let mut seen = vec![false; w * h];
+ let mut stack = vec![(sx as usize, sy as usize)];
+ while let Some((x, y)) = stack.pop() {
+ let row = y * w;
+ if seen[row + x] || !within(row + x) {
+ continue;
+ }
+ let mut l = x;
+ while l > 0 && !seen[row + l - 1] && within(row + l - 1) {
+ l -= 1;
+ }
+ let mut r = x;
+ while r + 1 < w && !seen[row + r + 1] && within(row + r + 1) {
+ r += 1;
+ }
+ for i in l..=r {
+ seen[row + i] = true;
+ region.data[row + i] = 1.0;
+ if y > 0 && !seen[row - w + i] {
+ stack.push((i, y - 1));
+ }
+ if y + 1 < h && !seen[row + w + i] {
+ stack.push((i, y + 1));
+ }
+ }
+ }
+ }
+ region
+}
+
+pub(super) fn paint_bucket(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ let pr = ctx.params;
+ let (w, h) = (b.img.width as usize, b.img.height as usize);
+ if w == 0 || h == 0 {
+ return b;
+ }
+ let region = paint_bucket_region(ctx, &b);
+ if pr.b("viewThreshold") {
+ b.img.data.par_iter_mut().zip(region.data.par_iter()).for_each(|(px, &v)| *px = [v, v, v, 1.0]);
+ return b;
+ }
+ let sc = b.scale;
+ let mut cov = match pr.e("stroke") {
+ 1 => {
+ let s = pr.f("featherSoftness") * sc * 0.5;
+ if s > 0.05 { gauss_plane(®ion, s, s) } else { region.clone() }
+ }
+ 2 => morph_frac(®ion, pr.f("spreadRadius") * sc, true),
+ 3 => morph_frac(®ion, pr.f("spreadRadius") * sc, false),
+ 4 => {
+ let r = pr.f("strokeWidth") * sc;
+ let out = morph_frac(®ion, r * 0.5, true);
+ let inn = morph_frac(®ion, r * 0.5, false);
+ out.zip_map(&inn, |a, b| (a - b).max(0.0))
+ }
+ _ => gauss_plane(®ion, 0.5, 0.5),
+ };
+ if pr.e("stroke") == 0 {
+ // Antialias: keep the hard interior, soften only the boundary.
+ cov = cov.zip_map(®ion, |a, r| if r > 0.0 { a.max(0.5) } else { a });
+ }
+ let color = pr.color("color");
+ let op = (pr.f("opacity") / 100.0) as f32;
+ let mode = pr.e("blendingMode");
+ b.img.data.par_iter_mut().zip(cov.data.par_iter()).for_each(|(px, &c)| {
+ let k = (c * op * color[3]).clamp(0.0, 1.0);
+ if k <= 0.0 {
+ if mode == 9 {
+ *px = [0.0; 4];
+ }
+ return;
+ }
+ let (dc, da) = unpremul(*px);
+ let fc = [color[0], color[1], color[2]];
+ let mixed = match mode {
+ 1 => [dc[0] + fc[0], dc[1] + fc[1], dc[2] + fc[2]],
+ 2 => [dc[0] * fc[0], dc[1] * fc[1], dc[2] * fc[2]],
+ 3 => [1.0 - (1.0 - dc[0]) * (1.0 - fc[0]), 1.0 - (1.0 - dc[1]) * (1.0 - fc[1]), 1.0 - (1.0 - dc[2]) * (1.0 - fc[2])],
+ 4..=7 => {
+ let (dh, ds, dl) = rgb_to_hsl(dc[0], dc[1], dc[2]);
+ let (fh, fs, fl) = rgb_to_hsl(fc[0], fc[1], fc[2]);
+ let (r, g, bl) = match mode {
+ 4 => hsl_to_rgb(fh, ds, dl),
+ 5 => hsl_to_rgb(dh, fs, dl),
+ 6 => hsl_to_rgb(fh, fs, dl),
+ _ => hsl_to_rgb(dh, ds, fl),
+ };
+ [r, g, bl]
+ }
+ _ => fc,
+ };
+ *px = match mode {
+ 8 => over(premul(fc, k), *px),
+ 9 => premul(fc, k),
+ 0 => over(*px, premul(fc, k)),
+ _ => {
+ if da <= 1e-6 {
+ return;
+ }
+ let c3 = crate::util::lerp3(dc, mixed, k);
+ premul(c3, da)
+ }
+ };
+ });
+ b
+}
+
+// ---------------------------------------------------------------- Eyedropper Fill
+
+pub(super) fn eyedropper_fill(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ let pr = ctx.params;
+ let fill = eyedropper_color(ctx, &b);
+ let keep_alpha = pr.b("maintainOriginalAlpha");
+ let blend = (pr.f("blendWithOriginal") / 100.0) as f32;
+ b.img.data.par_iter_mut().for_each(|px| {
+ let a = if keep_alpha { px[3] } else { fill[3] };
+ let f = premul([fill[0], fill[1], fill[2]], a);
+ *px = crate::util::lerp4(f, *px, blend);
+ });
+ b
+}
+
+/// Eyedropper Fill's sampled colour (straight RGB, alpha) from the layer's pixels (shared with
+/// the GPU compositor, which reads the layer back for it).
+pub fn eyedropper_color(ctx: &EffectCtx, b: &Buf) -> Px {
+ let pr = ctx.params;
+ let (w, h) = (b.img.width as i64, b.img.height as i64);
+ let c = b.to_px(pr.v2("samplePoint"));
+ let r = (pr.f("sampleRadius") * b.scale).max(0.0);
+ let mode = pr.e("averagePixelColors");
+ let (cx, cy) = (c.0.floor() as i64, c.1.floor() as i64);
+ let ri = r.ceil() as i64;
+ let mut acc = [0.0f64; 4];
+ let mut n = 0.0f64;
+ for y in (cy - ri).max(0)..=(cy + ri).min(h - 1) {
+ for x in (cx - ri).max(0)..=(cx + ri).min(w - 1) {
+ if ((x - cx).pow(2) + (y - cy).pow(2)) as f64 > r * r + 0.5 {
+ continue;
+ }
+ let px = b.img.data[(y * w + x) as usize];
+ match mode {
+ 0 => {
+ if px[3] > 1e-4 {
+ let (s, _) = unpremul(px);
+ for k in 0..3 {
+ acc[k] += s[k] as f64;
+ }
+ acc[3] += 1.0;
+ n += 1.0;
+ }
+ }
+ 1 => {
+ let (s, _) = unpremul(px);
+ for k in 0..3 {
+ acc[k] += s[k] as f64;
+ }
+ acc[3] += 1.0;
+ n += 1.0;
+ }
+ 2 => {
+ for k in 0..3 {
+ acc[k] += px[k] as f64;
+ }
+ acc[3] += 1.0;
+ n += 1.0;
+ }
+ _ => {
+ for k in 0..4 {
+ acc[k] += px[k] as f64;
+ }
+ n += 1.0;
+ }
+ }
+ }
+ }
+ if n > 0.0 {
+ if mode == 3 {
+ let a = (acc[3] / n) as f32;
+ let s = if a > 1e-6 { [(acc[0] / n) as f32 / a, (acc[1] / n) as f32 / a, (acc[2] / n) as f32 / a] } else { [0.0; 3] };
+ [s[0], s[1], s[2], a]
+ } else {
+ [(acc[0] / n) as f32, (acc[1] / n) as f32, (acc[2] / n) as f32, 1.0]
+ }
+ } else {
+ [0.0, 0.0, 0.0, 0.0]
+ }
+}
+
+// ---------------------------------------------------------------- CC Threads
+
+pub(super) fn threads(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ let pr = ctx.params;
+ let sc = b.scale;
+ let tw = (pr.f("width") * sc).max(1.0);
+ let th = (pr.f("height") * sc).max(1.0);
+ let overlaps = pr.f("overlaps").round().clamp(1.0, 20.0) as i64;
+ let ang = pr.f("direction").to_radians();
+ let (sn, cs) = ang.sin_cos();
+ let c = b.to_px(pr.v2("center"));
+ let coverage = (pr.f("coverage") / 100.0).clamp(0.0, 1.0);
+ let shadow = (pr.f("shadowing") / 100.0) as f32;
+ let texture = (pr.f("texture") / 100.0) as f32;
+ let src = b.img.clone();
+ let to_px = |u: f64, v: f64| (c.0 + u * cs - v * sn, c.1 + u * sn + v * cs);
+ b.img.rows_mut().for_each(|(y, row)| {
+ for (x, px) in row.iter_mut().enumerate() {
+ let (dx, dy) = (x as f64 + 0.5 - c.0, y as f64 + 0.5 - c.1);
+ let u = dx * cs + dy * sn;
+ let v = -dx * sn + dy * cs;
+ let (ci, cj) = ((u / tw).floor() as i64, (v / th).floor() as i64);
+ let (fu, fv) = (u / tw - ci as f64, v / th - cj as f64);
+ // Horizontal thread j occupies the band |fv-0.5| < coverage/2; vertical thread i the
+ // band |fu-0.5| < coverage/2.
+ let in_h = (fv - 0.5).abs() < coverage * 0.5;
+ let in_v = (fu - 0.5).abs() < coverage * 0.5;
+ // Twill: horizontal is on top when (i + j) mod (2·overlaps) < overlaps.
+ let h_top = (ci + cj).rem_euclid(2 * overlaps) < overlaps;
+ let which = match (in_h, in_v) {
+ (true, true) => Some(h_top),
+ (true, false) => Some(true),
+ (false, true) => Some(false),
+ _ => None,
+ };
+ let Some(horizontal) = which else {
+ *px = [0.0; 4];
+ continue;
+ };
+ // Thread colour: the source sampled along the thread centre line.
+ let (sx, sy) = if horizontal { to_px(u, (cj as f64 + 0.5) * th) } else { to_px((ci as f64 + 0.5) * tw, v) };
+ let s = src.sample_bilinear_clamped(sx, sy);
+ // Round profile across the thread + darkening where it dives under its neighbour.
+ let across = if horizontal { (fv - 0.5) / (coverage * 0.5).max(1e-6) } else { (fu - 0.5) / (coverage * 0.5).max(1e-6) };
+ let along = if horizontal { fu } else { fv };
+ let profile = (1.0 - across * across).max(0.0).sqrt() as f32;
+ let dive = 1.0 - (along - 0.5).abs() as f32 * 2.0;
+ let shade = 1.0 - shadow * (1.0 - profile) * 0.8 - shadow * 0.25 * (1.0 - dive) * if horizontal == h_top { 0.0 } else { 1.0 };
+ let fib =
+ if texture > 0.0 { 1.0 - texture * 0.3 * hash1((along * 64.0) as u32, (across * 8.0 + 8.0) as u32, ci as u32 ^ (cj as u32) << 8) } else { 1.0 };
+ let k = (shade * fib).max(0.0);
+ *px = [s[0] * k, s[1] * k, s[2] * k, s[3]];
+ }
+ });
+ b
+}
diff --git a/crates/effects/src/generate3/fractal.rs b/crates/effects/src/generate3/fractal.rs
new file mode 100644
index 000000000..519bec640
--- /dev/null
+++ b/crates/effects/src/generate3/fractal.rs
@@ -0,0 +1,193 @@
+use super::raster::over;
+use super::*;
+
+// ---------------------------------------------------------------- Fractal
+
+#[derive(Clone, Copy)]
+struct FracSet {
+ /// Mandelbrot iterations start at the Julia centre (the "Over Julia" set choices).
+ over_julia: bool,
+ julia: bool,
+ inverse: bool,
+}
+
+/// Smooth escape count, or `None` inside the set.
+fn escape(z0: (f64, f64), c: (f64, f64), power: u32, limit: f64, max_iter: u32) -> Option {
+ let (mut x, mut y) = z0;
+ let lim2 = limit * limit;
+ for i in 0..max_iter {
+ let (nx, ny) = match power {
+ 3 => (x * x * x - 3.0 * x * y * y, 3.0 * x * x * y - y * y * y),
+ 4 => {
+ let (a, b) = (x * x - y * y, 2.0 * x * y);
+ (a * a - b * b, 2.0 * a * b)
+ }
+ _ => (x * x - y * y, 2.0 * x * y),
+ };
+ x = nx + c.0;
+ y = ny + c.1;
+ let m2 = x * x + y * y;
+ if m2 > lim2 {
+ let lz = m2.ln() * 0.5;
+ let nu = (lz / limit.max(1.0001).ln()).max(1e-9).ln() / (power as f64).ln();
+ return Some((i as f64 + 1.0 - nu).max(0.0));
+ }
+ }
+ None
+}
+
+/// Fractal Set Choice options.
+pub(crate) const FRACTAL_SETS: [&str; 6] =
+ ["Mandelbrot", "Mandelbrot Inverse", "Mandelbrot Over Julia", "Mandelbrot Inverse Over Julia", "Julia", "Julia Inverse"];
+
+/// Fractal Palette options.
+pub(crate) const FRACTAL_PALETTES: [&str; 4] = ["Lightness Gradient", "Hue Wheel", "Black And White", "Solid Color"];
+
+/// Fractal Oversample Method options.
+pub(crate) const FRACTAL_OVERSAMPLE: [&str; 2] = ["Edge Detect-Fast-May Miss Pixels", "Brute Force-Slow-Every Pixel"];
+
+pub(super) fn fractal(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ let pr = ctx.params;
+ let set_choice = pr.e("setChoice");
+ let power = 2 + pr.e("equation").min(2);
+ let mc = (pr.f("mandelbrot/mandelbrotX"), pr.f("mandelbrot/mandelbrotY"));
+ let mmag = pr.f("mandelbrot/mandelbrotMagnification");
+ let mlim = pr.f("mandelbrot/mandelbrotEscapeLimit").max(1.01);
+ let jc = (pr.f("julia/juliaX"), pr.f("julia/juliaY"));
+ let jmag = pr.f("julia/juliaMagnification");
+ let jlim = pr.f("julia/juliaEscapeLimit").max(1.01);
+ let post = (pr.f("postInversionOffset/postInversionX"), pr.f("postInversionOffset/postInversionY"));
+ let overlay = pr.b("fractalColor/overlay");
+ let transparency = pr.b("fractalColor/transparency");
+ let transparent_inside = transparency || overlay;
+ let palette = pr.e("fractalColor/palette");
+ let hue = (pr.f("fractalColor/hue") / 360.0) as f32;
+ let steps = pr.f("fractalColor/cycleSteps").max(1.0);
+ let cyc_off = pr.f("fractalColor/cycleOffset") / 360.0;
+ let edge = pr.b("fractalColor/edgeHighlight");
+ let every = pr.e("highQualitySettings/samplingMethod") == 1;
+ let factor = pr.f("highQualitySettings/samplingFactor").round().clamp(1.0, 9.0) as usize;
+ let (w, h) = (b.img.width as usize, b.img.height as usize);
+ let lw = ctx.layer_size[0].max(1.0);
+ let lh = ctx.layer_size[1].max(1.0);
+ let inv = 1.0 / b.scale.max(1e-9);
+ let (off_x, off_y) = (b.offset[0], b.offset[1]);
+ // FRACTAL_SETS order.
+ let set = |julia, inverse, over_julia| FracSet { over_julia, julia, inverse };
+ let sets: (FracSet, Option) = match set_choice {
+ 1 => (set(false, true, false), None),
+ 2 => (set(false, false, true), None),
+ 3 => (set(false, true, true), None),
+ 4 => (set(true, false, false), None),
+ 5 => (set(true, true, false), None),
+ _ => (set(false, false, false), None),
+ };
+ let iter_for = |mag: f64| (96.0 + 48.0 * mag.max(0.0)).clamp(64.0, 3000.0) as u32;
+ let eval_set = |s: FracSet, lx: f64, ly: f64| -> Option {
+ let (center, mag, lim) = if s.julia { (jc, jmag, jlim) } else { (mc, mmag, mlim) };
+ let span = 3.5 / 2f64.powf(mag);
+ let mut u = (lx - lw * 0.5) / lw * span + center.0;
+ let mut v = (ly - lh * 0.5) / lw * span + center.1;
+ if s.inverse {
+ let d = (u * u + v * v).max(1e-12);
+ u = u / d + post.0;
+ v = -v / d + post.1;
+ }
+ if s.julia {
+ escape((u, v), mc, power, lim, iter_for(mag))
+ } else {
+ let z0 = if s.over_julia { jc } else { (0.0, 0.0) };
+ escape(z0, (u, v), power, lim, iter_for(mag))
+ }
+ };
+ let eval = |lx: f64, ly: f64| -> Option {
+ let a = eval_set(sets.0, lx, ly);
+ match (a, sets.1) {
+ (None, Some(s2)) => eval_set(s2, lx, ly),
+ _ => a,
+ }
+ };
+ let shade = |n: Option| -> Px {
+ // Solid Color: only the inside of the set is drawn (Transparency flips the sides).
+ if palette == 3 {
+ let (r, g, bl) = hsl_to_rgb(hue, 1.0, 0.5);
+ return if n.is_none() != transparency { [r, g, bl, 1.0] } else { [0.0; 4] };
+ }
+ let Some(n) = n else {
+ return if transparent_inside { [0.0; 4] } else { [0.0, 0.0, 0.0, 1.0] };
+ };
+ let u = n / steps + cyc_off;
+ let band = (u.rem_euclid(1.0)) as f32;
+ let (r, g, bl) = match palette {
+ // Hue Wheel: the full hue circle at full saturation and brightness.
+ 1 => hsl_to_rgb((hue + band).rem_euclid(1.0), 1.0, 0.5),
+ // Black And White: alternating bands.
+ 2 => {
+ let v = if (u.floor() as i64).rem_euclid(2) == 0 { 0.0 } else { 1.0 };
+ (v, v, v)
+ }
+ // Lightness Gradient: black → hue → white, the hue moving 45° each cycle.
+ _ => hsl_to_rgb((hue + u.floor() as f32 * 0.125).rem_euclid(1.0), 0.85, band.clamp(0.0, 1.0)),
+ };
+ let mut c = [r, g, bl];
+ if edge && n.fract() < 0.12 {
+ c = [c[0] * 0.4 + 0.6, c[1] * 0.4 + 0.6, c[2] * 0.4 + 0.6];
+ }
+ [c[0], c[1], c[2], 1.0]
+ };
+ // First pass: one sample per pixel.
+ let mut first: Vec> = vec![None; w * h];
+ first.par_chunks_mut(w.max(1)).enumerate().for_each(|(y, row)| {
+ for (x, v) in row.iter_mut().enumerate() {
+ *v = eval((x as f64 + 0.5 - off_x) * inv, (y as f64 + 0.5 - off_y) * inv);
+ }
+ });
+ let src = if overlay { Some(b.img.clone()) } else { None };
+ b.img.rows_mut().for_each(|(y, row)| {
+ for (x, px) in row.iter_mut().enumerate() {
+ let here = first[y * w + x];
+ let needs_ss = factor > 1
+ && (every || {
+ let mut diff = false;
+ for (dx, dy) in [(-1i64, 0i64), (1, 0), (0, -1), (0, 1)] {
+ let (nx, ny) = (x as i64 + dx, y as i64 + dy);
+ if nx < 0 || ny < 0 || nx >= w as i64 || ny >= h as i64 {
+ continue;
+ }
+ let o = first[ny as usize * w + nx as usize];
+ diff |= match (here, o) {
+ (Some(a), Some(c)) => (a - c).abs() > steps * 0.25,
+ (None, None) => false,
+ _ => true,
+ };
+ }
+ diff
+ });
+ let c = if needs_ss {
+ let mut acc = [0.0f32; 4];
+ for sy in 0..factor {
+ for sx in 0..factor {
+ let fx = x as f64 + (sx as f64 + 0.5) / factor as f64;
+ let fy = y as f64 + (sy as f64 + 0.5) / factor as f64;
+ let s = shade(eval((fx - off_x) * inv, (fy - off_y) * inv));
+ let a = s[3];
+ for k in 0..3 {
+ acc[k] += s[k] * a;
+ }
+ acc[3] += a;
+ }
+ }
+ let n = (factor * factor) as f32;
+ [acc[0] / n, acc[1] / n, acc[2] / n, acc[3] / n]
+ } else {
+ let s = shade(here);
+ [s[0] * s[3], s[1] * s[3], s[2] * s[3], s[3]]
+ };
+ *px = match &src {
+ Some(o) => over(o.data[y * w + x], c),
+ None => c,
+ };
+ }
+ });
+ b
+}
diff --git a/crates/effects/src/generate3/paths.rs b/crates/effects/src/generate3/paths.rs
new file mode 100644
index 000000000..779892cc7
--- /dev/null
+++ b/crates/effects/src/generate3/paths.rs
@@ -0,0 +1,553 @@
+use super::raster::{Seg, all_masks_px, chaikin, mask_px, over, poly_segs, raster_convex, raster_segs, scan_runs, stroke_outline, trim_poly};
+use super::*;
+
+/// How painted coverage meets the layer: 0 On Original Image, 1 On Transparent, 2 Reveal
+/// Original Image.
+pub(crate) fn paint(img: &mut Image, cov: &Plane, color: [f32; 4], opacity: f32, style: u32) {
+ img.data.par_iter_mut().zip(cov.data.par_iter()).for_each(|(px, &c)| {
+ let a = (c * opacity * color[3]).clamp(0.0, 1.0);
+ let s = [color[0] * a, color[1] * a, color[2] * a, a];
+ *px = match style {
+ 1 => s,
+ 2 => [px[0] * a, px[1] * a, px[2] * a, px[3] * a],
+ _ => over(*px, s),
+ };
+ });
+}
+
+/// Coverage of a plan-drawn generator: round-capped segments rasterised by `raster_segs`
+/// with `hardness`, or the union of convex polygons (`raster_convex`).
+#[derive(Clone, Debug)]
+pub enum Coverage {
+ Segs { segs: Vec, hardness: f64 },
+ Convex(Vec>),
+}
+
+impl Coverage {
+ fn raster(&self, w: usize, h: usize) -> Plane {
+ match self {
+ Coverage::Segs { segs, hardness } => raster_segs(w, h, segs, *hardness),
+ Coverage::Convex(polys) => raster_convex(w, h, polys),
+ }
+ }
+}
+
+/// Stroke, Scribble, Vegas and Write-on, shared with the GPU compositor (effectcraft-gpu
+/// `fx_gen2`): the coverage and how it is painted. `style` 0–2 as `paint` (On Original
+/// Image, On Transparent, Reveal Original Image), 3 = under the layer (Vegas' Composite Under).
+#[derive(Clone, Debug)]
+pub struct PaintPlan {
+ pub cov: Coverage,
+ pub color: [f32; 4],
+ pub opacity: f32,
+ pub style: u32,
+}
+
+/// Draw a [`PaintPlan`].
+fn draw_paint(b: &mut Buf, plan: &PaintPlan) {
+ let cov = plan.cov.raster(b.img.width as usize, b.img.height as usize);
+ if plan.style == 3 {
+ let color = plan.color;
+ b.img.data.par_iter_mut().zip(cov.data.par_iter()).for_each(|(px, &c)| {
+ let a = c * color[3];
+ *px = over([color[0] * a, color[1] * a, color[2] * a, a], *px);
+ });
+ } else {
+ paint(&mut b.img, &cov, plan.color, plan.opacity, plan.style);
+ }
+}
+
+/// Generators drawn from a plan that need the layer's own pixels (`b.img`) to build it.
+pub fn plan_reads_pixels(id: &str, ctx: &EffectCtx) -> bool {
+ match id {
+ // Image Contours read the layer itself when no (resolvable) Input Layer is chosen.
+ "ec.generate.vegas" => ctx.params.e("stroke") == 0,
+ "ec.generate.paintbucket" | "ec.generate.eyedropperfill" => true,
+ "ec.generate.advancedlightning" => ctx.params.f("alphaObstacle").clamp(-10.0, 10.0) != 0.0,
+ _ => false,
+ }
+}
+
+/// [`PaintPlan`] of Stroke, Scribble, Vegas or Write-on on `b`'s geometry (`b.img` is read
+/// only when [`plan_reads_pixels`]). `None`: Scribble without a usable mask (the layer is
+/// cleared when it composites On Transparent, else kept).
+pub fn paint_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option {
+ match id {
+ "ec.generate.stroke" => Some(stroke_plan(ctx, b)),
+ "ec.generate.scribble" => scribble_plan(ctx, b),
+ "ec.generate.vegas" => Some(vegas_plan(ctx, b)),
+ "ec.generate.writeon" => Some(write_on_plan(ctx, b)),
+ _ => None,
+ }
+}
+
+/// Scribble's Composite as a `paint` style.
+pub fn scribble_style(ctx: &EffectCtx) -> u32 {
+ match ctx.params.e("composite") {
+ 0 => 0,
+ 2 => 2,
+ _ => 1,
+ }
+}
+
+pub(super) fn scribble(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ match scribble_plan(ctx, &b) {
+ Some(plan) => draw_paint(&mut b, &plan),
+ None if scribble_style(ctx) == 1 => b.img = Image::new(b.img.width, b.img.height),
+ None => {}
+ }
+ b
+}
+
+fn scribble_plan(ctx: &EffectCtx, b: &Buf) -> Option {
+ let pr = ctx.params;
+ let which = pr.e("scribble");
+ let polys: Vec<_> = if which == 0 { mask_px(ctx, b, pr.f("mask").round().max(1.0) as usize).into_iter().collect() } else { all_masks_px(ctx, b) };
+ let polys: Vec<_> = polys.into_iter().filter(|p| p.0.len() >= 3).map(|(p, c, i)| (p, c, i && which == 2)).collect();
+ let style = scribble_style(ctx);
+ if polys.is_empty() {
+ return None;
+ }
+ let sc = b.scale;
+ let fill = pr.e("fillType");
+ let ew = pr.f("edgeOptions/edgeWidth").max(0.1) * sc;
+ let ang = pr.f("angle").to_radians();
+ let d = [ang.cos(), ang.sin()];
+ let n = [-d[1], d[0]];
+ let width = (pr.f("strokeWidth") * sc).max(0.1);
+ let curv = pr.f("strokeOptions/curviness") / 100.0;
+ let curv_var = pr.f("strokeOptions/curvinessVariation") / 100.0;
+ let spacing = (pr.f("strokeOptions/spacing") * sc).max(0.75).max(width * 0.25);
+ let spacing_var = pr.f("strokeOptions/spacingVariation") / 100.0;
+ let overlap = pr.f("strokeOptions/pathOverlap") / 100.0;
+ let overlap_var = pr.f("strokeOptions/pathOverlapVariation") / 100.0;
+ let start = pr.f("start").clamp(0.0, 100.0) / 100.0;
+ let end = pr.f("end").clamp(0.0, 100.0) / 100.0;
+ let sequential = pr.b("fillPathsSequentially");
+ let wiggle = pr.e("wiggleType");
+ let wps = pr.f("wigglesPerSecond").max(0.0);
+ let seed = pr.f("randomSeed") as i64 as u32 ^ ctx.seed;
+ let (step, frac) = match wiggle {
+ 0 => (0u32, 0.0f32),
+ 1 => ((ctx.time * wps).floor().max(0.0) as u32, 0.0),
+ _ => {
+ let u = (ctx.time * wps).max(0.0);
+ (u.floor() as u32, smoothstep(0.0, 1.0, u.fract() as f32))
+ }
+ };
+ let rnd = |i: u32, k: u32| {
+ let a = hash1(i, k.wrapping_mul(31).wrapping_add(step.wrapping_mul(7919)), seed) * 2.0 - 1.0;
+ if frac > 0.0 {
+ let c = hash1(i, k.wrapping_mul(31).wrapping_add((step + 1).wrapping_mul(7919)), seed) * 2.0 - 1.0;
+ a + (c - a) * frac
+ } else {
+ a
+ }
+ };
+ let groups: Vec, bool, bool)>> =
+ if which == 0 || sequential { vec![polys.clone()] } else { polys.iter().map(|p| vec![p.clone()]).collect() };
+ // Per group a zig-zag polyline (in buffer px).
+ let mut lines: Vec>> = Vec::new();
+ let mut runs = Vec::new();
+ for (gi, g) in groups.iter().enumerate() {
+ let mut nmin = f64::INFINITY;
+ let mut nmax = f64::NEG_INFINITY;
+ for (pts, _, _) in g {
+ for q in pts {
+ let v = q[0] * n[0] + q[1] * n[1];
+ nmin = nmin.min(v);
+ nmax = nmax.max(v);
+ }
+ }
+ nmin -= ew;
+ nmax += ew;
+ // Chains of zig-zags: each run joins the nearest chain that ended on the previous
+ // scan line (so separate regions get separate strokes).
+ let mut chains: Vec<(Vec<[f64; 2]>, u32)> = Vec::new();
+ let mut s = nmin + spacing * 0.5;
+ let mut li = 0u32;
+ let reach = spacing * 3.0 + ew;
+ while s < nmax && li < 20_000 {
+ scan_runs(g, fill, ew, d, n, s, &mut runs);
+ for (ri, &(a, bb)) in runs.iter().enumerate() {
+ let k = (gi as u32) << 20 | ri as u32;
+ let ov = spacing * (overlap + overlap_var * rnd(li, k * 4) as f64 * 0.5).max(-0.45);
+ let ov2 = spacing * (overlap + overlap_var * rnd(li, k * 4 + 1) as f64 * 0.5).max(-0.45);
+ let (a, bb) = (a - ov, bb + ov2);
+ if bb <= a {
+ continue;
+ }
+ let at = |t: f64| [d[0] * t + n[0] * s, d[1] * t + n[1] * s];
+ let (pa, pb) = (at(a), at(bb));
+ let dist = |p: [f64; 2], q: [f64; 2]| ((p[0] - q[0]).powi(2) + (p[1] - q[1]).powi(2)).sqrt();
+ let best = chains
+ .iter()
+ .enumerate()
+ .filter(|(_, c)| li > 0 && c.1 == li - 1)
+ .map(|(i, c)| {
+ let last = *c.0.last().unwrap_or(&pa);
+ (i, dist(last, pa).min(dist(last, pb)))
+ })
+ .filter(|&(_, dd)| dd < reach)
+ .min_by(|x, y| x.1.total_cmp(&y.1));
+ match best {
+ Some((ci, _)) => {
+ let last = *chains[ci].0.last().unwrap_or(&pa);
+ let (p0, p1, dir) = if dist(last, pa) <= dist(last, pb) { (pa, pb, -1.0) } else { (pb, pa, 1.0) };
+ // Curved turn: an extra point pushed past the edge.
+ let c = (curv + curv_var * rnd(li, k * 4 + 2) as f64 * 0.5).max(0.0);
+ let mid = [(last[0] + p0[0]) * 0.5 + d[0] * dir * c * spacing, (last[1] + p0[1]) * 0.5 + d[1] * dir * c * spacing];
+ let ch = &mut chains[ci];
+ ch.0.extend([mid, p0, p1]);
+ ch.1 = li;
+ }
+ None => chains.push((vec![pa, pb], li)),
+ }
+ }
+ s += spacing * (1.0 + spacing_var * rnd(li, 3) as f64 * 0.5).max(0.25);
+ li += 1;
+ }
+ lines.push(chains.into_iter().map(|(z, _)| if curv > 0.0 { chaikin(&z, 2) } else { z }).collect());
+ }
+ let r = width * 0.5;
+ // Start / End Apply To: all of a mask's strokes as one path, or each stroke on its own.
+ let each = pr.e("startEndApplyTo") == 1;
+ let mut parts: Vec> = Vec::new();
+ for group in &lines {
+ let lens: Vec = group.iter().map(|l| poly_length(l, false)).collect();
+ let total: f64 = lens.iter().sum();
+ let (g0, g1) = (total * start, total * end);
+ let mut acc = 0.0;
+ for (l, len) in group.iter().zip(lens) {
+ let part =
+ if each { trim_poly(l, false, len * start, len * end) } else { trim_poly(l, false, (g0 - acc).clamp(0.0, len), (g1 - acc).clamp(0.0, len)) };
+ acc += len;
+ parts.push(part);
+ }
+ }
+ let cap = pr.e("edgeOptions/endCap");
+ let join = pr.e("edgeOptions/join");
+ let cov = if cap == 0 && join == 0 {
+ let mut segs = Vec::new();
+ for part in &parts {
+ poly_segs(part, false, r, 1.0, &mut segs);
+ }
+ Coverage::Segs { segs, hardness: 0.9 }
+ } else {
+ Coverage::Convex(stroke_outline(&parts, r, cap, join, pr.f("edgeOptions/miterLimit").max(1.0)))
+ };
+ Some(PaintPlan { cov, color: pr.color("color"), opacity: (pr.f("opacity") / 100.0) as f32, style })
+}
+
+// ---------------------------------------------------------------- Stroke
+
+pub(super) fn stroke(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ let plan = stroke_plan(ctx, &b);
+ draw_paint(&mut b, &plan);
+ b
+}
+
+fn stroke_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {
+ let pr = ctx.params;
+ let all = pr.b("allMasks");
+ let polys: Vec<_> = if all { all_masks_px(ctx, b) } else { mask_px(ctx, b, pr.f("path").round() as usize).into_iter().collect() };
+ let style = pr.e("paintStyle");
+ let size = (pr.f("brushSize") * b.scale).max(0.1);
+ let r = size * 0.5;
+ let hard = pr.f("brushHardness") / 100.0;
+ let start = pr.f("start").clamp(0.0, 100.0) / 100.0;
+ let end = pr.f("end").clamp(0.0, 100.0) / 100.0;
+ let spacing = pr.f("spacing") / 100.0;
+ let sequential = pr.b("strokeSequentially");
+ let lens: Vec = polys.iter().map(|(p, c, _)| poly_length(p, *c)).collect();
+ let total: f64 = lens.iter().sum();
+ let mut segs = Vec::new();
+ let mut acc = 0.0;
+ for ((pts, closed, _), &len) in polys.iter().zip(&lens) {
+ let (s0, s1) = if all && sequential {
+ let (g0, g1) = (total * start, total * end);
+ ((g0 - acc).clamp(0.0, len), (g1 - acc).clamp(0.0, len))
+ } else {
+ (len * start, len * end)
+ };
+ acc += len;
+ if s1 <= s0 {
+ continue;
+ }
+ if spacing <= 0.5 {
+ let part = trim_poly(pts, *closed, s0, s1);
+ poly_segs(&part, false, r, 1.0, &mut segs);
+ } else {
+ let step = (size * spacing).max(0.5);
+ let mut s = s0;
+ while s <= s1 + 1e-9 && segs.len() < 200_000 {
+ let (q, _) = crate::util::poly_point_at(pts, *closed, s);
+ segs.push(Seg { a: q, b: q, r, v: 1.0 });
+ s += step;
+ }
+ }
+ }
+ PaintPlan { cov: Coverage::Segs { segs, hardness: hard }, color: pr.color("color"), opacity: (pr.f("opacity") / 100.0) as f32, style }
+}
+
+// ---------------------------------------------------------------- Vegas
+
+/// Marching-squares iso-contours of `pl` at `thr`, chained into polylines (closed flag).
+pub(super) fn contours(pl: &Plane, thr: f32) -> Vec<(Vec<[f64; 2]>, bool)> {
+ use std::collections::HashMap;
+ let (w, h) = (pl.w, pl.h);
+ if w < 2 || h < 2 {
+ return Vec::new();
+ }
+ // Edge key: horizontal edge (x,y)-(x+1,y) = 2*(y*w+x), vertical (x,y)-(x,y+1) = 2*(y*w+x)+1.
+ let hk = |x: usize, y: usize| 2 * (y * w + x) as u64;
+ let vk = |x: usize, y: usize| 2 * (y * w + x) as u64 + 1;
+ let mut pos: HashMap = HashMap::new();
+ let mut adj: HashMap> = HashMap::new();
+ let v = |x: usize, y: usize| pl.data[y * w + x];
+ let interp = |a: f32, b: f32| if (b - a).abs() > 1e-9 { ((thr - a) / (b - a)).clamp(0.0, 1.0) as f64 } else { 0.5 };
+ for y in 0..h - 1 {
+ for x in 0..w - 1 {
+ let (a, bb, c, d) = (v(x, y), v(x + 1, y), v(x + 1, y + 1), v(x, y + 1));
+ let idx = (a > thr) as u8 | ((bb > thr) as u8) << 1 | ((c > thr) as u8) << 2 | ((d > thr) as u8) << 3;
+ if idx == 0 || idx == 15 {
+ continue;
+ }
+ // Edge points (pixel centres at +0.5).
+ let top = (hk(x, y), [x as f64 + 0.5 + interp(a, bb), y as f64 + 0.5]);
+ let right = (vk(x + 1, y), [x as f64 + 1.5, y as f64 + 0.5 + interp(bb, c)]);
+ let bottom = (hk(x, y + 1), [x as f64 + 0.5 + interp(d, c), y as f64 + 1.5]);
+ let left = (vk(x, y), [x as f64 + 0.5, y as f64 + 0.5 + interp(a, d)]);
+ let pairs: &[(usize, usize)] = match idx {
+ 1 | 14 => &[(3, 0)],
+ 2 | 13 => &[(0, 1)],
+ 3 | 12 => &[(3, 1)],
+ 4 | 11 => &[(1, 2)],
+ 5 => &[(3, 0), (1, 2)],
+ 6 | 9 => &[(0, 2)],
+ 7 | 8 => &[(3, 2)],
+ 10 => &[(0, 1), (2, 3)],
+ _ => &[],
+ };
+ let e = [top, right, bottom, left];
+ for &(i, j) in pairs {
+ pos.insert(e[i].0, e[i].1);
+ pos.insert(e[j].0, e[j].1);
+ adj.entry(e[i].0).or_default().push(e[j].0);
+ adj.entry(e[j].0).or_default().push(e[i].0);
+ }
+ }
+ }
+ let mut keys: Vec = adj.keys().copied().collect();
+ keys.sort_unstable();
+ // Start open chains at endpoints (degree 1) first, then closed loops.
+ keys.sort_by_key(|k| adj[k].len() != 1);
+ let mut used: std::collections::HashSet<(u64, u64)> = std::collections::HashSet::new();
+ let mut out = Vec::new();
+ for &k0 in &keys {
+ for &first in &adj[&k0] {
+ if used.contains(&(k0.min(first), k0.max(first))) {
+ continue;
+ }
+ let mut chain = vec![pos[&k0]];
+ let (mut prev, mut cur) = (k0, first);
+ used.insert((prev.min(cur), prev.max(cur)));
+ let mut closed = false;
+ loop {
+ chain.push(pos[&cur]);
+ if cur == k0 {
+ closed = true;
+ chain.pop();
+ break;
+ }
+ let next = adj[&cur].iter().copied().find(|&n| n != prev && !used.contains(&(cur.min(n), cur.max(n))));
+ match next {
+ Some(n) => {
+ used.insert((cur.min(n), cur.max(n)));
+ prev = cur;
+ cur = n;
+ }
+ None => break,
+ }
+ }
+ if chain.len() >= 2 {
+ out.push((chain, closed));
+ }
+ }
+ }
+ out
+}
+
+pub(super) fn vegas(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ let plan = vegas_plan(ctx, &b);
+ draw_paint(&mut b, &plan);
+ b
+}
+
+fn vegas_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {
+ let pr = ctx.params;
+ let (w, h) = (b.img.width as usize, b.img.height as usize);
+ let sc = b.scale;
+ let paths: Vec<(Vec<[f64; 2]>, bool)> = if pr.e("stroke") == 1 {
+ mask_px(ctx, b, pr.f("path").round() as usize).map(|(p, c, _)| vec![(p, c)]).unwrap_or_default()
+ } else {
+ let src = layer_or_self(ctx, b, "inputLayer", true, pr.e("ifLayerSizesDiffer") == 1);
+ let ch = pr.e("channel");
+ let inv = pr.b("invertInput");
+ let mut pl = Plane::from_image(&src, |px| {
+ let (c, a) = unpremul(px);
+ let v = match ch {
+ 1 => c[0],
+ 2 => c[1],
+ 3 => c[2],
+ 4 => a,
+ _ => luminance(c[0], c[1], c[2]) * a,
+ };
+ if inv { 1.0 - v } else { v }
+ });
+ let blur = pr.f("preBlur") * sc;
+ if blur > 0.05 {
+ pl = gauss_plane(&pl, blur, blur);
+ }
+ let mut cs = contours(&pl, (pr.f("threshold") / 100.0) as f32);
+ // Simplify by tolerance (drop points closer than tol × size).
+ let tol = pr.f("tolerance").max(0.0) * (w.max(h) as f64) * 0.1;
+ if tol > 0.0 {
+ for (c, _) in cs.iter_mut() {
+ let mut keep: Vec<[f64; 2]> = Vec::with_capacity(c.len());
+ for &q in c.iter() {
+ if keep.last().is_none_or(|l: &[f64; 2]| ((l[0] - q[0]).powi(2) + (l[1] - q[1]).powi(2)).sqrt() >= tol) {
+ keep.push(q);
+ }
+ }
+ *c = keep;
+ }
+ }
+ cs.sort_by(|a, b| poly_length(&b.0, b.1).total_cmp(&poly_length(&a.0, a.1)));
+ if pr.e("renderMode") == 1 {
+ let sel = (pr.f("selectedContour").round().max(1.0) as usize) - 1;
+ cs.into_iter().skip(sel).take(1).collect()
+ } else {
+ cs
+ }
+ };
+ let nseg = pr.f("segments").round().clamp(1.0, 1000.0) as usize;
+ // Shorter Contours Have Fewer Segments: segment count scales with contour length.
+ let fewer = pr.e("stroke") == 0 && pr.e("shorterContoursHave") == 1;
+ let longest = paths.iter().map(|(p, c)| poly_length(p, *c)).fold(0.0, f64::max);
+ let seg_len = pr.f("length").clamp(0.0, 1.0);
+ let bunched = pr.e("segmentDistribution") == 0;
+ let rot = pr.f("rotation") / 360.0;
+ let random_phase = pr.b("randomPhase");
+ let seed = pr.f("randomSeed") as i64 as u32 ^ ctx.seed;
+ let width = (pr.f("width") * sc).max(0.1);
+ let hard = pr.f("hardness").clamp(0.0, 1.0);
+ let (o0, om, o1, mp) = (pr.f("startOpacity") as f32, pr.f("midpointOpacity") as f32, pr.f("endOpacity") as f32, pr.f("midpointPosition").clamp(0.01, 0.99));
+ let mut segs = Vec::new();
+ for (ci, (pts, closed)) in paths.iter().enumerate() {
+ let len = poly_length(pts, *closed);
+ if len <= 0.0 {
+ continue;
+ }
+ let phase = rot + if random_phase { hash1(ci as u32, 1, seed) as f64 } else { 0.0 };
+ let nseg = if fewer && longest > 0.0 { ((nseg as f64 * len / longest).round() as usize).max(1) } else { nseg };
+ let each = len / nseg as f64 * seg_len;
+ for i in 0..nseg {
+ let base = if bunched { (i as f64 + (hash1(ci as u32, i as u32 + 7, seed) as f64 - 0.5) * 0.8) / nseg as f64 } else { i as f64 / nseg as f64 };
+ let s0 = (base + phase).rem_euclid(1.0) * len;
+ // Sub-sample the segment so opacity can ramp along it.
+ let sub = 12usize;
+ let mut prev: Option<[f64; 2]> = None;
+ for k in 0..=sub {
+ let f = k as f64 / sub as f64;
+ let mut s = s0 + each * f;
+ if *closed {
+ s = s.rem_euclid(len);
+ } else if s > len {
+ break;
+ }
+ let (q, _) = crate::util::poly_point_at(pts, *closed, s);
+ let op = if f < mp { o0 + (om - o0) * (f / mp) as f32 } else { om + (o1 - om) * ((f - mp) / (1.0 - mp)) as f32 };
+ if let Some(pv) = prev
+ && ((pv[0] - q[0]).powi(2) + (pv[1] - q[1]).powi(2)) < (each * 0.5).powi(2) + 4.0
+ {
+ segs.push(Seg { a: pv, b: q, r: width * 0.5, v: op.clamp(0.0, 1.0) });
+ }
+ prev = Some(q);
+ }
+ }
+ }
+ let style = match pr.e("blendMode") {
+ 1 => 0,
+ 2 => 3,
+ 3 => 2,
+ _ => 1,
+ };
+ PaintPlan { cov: Coverage::Segs { segs, hardness: hard }, color: pr.color("color"), opacity: 1.0, style }
+}
+
+// ---------------------------------------------------------------- Write-on / Glue Gun
+
+/// Write-on draws a stroke along the animated Brush Position, as in After Effects: a dab every
+/// Brush Spacing seconds from the layer's start up to now, each one lasting Stroke Length
+/// seconds (0: for ever). The dabs' positions come from the host's parameters at their times;
+/// with Paint Time Properties ▸ Opacity or Brush Time Properties ▸ Size each dab keeps its own
+/// opacity or size, else the current ones apply to every dab. (Colour and hardness are one per
+/// stroke: the current ones.) Without a host (or dabs) the current dab draws. Deterministic.
+pub(super) fn write_on(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ let plan = write_on_plan(ctx, &b);
+ draw_paint(&mut b, &plan);
+ b
+}
+
+/// The most dabs one Write-on frame draws; longer strokes lay them further apart, joined.
+const WRITE_ON_MAX_DABS: i64 = 4096;
+
+fn write_on_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {
+ let pr = ctx.params;
+ let own_opacity = pr.e("paintTimeProperties") == 1;
+ let own_size = matches!(pr.e("brushTimeProperties"), 1 | 3);
+ let opacity = |p: &Params| (p.f("brushOpacity") / 100.0).clamp(0.0, 1.0) as f32;
+ let radius = |p: &Params| (p.f("brushSize") * b.scale * 0.5).max(0.05);
+ let dab = |p: &Params| {
+ let q = b.to_px(p.v2("brushPosition"));
+ ([q.0, q.1], radius(if own_size { p } else { pr }), if own_opacity { opacity(p) } else { 1.0 })
+ };
+ let mut segs = vec![];
+ let t = ctx.time;
+ let spacing = pr.f("brushSpacing").max(0.001);
+ let life = pr.f("strokeLength").max(0.0);
+ if let Some(host) = ctx.env.host
+ && t.is_finite()
+ && t >= 0.0
+ {
+ let start = if life > 0.0 { (t - life).max(0.0) } else { 0.0 };
+ let k0 = (start / spacing - 1e-9).ceil().max(0.0) as i64;
+ let k1 = (t / spacing + 1e-9).floor().max(0.0) as i64;
+ let n = k1.saturating_sub(k0).saturating_add(1);
+ let stride = (n / WRITE_ON_MAX_DABS).saturating_add(1).max(1);
+ let mut prev: Option<[f64; 2]> = None;
+ let mut k = k0;
+ while k <= k1 {
+ let tk = k as f64 * spacing;
+ let at = if (tk - t).abs() < 1e-9 { Some(dab(pr)) } else { host.params_at(tk).map(|p| dab(&p)) };
+ if let Some((q, r, v)) = at {
+ // Dabs laid further apart than the brush spacing are joined into a line.
+ let a = if stride > 1 { prev.unwrap_or(q) } else { q };
+ segs.push(Seg { a, b: q, r, v });
+ prev = Some(q);
+ }
+ k = k.saturating_add(stride);
+ }
+ }
+ if segs.is_empty() {
+ let (q, r, v) = dab(pr);
+ segs.push(Seg { a: q, b: q, r, v });
+ }
+ PaintPlan {
+ cov: Coverage::Segs { segs, hardness: pr.f("brushHardness") / 100.0 },
+ color: pr.color("color"),
+ opacity: if own_opacity { 1.0 } else { opacity(pr) },
+ style: pr.e("paintStyle"),
+ }
+}
diff --git a/crates/effects/src/generate3/raster.rs b/crates/effects/src/generate3/raster.rs
new file mode 100644
index 000000000..f9acd88a3
--- /dev/null
+++ b/crates/effects/src/generate3/raster.rs
@@ -0,0 +1,369 @@
+use super::*;
+
+// ---------------------------------------------------------------- shared rasterisation
+
+/// A round-capped line segment in buffer pixels with radius `r` and intensity `v`.
+#[derive(Clone, Copy, Debug)]
+pub struct Seg {
+ pub a: [f64; 2],
+ pub b: [f64; 2],
+ pub r: f64,
+ pub v: f32,
+}
+
+/// Rasterise segments into a coverage plane (max-combined). `hardness` (0..1) is the fraction
+/// of the radius that is fully opaque; the rest falls off smoothly.
+pub(crate) fn raster_segs(w: usize, h: usize, segs: &[Seg], hardness: f64) -> Plane {
+ let mut out = Plane::new(w, h);
+ if w == 0 || h == 0 || segs.is_empty() {
+ return out;
+ }
+ let mut buckets: Vec> = vec![Vec::new(); h];
+ for (i, s) in segs.iter().enumerate() {
+ let pad = s.r + 1.0;
+ let y0 = (s.a[1].min(s.b[1]) - pad).floor().max(0.0) as usize;
+ let y1 = (s.a[1].max(s.b[1]) + pad).ceil().min(h as f64);
+ if y1 <= 0.0 || y0 >= h {
+ continue;
+ }
+ for row in buckets.iter_mut().take(y1 as usize).skip(y0) {
+ row.push(i as u32);
+ }
+ }
+ let hard = hardness.clamp(0.0, 1.0);
+ out.data.par_chunks_mut(w).enumerate().for_each(|(y, row)| {
+ let py = y as f64 + 0.5;
+ for &i in &buckets[y] {
+ let s = segs[i as usize];
+ let pad = s.r + 1.0;
+ let x0 = (s.a[0].min(s.b[0]) - pad).floor().max(0.0) as usize;
+ let x1 = ((s.a[0].max(s.b[0]) + pad).ceil().max(0.0) as usize).min(w);
+ let (dx, dy) = (s.b[0] - s.a[0], s.b[1] - s.a[1]);
+ let l2 = dx * dx + dy * dy;
+ let inner = s.r * hard - 0.5;
+ let outer = s.r + 0.5;
+ for (x, o) in row.iter_mut().enumerate().take(x1).skip(x0) {
+ let px = x as f64 + 0.5;
+ let t = if l2 > 1e-12 { (((px - s.a[0]) * dx + (py - s.a[1]) * dy) / l2).clamp(0.0, 1.0) } else { 0.0 };
+ let d = ((px - s.a[0] - dx * t).powi(2) + (py - s.a[1] - dy * t).powi(2)).sqrt();
+ if d >= outer {
+ continue;
+ }
+ let c = if d <= inner { 1.0 } else { 1.0 - smoothstep(inner as f32, outer as f32, d as f32) } * s.v;
+ if c > *o {
+ *o = c;
+ }
+ }
+ }
+ });
+ out
+}
+
+/// Segments along a polyline (buffer px).
+pub fn poly_segs(pts: &[[f64; 2]], closed: bool, r: f64, v: f32, out: &mut Vec) {
+ let n = pts.len();
+ if n == 1 {
+ out.push(Seg { a: pts[0], b: pts[0], r, v });
+ }
+ if n < 2 {
+ return;
+ }
+ let segs = if closed { n } else { n - 1 };
+ for i in 0..segs {
+ out.push(Seg { a: pts[i], b: pts[(i + 1) % n], r, v });
+ }
+}
+
+/// Portion `[s0, s1]` (arc length) of a polyline.
+pub(crate) fn trim_poly(pts: &[[f64; 2]], closed: bool, s0: f64, s1: f64) -> Vec<[f64; 2]> {
+ let n = pts.len();
+ let mut out = Vec::new();
+ if n < 2 || s1 <= s0 {
+ return out;
+ }
+ let segs = if closed { n } else { n - 1 };
+ let mut acc = 0.0;
+ for i in 0..segs {
+ let (a, b) = (pts[i], pts[(i + 1) % n]);
+ let l = ((b[0] - a[0]).powi(2) + (b[1] - a[1]).powi(2)).sqrt();
+ let (e0, e1) = (acc, acc + l);
+ acc = e1;
+ if e1 < s0 || e0 > s1 || l <= 0.0 {
+ continue;
+ }
+ let at = |s: f64| {
+ let t = ((s - e0) / l).clamp(0.0, 1.0);
+ [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]
+ };
+ let p0 = at(s0.max(e0));
+ if out.last() != Some(&p0) {
+ out.push(p0);
+ }
+ out.push(at(s1.min(e1)));
+ }
+ out
+}
+
+#[inline]
+pub(super) fn over(dst: Px, src: Px) -> Px {
+ let k = 1.0 - src[3];
+ [src[0] + dst[0] * k, src[1] + dst[1] * k, src[2] + dst[2] * k, src[3] + dst[3] * k]
+}
+
+/// Mask `idx` (1-based; 0 = none) mapped to buffer pixels.
+pub(crate) fn mask_px(ctx: &EffectCtx, b: &Buf, idx: usize) -> Option<(Vec<[f64; 2]>, bool, bool)> {
+ let m = ctx.env.masks.get(idx.checked_sub(1)?)?;
+ if m.points.is_empty() {
+ return None;
+ }
+ Some((m.points.iter().map(|&q| [q[0] * b.scale + b.offset[0], q[1] * b.scale + b.offset[1]]).collect(), m.closed, m.inverted))
+}
+
+/// All masks mapped to buffer pixels.
+pub(super) fn all_masks_px(ctx: &EffectCtx, b: &Buf) -> Vec<(Vec<[f64; 2]>, bool, bool)> {
+ (1..=ctx.env.masks.len()).filter_map(|i| mask_px(ctx, b, i)).collect()
+}
+
+/// Chaikin corner cutting (open polyline, endpoints kept).
+pub(super) fn chaikin(pts: &[[f64; 2]], iters: usize) -> Vec<[f64; 2]> {
+ let mut cur = pts.to_vec();
+ for _ in 0..iters {
+ if cur.len() < 3 {
+ return cur;
+ }
+ let mut nx = Vec::with_capacity(cur.len() * 2);
+ nx.push(cur[0]);
+ for w in cur.windows(2) {
+ let (a, b) = (w[0], w[1]);
+ nx.push([a[0] * 0.75 + b[0] * 0.25, a[1] * 0.75 + b[1] * 0.25]);
+ nx.push([a[0] * 0.25 + b[0] * 0.75, a[1] * 0.25 + b[1] * 0.75]);
+ }
+ nx.push(*cur.last().unwrap_or(&[0.0; 2]));
+ cur = nx;
+ }
+ cur
+}
+
+// ---------------------------------------------------------------- Scribble
+
+/// Scan runs (start, end along direction `d`) of the fill region on the line `n·p = s`.
+#[allow(clippy::too_many_arguments)]
+pub(super) fn scan_runs(polys: &[(Vec<[f64; 2]>, bool, bool)], fill: u32, ew: f64, d: [f64; 2], n: [f64; 2], s: f64, out: &mut Vec<(f64, f64)>) {
+ out.clear();
+ for (pts, _closed, inverted) in polys {
+ let m = pts.len();
+ if m < 2 {
+ continue;
+ }
+ // Crossings: (t along d, |sin| of crossing angle).
+ let mut xs: Vec<(f64, f64)> = Vec::new();
+ for i in 0..m {
+ let (a, b) = (pts[i], pts[(i + 1) % m]);
+ let (na, nb) = (a[0] * n[0] + a[1] * n[1] - s, b[0] * n[0] + b[1] * n[1] - s);
+ if (na > 0.0) == (nb > 0.0) {
+ continue;
+ }
+ let t = na / (na - nb);
+ let q = [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+ let (ex, ey) = (b[0] - a[0], b[1] - a[1]);
+ let el = (ex * ex + ey * ey).sqrt().max(1e-9);
+ let sin = ((ex * n[0] + ey * n[1]) / el).abs().max(0.2);
+ xs.push((q[0] * d[0] + q[1] * d[1], sin));
+ }
+ xs.sort_by(|a, b| a.0.total_cmp(&b.0));
+ // Signed area decides which side is "left".
+ let area: f64 = (0..m).map(|i| pts[i][0] * pts[(i + 1) % m][1] - pts[(i + 1) % m][0] * pts[i][1]).sum();
+ let left_is_inside = area < 0.0;
+ let mode = match fill {
+ 4 => {
+ if left_is_inside {
+ 2
+ } else {
+ 3
+ }
+ }
+ 5 => {
+ if left_is_inside {
+ 3
+ } else {
+ 2
+ }
+ }
+ f => f,
+ };
+ let mode = if *inverted && mode == 0 { 6 } else { mode };
+ for (k, &(t, sin)) in xs.iter().enumerate() {
+ let entering = k % 2 == 0;
+ let l = ew / sin;
+ match mode {
+ 0 if entering && k + 1 < xs.len() => {
+ out.push((t, xs[k + 1].0));
+ }
+ 1 => out.push((t - l * 0.5, t + l * 0.5)),
+ 2 => out.push(if entering { (t, t + l) } else { (t - l, t) }),
+ 3 => out.push(if entering { (t - l, t) } else { (t, t + l) }),
+ _ => {}
+ }
+ }
+ if mode == 6 {
+ // Inverted Inside: outside of the polygon within the bounds.
+ let lo = pts.iter().map(|q| q[0] * d[0] + q[1] * d[1]).fold(f64::INFINITY, f64::min) - ew;
+ let hi = pts.iter().map(|q| q[0] * d[0] + q[1] * d[1]).fold(f64::NEG_INFINITY, f64::max) + ew;
+ let mut cur = lo;
+ for pair in xs.chunks(2) {
+ out.push((cur, pair[0].0));
+ cur = pair.get(1).map(|v| v.0).unwrap_or(hi);
+ }
+ out.push((cur, hi));
+ }
+ }
+ out.sort_by(|a, b| a.0.total_cmp(&b.0));
+ // Merge overlaps.
+ let mut merged: Vec<(f64, f64)> = Vec::with_capacity(out.len());
+ for &(a, b) in out.iter() {
+ if let Some(last) = merged.last_mut()
+ && a <= last.1
+ {
+ last.1 = last.1.max(b);
+ continue;
+ }
+ merged.push((a, b));
+ }
+ *out = merged;
+}
+
+/// End Cap and Join options (Scribble's Edge Options).
+pub(super) const END_CAPS: [&str; 3] = ["Round", "Butt", "Projecting"];
+
+pub(super) const JOINS: [&str; 3] = ["Round", "Miter", "Bevel"];
+
+/// Convex polygons whose union is the stroke of the polylines `lines` with half width `r`:
+/// one quad per segment, plus the joins (Round discs, Miter wedges up to `miter_limit` × the
+/// half width, Bevel triangles) and the caps (Round discs, Butt none, Projecting square ends).
+pub(crate) fn stroke_outline(lines: &[Vec<[f64; 2]>], r: f64, cap: u32, join: u32, miter_limit: f64) -> Vec> {
+ let disc = |c: [f64; 2]| -> Vec<[f64; 2]> {
+ (0..16).map(|k| (k as f64 / 16.0 * std::f64::consts::TAU).sin_cos()).map(|(s, co)| [c[0] + co * r, c[1] + s * r]).collect()
+ };
+ let mut out = Vec::new();
+ for l in lines {
+ let pts: Vec<[f64; 2]> = l.iter().copied().fold(Vec::new(), |mut v, p| {
+ if v.last().is_none_or(|q: &[f64; 2]| (q[0] - p[0]).hypot(q[1] - p[1]) > 1e-9) {
+ v.push(p);
+ }
+ v
+ });
+ if pts.len() < 2 {
+ if let (Some(p), 0) = (pts.first(), cap) {
+ out.push(disc(*p));
+ }
+ continue;
+ }
+ let dir = |a: [f64; 2], b: [f64; 2]| {
+ let (dx, dy) = (b[0] - a[0], b[1] - a[1]);
+ let l = dx.hypot(dy).max(1e-12);
+ [dx / l, dy / l]
+ };
+ let n = pts.len();
+ for k in 0..n - 1 {
+ let (mut a, mut b) = (pts[k], pts[k + 1]);
+ let d = dir(a, b);
+ // Projecting caps extend the end segments by the half width.
+ if cap == 2 && k == 0 {
+ a = [a[0] - d[0] * r, a[1] - d[1] * r];
+ }
+ if cap == 2 && k == n - 2 {
+ b = [b[0] + d[0] * r, b[1] + d[1] * r];
+ }
+ let nn = [-d[1] * r, d[0] * r];
+ out.push(vec![[a[0] + nn[0], a[1] + nn[1]], [b[0] + nn[0], b[1] + nn[1]], [b[0] - nn[0], b[1] - nn[1]], [a[0] - nn[0], a[1] - nn[1]]]);
+ }
+ // Joins.
+ for k in 1..n - 1 {
+ let (p, d0, d1) = (pts[k], dir(pts[k - 1], pts[k]), dir(pts[k], pts[k + 1]));
+ let cross = d0[0] * d1[1] - d0[1] * d1[0];
+ if cross.abs() < 1e-9 && d0[0] * d1[0] + d0[1] * d1[1] > 0.0 {
+ continue;
+ }
+ if join == 0 {
+ out.push(disc(p));
+ continue;
+ }
+ // The outer side of the turn.
+ let s = if cross > 0.0 { -1.0 } else { 1.0 };
+ let o0 = [p[0] - d0[1] * r * s, p[1] + d0[0] * r * s];
+ let o1 = [p[0] - d1[1] * r * s, p[1] + d1[0] * r * s];
+ let bevel = vec![p, o0, o1];
+ if join == 1 {
+ // Miter point: where the two offset edges meet.
+ let bis = [d0[0] - d1[0], d0[1] - d1[1]];
+ let bl = bis[0].hypot(bis[1]);
+ let cos_half = ((1.0 + d0[0] * d1[0] + d0[1] * d1[1]) * 0.5).max(0.0).sqrt();
+ let len = if cos_half > 1e-6 { r / cos_half } else { f64::INFINITY };
+ if bl > 1e-9 && len <= miter_limit * r {
+ let m = [p[0] + (o0[0] + o1[0] - 2.0 * p[0]) * 0.5, p[1] + (o0[1] + o1[1] - 2.0 * p[1]) * 0.5];
+ let ml = (m[0] - p[0]).hypot(m[1] - p[1]).max(1e-12);
+ let tip = [p[0] + (m[0] - p[0]) / ml * len, p[1] + (m[1] - p[1]) / ml * len];
+ out.push(vec![p, o0, tip, o1]);
+ continue;
+ }
+ }
+ out.push(bevel);
+ }
+ if cap == 0 {
+ out.push(disc(pts[0]));
+ out.push(disc(pts[n - 1]));
+ }
+ }
+ out
+}
+
+/// Coverage (union, 4×4 samples per pixel) of convex polygons on a `w`×`h` grid.
+pub(crate) fn raster_convex(w: usize, h: usize, polys: &[Vec<[f64; 2]>]) -> Plane {
+ let mut out = Plane::new(w, h);
+ let inside = |poly: &[[f64; 2]], x: f64, y: f64| {
+ let n = poly.len();
+ let mut sign = 0.0;
+ for i in 0..n {
+ let (a, b) = (poly[i], poly[(i + 1) % n]);
+ let c = (b[0] - a[0]) * (y - a[1]) - (b[1] - a[1]) * (x - a[0]);
+ if c.abs() < 1e-12 {
+ continue;
+ }
+ if sign == 0.0 {
+ sign = c.signum();
+ } else if c.signum() != sign {
+ return false;
+ }
+ }
+ true
+ };
+ for poly in polys {
+ if poly.len() < 3 {
+ continue;
+ }
+ let (mut x0, mut y0, mut x1, mut y1) = (f64::INFINITY, f64::INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY);
+ for p in poly {
+ x0 = x0.min(p[0]);
+ y0 = y0.min(p[1]);
+ x1 = x1.max(p[0]);
+ y1 = y1.max(p[1]);
+ }
+ let (xa, xb) = (x0.floor().max(0.0) as usize, (x1.ceil().max(0.0) as usize).min(w));
+ let (ya, yb) = (y0.floor().max(0.0) as usize, (y1.ceil().max(0.0) as usize).min(h));
+ for y in ya..yb {
+ for x in xa..xb {
+ let mut hit = 0;
+ for sy in 0..4 {
+ for sx in 0..4 {
+ if inside(poly, x as f64 + (sx as f64 + 0.5) / 4.0, y as f64 + (sy as f64 + 0.5) / 4.0) {
+ hit += 1;
+ }
+ }
+ }
+ let v = &mut out.data[y * w + x];
+ *v = v.max(hit as f32 / 16.0);
+ }
+ }
+ }
+ out
+}
diff --git a/crates/effects/src/generate3/registry.rs b/crates/effects/src/generate3/registry.rs
new file mode 100644
index 000000000..f7f6b040f
--- /dev/null
+++ b/crates/effects/src/generate3/registry.rs
@@ -0,0 +1,265 @@
+use super::audio::{audio_spectrum, audio_waveform};
+use super::common::{pct, pt, spec};
+use super::fill::{eyedropper_fill, glue_gun, paint_bucket, threads};
+use super::fractal::{FRACTAL_OVERSAMPLE, FRACTAL_PALETTES, FRACTAL_SETS, fractal};
+use super::paths::{scribble, stroke, vegas, write_on};
+use super::raster::{END_CAPS, JOINS};
+use super::*;
+
+// ---------------------------------------------------------------- registry
+
+pub fn specs() -> Vec {
+ let ang = || ParamUi::Angle;
+ let check = |id: &'static str, name: &'static str, v: bool| p(id, name, Value::Bool(v), ParamUi::Checkbox);
+ let paint_style = || popup(&["On Original Image", "On Transparent", "Reveal Original Image"]);
+ let mask_idx = |id: &'static str, name: &'static str, d: f64| p(id, name, num(d), ParamUi::Mask);
+ let display = || popup(&["Digital", "Analog lines", "Analog dots"]);
+ vec![
+ spec(
+ "ec.generate.fractal",
+ "Fractal",
+ vec![
+ p("setChoice", "Set Choice", Value::Enum(0), popup(&FRACTAL_SETS)),
+ p("equation", "Equation", Value::Enum(0), popup(&["z = z^2 + c", "z = z^3 + c", "z = z^4 + c"])),
+ p("mandelbrot/mandelbrotX", "X (Real)", num(-0.74), slider(-2.0, 2.0, -2.0, 2.0, 4)),
+ p("mandelbrot/mandelbrotY", "Y (Imaginary)", num(0.15), slider(-2.0, 2.0, -2.0, 2.0, 4)),
+ p("mandelbrot/mandelbrotMagnification", "Magnification", num(0.0), slider(-5.0, 30.0, -5.0, 30.0, 2)),
+ p("mandelbrot/mandelbrotEscapeLimit", "Escape Limit", num(4.0), slider(1.0, 1000.0, 1.0, 100.0, 1)),
+ p("julia/juliaX", "X (Real)", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
+ p("julia/juliaY", "Y (Imaginary)", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
+ p("julia/juliaMagnification", "Magnification", num(0.0), slider(-5.0, 30.0, -5.0, 30.0, 2)),
+ p("julia/juliaEscapeLimit", "Escape Limit", num(4.0), slider(1.0, 1000.0, 1.0, 100.0, 1)),
+ p("postInversionOffset/postInversionX", "X Offset", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
+ p("postInversionOffset/postInversionY", "Y Offset", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
+ check("fractalColor/overlay", "Overlay", false),
+ check("fractalColor/transparency", "Transparency", false),
+ p("fractalColor/palette", "Palette", Value::Enum(0), popup(&FRACTAL_PALETTES)),
+ p("fractalColor/hue", "Hue", num(0.0), ang()),
+ p("fractalColor/cycleSteps", "Cycle Steps", num(32.0), slider(1.0, 1000.0, 1.0, 256.0, 0)),
+ p("fractalColor/cycleOffset", "Cycle Offset", num(0.0), ang()),
+ check("fractalColor/edgeHighlight", "Edge Highlight", false),
+ p("highQualitySettings/samplingMethod", "Oversample Method", Value::Enum(0), popup(&FRACTAL_OVERSAMPLE)),
+ p("highQualitySettings/samplingFactor", "Oversample Factor", num(2.0), slider(1.0, 9.0, 1.0, 9.0, 0)),
+ ],
+ fractal,
+ ),
+ spec(
+ "ec.generate.scribble",
+ "Scribble",
+ vec![
+ p("scribble", "Scribble", Value::Enum(0), popup(&["Single Mask", "All Masks", "All Masks Using Modes"])),
+ mask_idx("mask", "Mask", 1.0),
+ p("fillType", "Fill Type", Value::Enum(0), popup(&["Inside", "Centered Edge", "Inside Edge", "Outside Edge", "Left Edge", "Right Edge"])),
+ p("edgeOptions/edgeWidth", "Edge Width", num(10.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
+ p("edgeOptions/endCap", "End Cap", Value::Enum(0), popup(&END_CAPS)),
+ p("edgeOptions/join", "Join", Value::Enum(0), popup(&JOINS)),
+ p("edgeOptions/miterLimit", "Miter Limit", num(4.0), slider(1.0, 100.0, 1.0, 20.0, 1)),
+ p("color", "Color", col(1.0, 0.0, 0.0), ParamUi::Color),
+ p("opacity", "Opacity", num(100.0), pct()),
+ p("angle", "Angle", num(45.0), ang()),
+ p("strokeWidth", "Stroke Width", num(2.0), slider(0.1, 50.0, 0.1, 50.0, 1)),
+ p("strokeOptions/curviness", "Curviness", num(50.0), pct()),
+ p("strokeOptions/curvinessVariation", "Curviness Variation", num(50.0), pct()),
+ p("strokeOptions/spacing", "Spacing", num(5.0), slider(0.1, 100.0, 0.1, 50.0, 1)),
+ p("strokeOptions/spacingVariation", "Spacing Variation", num(50.0), pct()),
+ p("strokeOptions/pathOverlap", "Path Overlap", num(0.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
+ p("strokeOptions/pathOverlapVariation", "Path Overlap Variation", num(50.0), pct()),
+ p("start", "Start", num(0.0), pct()),
+ p("end", "End", num(100.0), pct()),
+ p("startEndApplyTo", "Start/End Apply To", Value::Enum(0), popup(&["All Strokes", "Each Stroke"])),
+ check("fillPathsSequentially", "Fill Paths Sequentially", true),
+ p("wiggleType", "Wiggle Type", Value::Enum(1), popup(&["Static", "Jumpy", "Smooth"])),
+ p("wigglesPerSecond", "Wiggles/Second", num(5.0), slider(0.0, 100.0, 0.0, 30.0, 2)),
+ p("randomSeed", "Random Seed", num(1.0), slider(0.0, 10000.0, 0.0, 100.0, 0)),
+ p("composite", "Composite", Value::Enum(1), popup(&["On Original Image", "On Transparent", "Reveal Original Image"])),
+ ],
+ scribble,
+ ),
+ spec(
+ "ec.generate.stroke",
+ "Stroke",
+ vec![
+ mask_idx("path", "Path", 1.0),
+ check("allMasks", "All Masks", false),
+ check("strokeSequentially", "Stroke Sequentially", true),
+ p("color", "Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+ p("brushSize", "Brush Size", num(2.0), slider(0.0, 50.0, 0.0, 50.0, 1)),
+ p("brushHardness", "Brush Hardness", num(75.0), pct()),
+ p("opacity", "Opacity", num(100.0), pct()),
+ p("start", "Start", num(0.0), pct()),
+ p("end", "End", num(100.0), pct()),
+ p("spacing", "Spacing", num(15.0), slider(0.0, 100.0, 0.0, 100.0, 1)),
+ p("paintStyle", "Paint Style", Value::Enum(0), paint_style()),
+ ],
+ stroke,
+ ),
+ spec(
+ "ec.generate.vegas",
+ "Vegas",
+ vec![
+ p("stroke", "Stroke", Value::Enum(0), popup(&["Image Contours", "Mask/Path"])),
+ p("inputLayer", "Image Contours: Input Layer", Value::Layer(None), ParamUi::Layer),
+ check("invertInput", "Image Contours: Invert Input", false),
+ p("ifLayerSizesDiffer", "Image Contours: If Layer Sizes Differ", Value::Enum(0), popup(&["Center", "Stretch to Fit"])),
+ p("channel", "Image Contours: Channel", Value::Enum(0), popup(&["Intensity", "Red", "Green", "Blue", "Alpha"])),
+ p("threshold", "Image Contours: Threshold", num(50.0), pct()),
+ p("preBlur", "Image Contours: Pre-Blur", num(1.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
+ p("tolerance", "Image Contours: Tolerance", num(0.01), slider(0.0, 1.0, 0.0, 0.1, 3)),
+ p("renderMode", "Image Contours: Render", Value::Enum(0), popup(&["All Contours", "Selected Contour"])),
+ p("selectedContour", "Image Contours: Selected Contour", num(1.0), slider(1.0, 1000.0, 1.0, 20.0, 0)),
+ p("shorterContoursHave", "Image Contours: Shorter Contours Have", Value::Enum(0), popup(&["Same Number of Segments", "Fewer Segments"])),
+ mask_idx("path", "Mask/Path: Path", 1.0),
+ p("segments", "Segments: Segments", num(32.0), slider(1.0, 1000.0, 1.0, 100.0, 0)),
+ p("length", "Segments: Length", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
+ p("segmentDistribution", "Segments: Segment Distribution", Value::Enum(0), popup(&["Bunched", "Even"])),
+ p("rotation", "Segments: Rotation", num(0.0), ang()),
+ check("randomPhase", "Segments: Random Phase", false),
+ p("randomSeed", "Segments: Random Seed", num(1.0), slider(1.0, 10000.0, 1.0, 100.0, 0)),
+ p("blendMode", "Rendering: Blend Mode", Value::Enum(1), popup(&["Transparent", "Over", "Under", "Stencil"])),
+ p("color", "Rendering: Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+ p("width", "Rendering: Width", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 2)),
+ p("hardness", "Rendering: Hardness", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
+ p("startOpacity", "Rendering: Start Opacity", num(1.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
+ p("midpointOpacity", "Rendering: Mid-point Opacity", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
+ p("midpointPosition", "Rendering: Mid-point Position", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
+ p("endOpacity", "Rendering: End Opacity", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
+ ],
+ vegas,
+ ),
+ spec(
+ "ec.generate.writeon",
+ "Write-on",
+ vec![
+ p("brushPosition", "Brush Position", pt(0.5, 0.5), ParamUi::Point),
+ p("color", "Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+ p("brushSize", "Brush Size", num(6.0), slider(0.0, 50.0, 0.0, 50.0, 1)),
+ p("brushHardness", "Brush Hardness", num(75.0), pct()),
+ p("brushOpacity", "Brush Opacity", num(100.0), pct()),
+ p("strokeLength", "Stroke Length (secs)", num(0.0), slider(0.0, 30.0, 0.0, 30.0, 1)),
+ p("brushSpacing", "Brush Spacing (secs)", num(0.001), slider(0.001, 5.0, 0.001, 5.0, 3)),
+ p("paintTimeProperties", "Paint Time Properties", Value::Enum(0), popup(&["None", "Opacity", "Color"])),
+ p("brushTimeProperties", "Brush Time Properties", Value::Enum(0), popup(&["None", "Size", "Hardness", "Size & Hardness"])),
+ p("paintStyle", "Paint Style", Value::Enum(0), paint_style()),
+ ],
+ write_on,
+ ),
+ spec(
+ "ec.generate.paintbucket",
+ "Paint Bucket",
+ vec![
+ p("fillPoint", "Fill Point", pt(0.5, 0.5), ParamUi::Point),
+ p("fillSelector", "Fill Selector", Value::Enum(0), popup(&["Color & Alpha", "Straight Color", "Transparency", "Opacity", "Alpha Channel"])),
+ p("tolerance", "Tolerance", num(10.0), slider(0.0, 255.0, 0.0, 100.0, 1)),
+ check("viewThreshold", "View Threshold", false),
+ p("stroke", "Stroke", Value::Enum(0), popup(&["Antialias", "Feather", "Spread", "Choke", "Stroke"])),
+ p("featherSoftness", "Feather Softness", num(10.0), slider(0.0, 100.0, 0.0, 50.0, 1)),
+ p("spreadRadius", "Spread Radius", num(3.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
+ p("strokeWidth", "Stroke Width", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
+ p("color", "Color", col(1.0, 0.0, 0.0), ParamUi::Color),
+ p("opacity", "Opacity", num(100.0), pct()),
+ p(
+ "blendingMode",
+ "Blending Mode",
+ Value::Enum(0),
+ popup(&["Normal", "Add", "Multiply", "Screen", "Hue", "Saturation", "Color", "Luminosity", "Behind", "Fill Only"]),
+ ),
+ ],
+ paint_bucket,
+ ),
+ spec(
+ "ec.generate.eyedropperfill",
+ "Eyedropper Fill",
+ vec![
+ p("samplePoint", "Sample Point", pt(0.5, 0.5), ParamUi::Point),
+ p("sampleRadius", "Sample Radius", num(0.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
+ p("averagePixelColors", "Average Pixel Colors", Value::Enum(0), popup(&["Skip Empty", "All", "All Premultiplied", "Including Alpha"])),
+ check("maintainOriginalAlpha", "Maintain Original Alpha", false),
+ p("blendWithOriginal", "Blend With Original", num(0.0), pct()),
+ ],
+ eyedropper_fill,
+ ),
+ spec(
+ "ec.generate.ccgluegun",
+ "CC Glue Gun",
+ vec![
+ p("brushPosition", "Brush Position", pt(0.5, 0.5), ParamUi::Point),
+ p("strokeWidth", "Stroke Width", num(25.0), slider(0.0, 500.0, 0.0, 100.0, 1)),
+ p("density", "Density", num(5.0), slider(0.0, 32.0, 0.0, 32.0, 1)),
+ p("timeSpan", "Time Span (sec)", num(1.0), slider(0.0, 60.0, 0.0, 10.0, 2)),
+ p("reflection", "Reflection", num(45.0), ang()),
+ p("strength", "Strength", num(100.0), pct()),
+ p("style", "Style", Value::Enum(0), popup(&["Over Layer", "Glue Only"])),
+ ],
+ glue_gun,
+ ),
+ spec(
+ "ec.generate.ccthreads",
+ "CC Threads",
+ vec![
+ p("width", "Width", num(50.0), slider(1.0, 1000.0, 1.0, 200.0, 1)),
+ p("height", "Height", num(50.0), slider(1.0, 1000.0, 1.0, 200.0, 1)),
+ p("overlaps", "Overlaps", num(1.0), slider(1.0, 20.0, 1.0, 10.0, 0)),
+ p("direction", "Direction", num(0.0), ang()),
+ p("center", "Center", pt(0.5, 0.5), ParamUi::Point),
+ p("coverage", "Coverage", num(80.0), pct()),
+ p("shadowing", "Shadowing", num(50.0), pct()),
+ p("texture", "Texture", num(10.0), pct()),
+ ],
+ threads,
+ ),
+ spec(
+ "ec.generate.audiospectrum",
+ "Audio Spectrum",
+ vec![
+ p("audioLayer", "Audio Layer", Value::Layer(None), ParamUi::Layer),
+ p("startPoint", "Start Point", pt(0.1, 0.5), ParamUi::Point),
+ p("endPoint", "End Point", pt(0.9, 0.5), ParamUi::Point),
+ mask_idx("path", "Path", 0.0),
+ check("usePolarPath", "Use Polar Path", false),
+ p("startFrequency", "Start Frequency", num(20.0), slider(1.0, 20000.0, 1.0, 2000.0, 0)),
+ p("endFrequency", "End Frequency", num(2000.0), slider(1.0, 20000.0, 1.0, 10000.0, 0)),
+ p("frequencyBands", "Frequency bands", num(64.0), slider(1.0, 4096.0, 1.0, 256.0, 0)),
+ p("maximumHeight", "Maximum Height", num(50.0), slider(0.0, 10000.0, 0.0, 500.0, 1)),
+ p("audioDuration", "Audio Duration (milliseconds)", num(90.0), slider(1.0, 30000.0, 1.0, 1000.0, 1)),
+ p("audioOffset", "Audio Offset (milliseconds)", num(0.0), slider(-30000.0, 30000.0, -1000.0, 1000.0, 1)),
+ p("thickness", "Thickness", num(3.0), slider(0.0, 1000.0, 0.0, 50.0, 2)),
+ p("softness", "Softness", num(50.0), pct()),
+ p("insideColor", "Inside Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+ p("outsideColor", "Outside Color", col(0.2, 0.4, 1.0), ParamUi::Color),
+ check("blendOverlappingColors", "Blend Overlapping Colors", true),
+ p("hueInterpolation", "Hue Interpolation", num(0.0), ang()),
+ check("dynamicHuePhase", "Dynamic Hue Phase", false),
+ check("colorSymmetry", "Color Symmetry", false),
+ p("displayOptions", "Display Options", Value::Enum(0), display()),
+ p("sideOptions", "Side Options", Value::Enum(0), popup(&["Side A", "Side B", "Side A & B"])),
+ check("durationAveraging", "Duration Averaging", false),
+ check("compositeOnOriginal", "Composite On Original", false),
+ ],
+ audio_spectrum,
+ ),
+ spec(
+ "ec.generate.audiowaveform",
+ "Audio Waveform",
+ vec![
+ p("audioLayer", "Audio Layer", Value::Layer(None), ParamUi::Layer),
+ p("startPoint", "Start Point", pt(0.1, 0.5), ParamUi::Point),
+ p("endPoint", "End Point", pt(0.9, 0.5), ParamUi::Point),
+ mask_idx("path", "Path", 0.0),
+ check("usePolarPath", "Use Polar Path", false),
+ p("displayedSamples", "Displayed Samples", num(200.0), slider(2.0, 4096.0, 2.0, 1000.0, 0)),
+ p("maximumHeight", "Maximum Height", num(100.0), slider(0.0, 10000.0, 0.0, 500.0, 1)),
+ p("audioDuration", "Audio Duration (milliseconds)", num(200.0), slider(1.0, 30000.0, 1.0, 1000.0, 1)),
+ p("audioOffset", "Audio Offset (milliseconds)", num(0.0), slider(-30000.0, 30000.0, -1000.0, 1000.0, 1)),
+ p("thickness", "Thickness", num(2.0), slider(0.0, 1000.0, 0.0, 50.0, 2)),
+ p("softness", "Softness", num(10.0), pct()),
+ p("randomSeed", "Random Seed (Analog)", num(1.0), slider(1.0, 10000.0, 1.0, 100.0, 0)),
+ p("insideColor", "Inside Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+ p("outsideColor", "Outside Color", col(0.2, 0.4, 1.0), ParamUi::Color),
+ p("waveformOptions", "Waveform Options", Value::Enum(0), popup(&["Mono", "Left", "Right"])),
+ p("displayOptions", "Display Options", Value::Enum(1), display()),
+ check("compositeOnOriginal", "Composite On Original", false),
+ ],
+ audio_waveform,
+ ),
+ ]
+}
diff --git a/crates/effects/src/generate3/tests.rs b/crates/effects/src/generate3/tests.rs
new file mode 100644
index 000000000..0edad2f2d
--- /dev/null
+++ b/crates/effects/src/generate3/tests.rs
@@ -0,0 +1,397 @@
+use super::*;
+use crate::{EffectEnv, EffectHost, LayerPixels, MaskShape, Params};
+
+/// Run with point defaults scaled to the layer size.
+pub(crate) fn run_env(id: &str, set: &[(&str, Value)], img: Image, time: f64, env: EffectEnv) -> Buf {
+ let s = crate::find(id).unwrap();
+ let ls = [img.width as f64, img.height as f64];
+ let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+ for p in &s.params {
+ if let (ParamUi::Point, Value::Vec2(v)) = (&p.ui, &p.default) {
+ params.values.insert(p.id.to_string(), Value::Vec2([v[0] * ls[0], v[1] * ls[1]]));
+ }
+ }
+ for (k, v) in set {
+ assert!(params.values.contains_key(*k), "{id}: unknown {k}");
+ params.values.insert(k.to_string(), v.clone());
+ }
+ let ctx = EffectCtx { params: ¶ms, time, layer_size: ls, seed: 3, adjustment: false, env };
+ crate::apply(s, &ctx, Buf { img, offset: [0.0, 0.0], scale: 1.0 })
+}
+
+fn run(id: &str, set: &[(&str, Value)], img: Image) -> Buf {
+ run_env(id, set, img, 0.5, EffectEnv::default())
+}
+
+fn square_mask() -> Vec {
+ vec![MaskShape { name: "Mask 1".into(), points: vec![[16.0, 16.0], [48.0, 16.0], [48.0, 48.0], [16.0, 48.0]], closed: true, inverted: false }]
+}
+
+fn alpha_sum(img: &Image, x0: usize, y0: usize, x1: usize, y1: usize) -> f32 {
+ let mut s = 0.0;
+ for y in y0..y1 {
+ for x in x0..x1 {
+ s += img.data[y * img.width as usize + x][3];
+ }
+ }
+ s
+}
+
+#[test]
+fn audio_spectrum_linear_frequency_and_linear_amplitude() {
+ let host = Tone; // Tone produces 440 Hz
+ let env = EffectEnv { host: Some(&host), comp_time: 1.0, ..Default::default() };
+ let img = Image::new(200, 100);
+ let out = run_env(
+ "ec.generate.audiospectrum",
+ &[
+ ("audioLayer", Value::Layer(Some(1))),
+ ("startPoint", Value::Vec2([0.0, 50.0])),
+ ("endPoint", Value::Vec2([200.0, 50.0])),
+ ("startFrequency", num(20.0)),
+ ("endFrequency", num(2000.0)),
+ ("frequencyBands", num(100.0)),
+ ("maximumHeight", num(40.0)),
+ ("thickness", num(2.0)),
+ ("softness", num(0.0)),
+ ],
+ img,
+ 1.0,
+ env,
+ );
+ // Verify 440 Hz tone produces a peak above baseline, while high frequencies have zero bar height
+ let peak_zone = alpha_sum(&out.img, 36, 10, 48, 48);
+ let high_zone = alpha_sum(&out.img, 120, 10, 150, 48);
+ let silent_zone = alpha_sum(&out.img, 170, 10, 195, 48);
+ assert!(peak_zone > 5.0, "peak zone has energy: {peak_zone}");
+ assert!(peak_zone > high_zone * 2.0, "linear peak is distinctly taller than far frequencies: {peak_zone} vs {high_zone}");
+ assert_eq!(silent_zone, 0.0, "silent end has zero height, not boosted by dB scale");
+}
+
+#[test]
+fn fractal_deterministic_and_has_inside_set() {
+ let img = Image::new(64, 48);
+ let a = run("ec.generate.fractal", &[], img.clone());
+ let b = run("ec.generate.fractal", &[], img.clone());
+ assert_eq!(a.img.data, b.img.data);
+ // The default view contains the main cardioid (black, opaque) and escaped (coloured) points.
+ assert!(a.img.data.iter().any(|p| p[3] > 0.99 && p[0] + p[1] + p[2] < 0.01));
+ assert!(a.img.data.iter().any(|p| p[0] + p[1] + p[2] > 0.3));
+ let t = run("ec.generate.fractal", &[("fractalColor/transparency", Value::Bool(true))], img);
+ assert!(t.img.data.iter().any(|p| p[3] == 0.0));
+}
+
+#[test]
+fn fractal_palettes_and_set_choices() {
+ let img = Image::new(64, 48);
+ // Solid Color: only the inside of the set is drawn; Transparency flips it.
+ let solid = run("ec.generate.fractal", &[("fractalColor/palette", Value::Enum(3))], img.clone());
+ assert!(solid.img.data.iter().any(|p| p[3] == 0.0) && solid.img.data.iter().any(|p| p[3] > 0.99 && p[0] > 0.9));
+ let flipped = run("ec.generate.fractal", &[("fractalColor/palette", Value::Enum(3)), ("fractalColor/transparency", Value::Bool(true))], img.clone());
+ for (a, b) in solid.img.data.iter().zip(&flipped.img.data) {
+ assert!((a[3] > 0.5) != (b[3] > 0.5) || (a[3] - 0.5).abs() < 0.49);
+ }
+ // Black And White: escaped pixels are pure black or white (away from supersampled edges).
+ let bw = run("ec.generate.fractal", &[("fractalColor/palette", Value::Enum(2)), ("highQualitySettings/samplingFactor", num(1.0))], img.clone());
+ assert!(bw.img.data.iter().all(|p| p[0] == p[1] && p[1] == p[2] && (p[0] == 0.0 || p[0] == 1.0)));
+ // Mandelbrot Over Julia depends on the Julia centre.
+ let o1 = run("ec.generate.fractal", &[("setChoice", Value::Enum(2)), ("julia/juliaX", num(0.3))], img.clone());
+ let o2 = run("ec.generate.fractal", &[("setChoice", Value::Enum(2)), ("julia/juliaX", num(-0.2))], img.clone());
+ assert_ne!(o1.img.data, o2.img.data);
+ let plain = run("ec.generate.fractal", &[("julia/juliaX", num(0.3))], img);
+ assert_ne!(o1.img.data, plain.img.data);
+}
+
+#[test]
+fn scribble_fills_mask_and_animates() {
+ let masks = square_mask();
+ let env = EffectEnv { masks: &masks, ..Default::default() };
+ let img = Image::filled(64, 64, [0.0, 0.0, 1.0, 1.0]);
+ let a = run_env("ec.generate.scribble", &[], img.clone(), 0.5, env);
+ let b = run_env("ec.generate.scribble", &[], img.clone(), 0.5, env);
+ assert_eq!(a.img.data, b.img.data);
+ let inside = alpha_sum(&a.img, 18, 18, 46, 46);
+ let outside = alpha_sum(&a.img, 0, 0, 10, 64);
+ assert!(inside > 100.0 && outside < 1.0, "{inside} {outside}");
+ let c = run_env("ec.generate.scribble", &[], img.clone(), 1.5, env);
+ assert_ne!(a.img.data, c.img.data, "jumpy wiggle changes over time");
+ let s = run_env("ec.generate.scribble", &[("wiggleType", Value::Enum(0))], img.clone(), 0.5, env);
+ let s2 = run_env("ec.generate.scribble", &[("wiggleType", Value::Enum(0))], img.clone(), 3.5, env);
+ assert_eq!(s.img.data, s2.img.data, "static wiggle is constant");
+ let half = run_env("ec.generate.scribble", &[("end", num(50.0))], img, 0.5, env);
+ assert!(alpha_sum(&half.img, 0, 0, 64, 64) < alpha_sum(&a.img, 0, 0, 64, 64));
+}
+
+#[test]
+fn scribble_edge_types() {
+ let masks = square_mask();
+ let env = EffectEnv { masks: &masks, ..Default::default() };
+ let img = Image::new(64, 64);
+ let o = run_env("ec.generate.scribble", &[("fillType", Value::Enum(3)), ("edgeOptions/edgeWidth", num(6.0))], img, 0.5, env);
+ // Outside edge: paint near the border outside, nothing in the centre.
+ assert!(alpha_sum(&o.img, 26, 26, 38, 38) < 0.5);
+ assert!(alpha_sum(&o.img, 8, 8, 16, 56) > 5.0);
+}
+
+#[test]
+fn stroke_draws_along_mask() {
+ let masks = square_mask();
+ let env = EffectEnv { masks: &masks, ..Default::default() };
+ let img = Image::new(64, 64);
+ let a = run_env("ec.generate.stroke", &[("brushSize", num(4.0)), ("paintStyle", Value::Enum(1))], img.clone(), 0.0, env);
+ assert!(a.img.get(32, 16)[3] > 0.9, "on the top edge");
+ assert!(a.img.get(32, 32)[3] < 0.01, "centre empty");
+ let b = run_env("ec.generate.stroke", &[("brushSize", num(4.0)), ("end", num(25.0))], img.clone(), 0.0, env);
+ assert!(b.img.get(32, 16)[3] > 0.9 && b.img.get(48, 32)[3] < 0.01, "first quarter only");
+ let d = run_env("ec.generate.stroke", &[("brushSize", num(4.0)), ("spacing", num(300.0))], img, 0.0, env);
+ assert!(alpha_sum(&d.img, 0, 0, 64, 64) < alpha_sum(&a.img, 0, 0, 64, 64), "spaced dabs");
+ // No masks: unchanged.
+ let src = Image::filled(8, 8, [0.2, 0.3, 0.4, 1.0]);
+ assert_eq!(run("ec.generate.stroke", &[], src.clone()).img.data, src.data);
+}
+
+#[test]
+fn vegas_traces_contours() {
+ let mut img = Image::new(64, 64);
+ for y in 16..48 {
+ for x in 16..48 {
+ img.set(x, y, [1.0, 1.0, 1.0, 1.0]);
+ }
+ }
+ let a =
+ run("ec.generate.vegas", &[("blendMode", Value::Enum(0)), ("length", num(1.0)), ("midpointOpacity", num(1.0)), ("endOpacity", num(1.0))], img.clone());
+ let b =
+ run("ec.generate.vegas", &[("blendMode", Value::Enum(0)), ("length", num(1.0)), ("midpointOpacity", num(1.0)), ("endOpacity", num(1.0))], img.clone());
+ assert_eq!(a.img.data, b.img.data);
+ assert!(alpha_sum(&a.img, 14, 14, 50, 50) > 50.0, "edges drawn");
+ assert!(alpha_sum(&a.img, 26, 26, 38, 38) < 0.5, "interior untouched");
+ let r = run("ec.generate.vegas", &[("blendMode", Value::Enum(0)), ("rotation", num(90.0))], img);
+ assert_ne!(r.img.data, a.img.data);
+}
+
+#[test]
+fn contours_of_square_are_closed() {
+ let mut pl = Plane::new(20, 20);
+ for y in 5..15 {
+ for x in 5..15 {
+ pl.data[y * 20 + x] = 1.0;
+ }
+ }
+ let c = contours(&pl, 0.5);
+ assert_eq!(c.len(), 1);
+ assert!(c[0].1);
+ let l = poly_length(&c[0].0, true);
+ assert!((l - 40.0).abs() < 4.0, "{l}");
+}
+
+#[test]
+fn write_on_and_glue_gun_draw_at_brush() {
+ let img = Image::new(32, 32);
+ let a = run("ec.generate.writeon", &[], img.clone());
+ assert!(a.img.get(16, 16)[3] > 0.9 && a.img.get(2, 2)[3] == 0.0);
+ assert_eq!(a.img.data, run("ec.generate.writeon", &[], img.clone()).img.data);
+ let src = Image::filled(32, 32, [0.5, 0.2, 0.1, 1.0]);
+ let g = run("ec.generate.ccgluegun", &[], src.clone());
+ assert_eq!(g.img.data, run("ec.generate.ccgluegun", &[], src.clone()).img.data);
+ assert_ne!(g.img.get(16, 16), src.get(16, 16));
+ assert_eq!(g.img.get(0, 0), src.get(0, 0));
+}
+
+/// #536: an animated Brush Position draws a stroke that stays (Stroke Length 0), expires
+/// after Stroke Length, and lays its dabs Brush Spacing seconds apart.
+#[test]
+fn write_on_accumulates_a_stroke_along_the_animated_brush() {
+ // Brush Position from [8, 16] at 0 s to [56, 16] at 1 s; red, hard, 6 px.
+ struct Brush(Vec<(&'static str, Value)>);
+ impl Brush {
+ fn at(&self, t: f64) -> Vec<(&'static str, Value)> {
+ let mut v = self.0.clone();
+ v.push(("brushPosition", Value::Vec2([8.0 + 48.0 * t.clamp(0.0, 1.0), 16.0])));
+ v
+ }
+ }
+ impl EffectHost for Brush {
+ fn layer(&self, _: u64, _: bool) -> Option {
+ None
+ }
+ fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option> {
+ None
+ }
+ fn params_at(&self, t: f64) -> Option {
+ let s = crate::find("ec.generate.writeon").unwrap();
+ let mut p = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+ for (k, v) in self.at(t) {
+ p.values.insert(k.to_string(), v);
+ }
+ Some(p)
+ }
+ }
+ let render = |extra: &[(&'static str, Value)], t: f64| {
+ let mut set = vec![("color", col(1.0, 0.0, 0.0)), ("brushSize", num(6.0)), ("brushHardness", num(100.0)), ("brushSpacing", num(0.05))];
+ set.extend(extra.iter().cloned());
+ let host = Brush(set);
+ let env = EffectEnv { host: Some(&host), ..Default::default() };
+ let at = host.at(t);
+ run_env("ec.generate.writeon", &at, Image::new(64, 32), t, env).img
+ };
+ let on = |img: &Image, x: i64| img.get(x, 16)[3] > 0.9;
+ let half = render(&[], 0.5);
+ assert!(on(&half, 8) && on(&half, 20) && on(&half, 32) && !on(&half, 44) && !on(&half, 56));
+ let end = render(&[], 1.0);
+ assert!([8, 20, 32, 44, 56].iter().all(|x| on(&end, *x)));
+ // Stroke Length 0.25 s: only the last quarter second's trail.
+ let trail = render(&[("strokeLength", num(0.25))], 1.0);
+ assert!(!on(&trail, 8) && !on(&trail, 32) && on(&trail, 48) && on(&trail, 56));
+ // Brush Spacing 0.5 s: three separate marks.
+ let spaced = render(&[("brushSpacing", num(0.5))], 1.0);
+ assert!(on(&spaced, 8) && on(&spaced, 32) && on(&spaced, 56) && !on(&spaced, 20) && !on(&spaced, 44));
+ // Paint Time Properties ▸ Opacity: each dab keeps the opacity it was laid with.
+ struct Fade;
+ impl EffectHost for Fade {
+ fn layer(&self, _: u64, _: bool) -> Option {
+ None
+ }
+ fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option> {
+ None
+ }
+ fn params_at(&self, t: f64) -> Option {
+ let mut p = Brush(vec![("brushHardness", num(100.0)), ("brushSpacing", num(0.05)), ("paintTimeProperties", Value::Enum(1))]).params_at(t)?;
+ p.values.insert("brushOpacity".into(), num(if t < 0.5 { 100.0 } else { 20.0 }));
+ Some(p)
+ }
+ }
+ let p1 = Fade.params_at(1.0).unwrap();
+ let set: Vec<(&str, Value)> = p1.values.iter().map(|(k, v)| (k.as_str(), v.clone())).collect();
+ let faded = run_env("ec.generate.writeon", &set, Image::new(64, 32), 1.0, EffectEnv { host: Some(&Fade), ..Default::default() }).img;
+ assert!(faded.get(8, 16)[3] > 0.9 && (faded.get(56, 16)[3] - 0.2).abs() < 0.05, "{:?} {:?}", faded.get(8, 16), faded.get(56, 16));
+}
+
+#[test]
+fn paint_bucket_fills_enclosed_region_only() {
+ let mut img = Image::filled(32, 32, [1.0, 1.0, 1.0, 1.0]);
+ for i in 8..24 {
+ for &(x, y) in &[(i, 8), (i, 23), (8, i), (23, i)] {
+ img.set(x, y, [0.0, 0.0, 0.0, 1.0]);
+ }
+ }
+ let out = run("ec.generate.paintbucket", &[], img.clone());
+ let inside = out.img.get(16, 16);
+ assert!(inside[0] > 0.99 && inside[1] < 0.01, "{inside:?}");
+ assert_eq!(out.img.get(2, 2), [1.0, 1.0, 1.0, 1.0], "outside untouched");
+ assert_eq!(out.img.get(8, 16), [0.0, 0.0, 0.0, 1.0], "border untouched");
+ assert_eq!(out.img.data, run("ec.generate.paintbucket", &[], img).img.data);
+}
+
+#[test]
+fn eyedropper_fill_uses_sample() {
+ let mut img = Image::filled(16, 16, [0.0, 0.0, 1.0, 1.0]);
+ img.set(8, 8, [1.0, 0.0, 0.0, 1.0]);
+ let out = run("ec.generate.eyedropperfill", &[], img.clone());
+ assert!(out.img.data.iter().all(|p| *p == [1.0, 0.0, 0.0, 1.0]));
+ let blended = run("ec.generate.eyedropperfill", &[("blendWithOriginal", num(100.0))], img.clone());
+ assert_eq!(blended.img.data, img.data);
+}
+
+#[test]
+fn threads_weave_is_deterministic_and_gappy() {
+ let src = Image::filled(64, 64, [0.4, 0.6, 0.2, 1.0]);
+ let a = run("ec.generate.ccthreads", &[("width", num(16.0)), ("height", num(16.0)), ("coverage", num(50.0))], src.clone());
+ assert_eq!(a.img.data, run("ec.generate.ccthreads", &[("width", num(16.0)), ("height", num(16.0)), ("coverage", num(50.0))], src).img.data);
+ assert!(a.img.data.iter().any(|p| p[3] == 0.0), "gaps between threads");
+ assert!(a.img.data.iter().any(|p| p[3] > 0.99), "threads");
+}
+
+struct Tone;
+impl EffectHost for Tone {
+ fn layer(&self, _: u64, _: bool) -> Option {
+ None
+ }
+ fn audio(&self, _: u64, start: f64, frames: usize, rate: u32) -> Option> {
+ Some(
+ (0..frames)
+ .flat_map(|i| {
+ let t = start + i as f64 / rate as f64;
+ let v = (2.0 * PI * 440.0 * t).sin() as f32 * 0.8;
+ [v, v]
+ })
+ .collect(),
+ )
+ }
+}
+
+#[test]
+fn audio_effects_without_audio_pass_through() {
+ let src = Image::filled(16, 16, [0.3, 0.3, 0.3, 1.0]);
+ for id in ["ec.generate.audiospectrum", "ec.generate.audiowaveform"] {
+ assert_eq!(run(id, &[], src.clone()).img.data, src.data, "{id}");
+ }
+}
+
+#[test]
+fn audio_effects_draw_with_host() {
+ let host = Tone;
+ let env = EffectEnv { host: Some(&host), comp_time: 1.0, ..Default::default() };
+ let img = Image::new(96, 64);
+ for id in ["ec.generate.audiospectrum", "ec.generate.audiowaveform"] {
+ let a = run_env(id, &[("audioLayer", Value::Layer(Some(1)))], img.clone(), 1.0, env);
+ let b = run_env(id, &[("audioLayer", Value::Layer(Some(1)))], img.clone(), 1.0, env);
+ assert_eq!(a.img.data, b.img.data, "{id}");
+ assert!(alpha_sum(&a.img, 0, 0, 96, 64) > 10.0, "{id} drew nothing");
+ }
+}
+
+#[test]
+fn fft_finds_tone() {
+ let n = 256;
+ let mut re: Vec = (0..n).map(|i| (2.0 * PI * 8.0 * i as f64 / n as f64).cos()).collect();
+ let mut im = vec![0.0; n];
+ fft(&mut re, &mut im);
+ let mags: Vec = (0..n / 2).map(|k| (re[k] * re[k] + im[k] * im[k]).sqrt()).collect();
+ let peak = mags.iter().enumerate().max_by(|a, b| a.1.total_cmp(b.1)).unwrap().0;
+ assert_eq!(peak, 8);
+}
+
+#[test]
+fn stroke_outline_caps_and_joins() {
+ let line = vec![vec![[10.0, 10.0], [30.0, 10.0]]];
+ let cov = |cap: u32| raster_convex(40, 20, &stroke_outline(&line, 3.0, cap, 0, 4.0));
+ // Round caps reach 3 px past the ends (on the axis), Butt stops there, Projecting is square.
+ let (round, butt, proj) = (cov(0), cov(1), cov(2));
+ assert!(round.get(8, 10) > 0.9 && butt.get(8, 10) < 0.1 && proj.get(8, 10) > 0.9);
+ assert!(proj.get(7, 7) > 0.9 && round.get(7, 7) < 0.5, "square corner");
+ // A right-angle turn: Miter fills the outer corner, Bevel cuts it.
+ let corner = vec![vec![[5.0, 30.0], [30.0, 30.0], [30.0, 5.0]]];
+ let j = |join: u32| raster_convex(40, 40, &stroke_outline(&corner, 3.0, 1, join, 4.0));
+ let (miter, bevel) = (j(1), j(2));
+ assert!(miter.get(32, 32) > 0.9 && bevel.get(32, 32) < 0.1, "{} {}", miter.get(32, 32), bevel.get(32, 32));
+ // A tight miter limit falls back to a bevel.
+ let limited = raster_convex(40, 40, &stroke_outline(&corner, 3.0, 1, 1, 1.0));
+ assert!(limited.get(32, 32) < 0.1);
+}
+
+#[test]
+fn scribble_caps_and_start_end_apply_to() {
+ let masks = square_mask();
+ let env = EffectEnv { masks: &masks, ..Default::default() };
+ let img = Image::new(64, 64);
+ let base = [("wiggleType", Value::Enum(0)), ("strokeWidth", num(3.0))];
+ let round = run_env("ec.generate.scribble", &base, img.clone(), 0.0, env);
+ let butt = run_env(
+ "ec.generate.scribble",
+ &[base.as_slice(), &[("edgeOptions/endCap", Value::Enum(1)), ("edgeOptions/join", Value::Enum(2))]].concat(),
+ img.clone(),
+ 0.0,
+ env,
+ );
+ assert_ne!(round.img.data, butt.img.data);
+ // Each Stroke: every stroke is trimmed on its own, so the half-way image has ink all over.
+ let two = vec![
+ crate::MaskShape { name: String::new(), points: vec![[4.0, 4.0], [28.0, 4.0], [28.0, 60.0], [4.0, 60.0]], closed: true, inverted: false },
+ crate::MaskShape { name: String::new(), points: vec![[36.0, 4.0], [60.0, 4.0], [60.0, 60.0], [36.0, 60.0]], closed: true, inverted: false },
+ ];
+ let env2 = EffectEnv { masks: &two, ..Default::default() };
+ let seq = [("scribble", Value::Enum(1)), ("end", num(50.0))];
+ let all = run_env("ec.generate.scribble", &[base.as_slice(), &seq].concat(), img.clone(), 0.0, env2);
+ let each = run_env("ec.generate.scribble", &[base.as_slice(), &seq, &[("startEndApplyTo", Value::Enum(1))]].concat(), img, 0.0, env2);
+ assert_ne!(all.img.data, each.img.data);
+}
diff --git a/crates/effects/src/noise3.rs b/crates/effects/src/noise3.rs
index baa5fb50a..bf1f05ed6 100644
--- a/crates/effects/src/noise3.rs
+++ b/crates/effects/src/noise3.rs
@@ -333,7 +333,7 @@ impl Fractal {
}
/// Fractal / Turbulent Noise resolved for the GPU kernel (effectcraft-gpu `fx_noise`): the
-/// per-pixel constants and, per octave, the terms [`Fractal::raw`] computes before touching the
+/// per-pixel constants and, per octave, the terms `Fractal::raw` computes before touching the
/// pixel, in the same f32 order.
pub struct FractalGpu {
pub kind: u32,
diff --git a/crates/effects/src/ocio.rs b/crates/effects/src/ocio.rs
index e84720a32..2daa9857d 100644
--- a/crates/effects/src/ocio.rs
+++ b/crates/effects/src/ocio.rs
@@ -37,1802 +37,31 @@ use crate::util::unpremul;
use crate::utility::{Lut, parse_cube};
use crate::{Buf, EffectCtx, EffectSpec, num, p, popup, slider};
-type M3 = [[f64; 3]; 3];
+mod cdl;
+mod effects;
+mod lut;
+mod program;
+mod registry;
+mod space;
-pub(crate) const D65: [f64; 2] = [0.3127, 0.3290];
-const ACES_WHITE: [f64; 2] = [0.32168, 0.33767];
-const AP0: [[f64; 2]; 3] = [[0.7347, 0.2653], [0.0, 1.0], [0.0001, -0.0770]];
-const AP1: [[f64; 2]; 3] = [[0.713, 0.293], [0.165, 0.830], [0.128, 0.044]];
-pub(crate) const REC709: [[f64; 2]; 3] = [[0.640, 0.330], [0.300, 0.600], [0.150, 0.060]];
-pub(crate) const REC2020: [[f64; 2]; 3] = [[0.708, 0.292], [0.170, 0.797], [0.131, 0.046]];
-pub(crate) const P3: [[f64; 2]; 3] = [[0.680, 0.320], [0.265, 0.690], [0.150, 0.060]];
-const IDENTITY: M3 = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
-
-/// Transfer functions (encoded ↔ linear).
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Tf {
- Linear,
- Srgb,
- Gamma(f64),
- AcesCct,
- /// ACEScc (Academy S-2014-003), the pure-log grading encoding.
- AcesCc,
- /// SMPTE ST 2084 with 1.0 = 100 cd/m².
- Pq,
-}
-
-/// ACEScc: the lowest code value (linear 0 and below) and the end of its toe (linear 2⁻¹⁵).
-const ACESCC_MIN: f64 = (-16.0 + 9.72) / 17.52;
-const ACESCC_TOE: f64 = (-15.0 + 9.72) / 17.52;
-
-impl Tf {
- pub fn decode(self, v: f64) -> f64 {
- match self {
- Tf::Linear => v,
- Tf::Srgb => {
- let a = v.abs();
- let l = if a <= 0.04045 { a / 12.92 } else { ((a + 0.055) / 1.055).powf(2.4) };
- l.copysign(v)
- }
- Tf::Gamma(g) => v.abs().powf(g).copysign(v),
- Tf::AcesCct => {
- if v <= 0.155_251_141_552_511 {
- (v - 0.072_905_534_195_835_5) / 10.540_237_741_654_5
- } else if v < (65504f64.log2() + 9.72) / 17.52 {
- 2f64.powf(v * 17.52 - 9.72)
- } else {
- 65504.0
- }
- }
- Tf::AcesCc => {
- if v < ACESCC_TOE {
- (2f64.powf(v * 17.52 - 9.72) - 2f64.powi(-16)) * 2.0
- } else if v < (65504f64.log2() + 9.72) / 17.52 {
- 2f64.powf(v * 17.52 - 9.72)
- } else {
- 65504.0
- }
- }
- Tf::Pq => {
- let (m1, m2, c1, c2, c3) = pq_consts();
- let e = v.max(0.0).powf(1.0 / m2);
- let l = ((e - c1).max(0.0) / (c2 - c3 * e)).powf(1.0 / m1);
- l * 100.0
- }
- }
- }
- pub fn encode(self, v: f64) -> f64 {
- match self {
- Tf::Linear => v,
- Tf::Srgb => {
- let a = v.abs();
- let e = if a <= 0.003_130_8 { a * 12.92 } else { 1.055 * a.powf(1.0 / 2.4) - 0.055 };
- e.copysign(v)
- }
- Tf::Gamma(g) => v.abs().powf(1.0 / g).copysign(v),
- Tf::AcesCct => {
- if v <= 0.007_812_5 {
- 10.540_237_741_654_5 * v + 0.072_905_534_195_835_5
- } else {
- (v.log2() + 9.72) / 17.52
- }
- }
- Tf::AcesCc => {
- if v <= 0.0 {
- ACESCC_MIN
- } else if v < 2f64.powi(-15) {
- ((2f64.powi(-16) + v * 0.5).log2() + 9.72) / 17.52
- } else {
- (v.log2() + 9.72) / 17.52
- }
- }
- Tf::Pq => {
- let (m1, m2, c1, c2, c3) = pq_consts();
- let y = (v / 100.0).max(0.0).powf(m1);
- ((c1 + c2 * y) / (1.0 + c3 * y)).powf(m2)
- }
- }
- }
-}
-
-fn pq_consts() -> (f64, f64, f64, f64, f64) {
- (2610.0 / 16384.0, 2523.0 / 4096.0 * 128.0, 3424.0 / 4096.0, 2413.0 / 4096.0 * 32.0, 2392.0 / 4096.0 * 32.0)
-}
-
-/// A colour space of the built-in config.
-#[derive(Clone, Copy, Debug)]
-pub struct Space {
- pub name: &'static str,
- /// Primaries and white (None = CIE XYZ itself).
- pub prims: Option<([[f64; 2]; 3], [f64; 2])>,
- pub tf: Tf,
- /// Passes data through untouched.
- pub raw: bool,
-}
-
-pub(crate) const fn sp(name: &'static str, prims: [[f64; 2]; 3], white: [f64; 2], tf: Tf) -> Space {
- Space { name, prims: Some((prims, white)), tf, raw: false }
-}
-
-/// The built-in configuration's colour spaces, in popup order.
-pub(crate) const ACES2065_1: Space = sp("ACES2065-1", AP0, ACES_WHITE, Tf::Linear);
-pub(crate) const ACES_CG: Space = sp("ACEScg", AP1, ACES_WHITE, Tf::Linear);
-const ACES_CCT: Space = sp("ACEScct", AP1, ACES_WHITE, Tf::AcesCct);
-
-pub const SPACES: &[Space] = &[
- ACES2065_1,
- ACES_CG,
- ACES_CCT,
- sp("Linear Rec.709 (sRGB)", REC709, D65, Tf::Linear),
- sp("sRGB", REC709, D65, Tf::Srgb),
- sp("Gamma 2.4 Rec.709", REC709, D65, Tf::Gamma(2.4)),
- sp("Linear Rec.2020", REC2020, D65, Tf::Linear),
- sp("Gamma 2.4 Rec.2020", REC2020, D65, Tf::Gamma(2.4)),
- sp("Linear P3-D65", P3, D65, Tf::Linear),
- sp("Display P3", P3, D65, Tf::Srgb),
- Space { name: "CIE-XYZ-D65", prims: None, tf: Tf::Linear, raw: false },
- Space { name: "Raw", prims: None, tf: Tf::Linear, raw: true },
-];
-
-pub fn space_names() -> Vec<&'static str> {
- SPACES.iter().map(|s| s.name).collect()
-}
+pub use cdl::Cdl;
+pub(crate) use effects::CUSTOM_CONFIG_FX;
+#[cfg(test)]
+pub use effects::parse_looks;
+pub use effects::{color_stabilizer_maps, warning};
+#[cfg(test)]
+use effects::{tonemap, tonemap_inv};
+pub use lut::{FileXform, load_file};
+#[cfg(test)]
+pub use lut::{parse_file, parse_spi1d, parse_spi3d, parse_spimtx};
+pub use program::{ColorOp, Straight, color_program};
+pub use registry::specs;
+#[cfg(test)]
+use space::M3;
+pub(crate) use space::{ACES_CG, ACES2065_1, D65, P3, REC709, REC2020, sp};
+#[cfg(test)]
+pub use space::{SPACES, Xform, bradford, space_by_name};
+pub use space::{Space, Tf, matrix};
#[cfg(test)]
-pub fn space_by_name(n: &str) -> Option<&'static Space> {
- SPACES.iter().find(|s| s.name.eq_ignore_ascii_case(n))
-}
-
-/// Bradford chromatic adaptation from white `src` to white `dst` (xy).
-pub fn bradford(src: [f64; 2], dst: [f64; 2]) -> M3 {
- if src == dst {
- return IDENTITY;
- }
- const MB: M3 = [[0.8951, 0.2664, -0.1614], [-0.7502, 1.7135, 0.0367], [0.0389, -0.0685, 1.0296]];
- let xyz = |c: [f64; 2]| [c[0] / c[1], 1.0, (1.0 - c[0] - c[1]) / c[1]];
- let s = mul_vec(&MB, xyz(src));
- let d = mul_vec(&MB, xyz(dst));
- let diag = [[d[0] / s[0], 0.0, 0.0], [0.0, d[1] / s[1], 0.0], [0.0, 0.0, d[2] / s[2]]];
- mul(&invert(&MB), &mul(&diag, &MB))
-}
-
-impl Space {
- /// Linear RGB → XYZ D65 (Bradford-adapted when `adapt`, else the space's own white).
- pub fn to_ref(self, adapt: bool) -> M3 {
- match self.prims {
- None => IDENTITY,
- Some((p, w)) => {
- let m = rgb_to_xyz(p, w);
- if adapt { mul(&bradford(w, D65), &m) } else { m }
- }
- }
- }
-}
-
-/// Linear-RGB matrix from space `a` to space `b`.
-pub fn matrix(a: &Space, b: &Space) -> M3 {
- mul(&invert(&b.to_ref(true)), &a.to_ref(true))
-}
-
-/// A compiled colour-space conversion.
-#[derive(Clone, Copy, Debug)]
-pub struct Xform {
- dec: Tf,
- m: [[f32; 3]; 3],
- ident: bool,
- enc: Tf,
-}
-
-impl Xform {
- pub fn new(a: &Space, b: &Space) -> Xform {
- if a.raw || b.raw {
- return Xform { dec: Tf::Linear, m: IDENTITY.map(|r| r.map(|v| v as f32)), ident: true, enc: Tf::Linear };
- }
- let m = matrix(a, b);
- let ident = (0..3).all(|i| (0..3).all(|j| (m[i][j] - IDENTITY[i][j]).abs() < 1e-12));
- Xform { dec: a.tf, m: m.map(|r| r.map(|v| v as f32)), ident, enc: b.tf }
- }
- #[inline]
- pub fn apply(&self, c: [f32; 3]) -> [f32; 3] {
- let l = c.map(|v| self.dec.decode(v as f64) as f32);
- let l = if self.ident { l } else { [0, 1, 2].map(|i| self.m[i][0] * l[0] + self.m[i][1] * l[1] + self.m[i][2] * l[2]) };
- l.map(|v| self.enc.encode(v as f64) as f32)
- }
-}
-
-// ---------------------------------------------------------------- ASC CDL
-
-/// An ASC Colour Decision List correction.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Cdl {
- pub slope: [f64; 3],
- pub offset: [f64; 3],
- pub power: [f64; 3],
- pub sat: f64,
-}
-
-impl Default for Cdl {
- fn default() -> Self {
- Cdl { slope: [1.0; 3], offset: [0.0; 3], power: [1.0; 3], sat: 1.0 }
- }
-}
-
-const LUMA: [f64; 3] = [0.2126, 0.7152, 0.0722];
-
-impl Cdl {
- /// Forward CDL. `clamp` = the v1.2 style (results clamped to 0..1 after SOP and saturation).
- pub fn apply(&self, c: [f64; 3], clamp: bool) -> [f64; 3] {
- let mut o = [0.0; 3];
- for i in 0..3 {
- let v = c[i] * self.slope[i] + self.offset[i];
- o[i] = if clamp {
- v.clamp(0.0, 1.0).powf(self.power[i])
- } else if v >= 0.0 {
- v.powf(self.power[i])
- } else {
- v
- };
- }
- let l = o[0] * LUMA[0] + o[1] * LUMA[1] + o[2] * LUMA[2];
- let o = o.map(|v| l + self.sat * (v - l));
- if clamp { o.map(|v| v.clamp(0.0, 1.0)) } else { o }
- }
- /// Exact inverse of [`Cdl::apply`] (inside the clamped range).
- pub fn invert(&self, c: [f64; 3], clamp: bool) -> [f64; 3] {
- let c = if clamp { c.map(|v| v.clamp(0.0, 1.0)) } else { c };
- let l = c[0] * LUMA[0] + c[1] * LUMA[1] + c[2] * LUMA[2];
- let s = if self.sat.abs() < 1e-9 { 1e-9 } else { self.sat };
- let o = c.map(|v| l + (v - l) / s);
- let mut r = [0.0; 3];
- for i in 0..3 {
- let v = if clamp { o[i].clamp(0.0, 1.0) } else { o[i] };
- let pw = self.power[i].max(1e-9);
- let u = if v >= 0.0 { v.powf(1.0 / pw) } else { v };
- let sl = if self.slope[i].abs() < 1e-9 { 1e-9 } else { self.slope[i] };
- r[i] = (u - self.offset[i]) / sl;
- }
- if clamp { r.map(|v| v.clamp(0.0, 1.0)) } else { r }
- }
-}
-
-fn tag<'a>(xml: &'a str, name: &str) -> Option<&'a str> {
- let open = xml.find(&format!("<{name}"))?;
- let gt = open + xml[open..].find('>')?;
- if xml[..gt].ends_with('/') {
- return Some("");
- }
- let close = xml[gt..].find(&format!(""))? + gt;
- Some(&xml[gt + 1..close])
-}
-
-fn nums3(s: &str) -> Option<[f64; 3]> {
- let v: Vec = s.split_whitespace().filter_map(|t| t.parse().ok()).collect();
- (v.len() >= 3).then(|| [v[0], v[1], v[2]])
-}
-
-fn parse_cc(block: &str) -> Cdl {
- let mut c = Cdl::default();
- if let Some(s) = tag(block, "Slope").and_then(nums3) {
- c.slope = s;
- }
- if let Some(s) = tag(block, "Offset").and_then(nums3) {
- c.offset = s;
- }
- if let Some(s) = tag(block, "Power").and_then(nums3) {
- c.power = s;
- }
- if let Some(s) = tag(block, "Saturation").and_then(|t| t.trim().parse().ok()) {
- c.sat = s;
- }
- c
-}
-
-/// Parse ASC CDL XML (`.cc`, `.ccc`, `.cdl`): every `` with its `id`.
-pub fn parse_cdl_xml(xml: &str) -> Vec<(String, Cdl)> {
- let mut out = vec![];
- let mut rest = xml;
- while let Some(i) = rest.find("').unwrap_or(after.len());
- let head = &after[..head_end];
- let id = head
- .find("id=")
- .and_then(|k| {
- let q = head[k + 3..].chars().next()?;
- let s = &head[k + 4..];
- s.find(q).map(|e| s[..e].to_string())
- })
- .unwrap_or_default();
- let end = after.find("").map(|e| e + "".len()).unwrap_or(after.len());
- out.push((id, parse_cc(&after[..end])));
- rest = &after[end..];
- }
- out
-}
-
-// ---------------------------------------------------------------- LUT files
-
-/// A loaded transform file.
-#[derive(Clone, Debug)]
-pub enum FileXform {
- /// A lattice/1D LUT with an optional per-channel piecewise-linear shaper (cineSpace pre-LUT).
- Lut { lut: Lut, shaper: Option<[Vec<(f32, f32)>; 3]> },
- /// CDL corrections by id (in file order).
- Cdl(Vec<(String, Cdl)>),
- /// A matrix with offset (Sony Imageworks `.spimtx`), as a MatrixTransform's.
- Matrix { m: [f64; 16], offset: [f64; 4] },
-}
-
-/// Parse a Sony Imageworks `.spimtx` matrix: three rows of four numbers, three matrix columns
-/// and an offset in 16-bit code values (÷ 65535).
-pub fn parse_spimtx(text: &str) -> Option {
- let v: Vec = text.split_whitespace().map(|t| t.parse().ok()).collect::>()?;
- if v.len() != 12 || v.iter().any(|x| !x.is_finite()) {
- return None;
- }
- let mut m = [0.0; 16];
- let mut offset = [0.0; 4];
- for (r, row) in v.as_chunks::<4>().0.iter().enumerate() {
- m[r * 4..r * 4 + 3].copy_from_slice(&row[..3]);
- offset[r] = row[3] / 65535.0;
- }
- m[15] = 1.0;
- Some(FileXform::Matrix { m, offset })
-}
-
-/// Parse a Sony Imageworks `.spi1d` 1D LUT: `From `, `Length `, `Components
-/// <1 | 3>`, then `{` the values `}`.
-pub fn parse_spi1d(text: &str) -> Option {
- let (mut from, mut len, mut comps) = ([0.0f32, 1.0], 0usize, 1usize);
- let mut values: Vec = vec![];
- let mut body = false;
- for line in text.lines().map(str::trim).filter(|l| !l.is_empty()) {
- if body {
- if line.starts_with('}') {
- break;
- }
- for t in line.split_whitespace() {
- values.push(t.parse().ok()?);
- }
- continue;
- }
- let mut t = line.split_whitespace();
- match t.next()? {
- "{" => body = true,
- "From" => from = [t.next()?.parse().ok()?, t.next()?.parse().ok()?],
- "Length" => len = t.next()?.parse().ok()?,
- "Components" => comps = t.next()?.parse().ok()?,
- _ => {}
- }
- }
- // A 1D table is interpolated by index, so cap it like the lattices (2²⁴ entries).
- if !(2..=1 << 24).contains(&len)
- || !matches!(comps, 1 | 3)
- || values.len() != len.checked_mul(comps)?
- || from[1] <= from[0]
- || from.iter().any(|v| !v.is_finite())
- {
- return None;
- }
- let d1 = values.chunks_exact(comps).map(|c| if comps == 3 { [c[0], c[1], c[2]] } else { [c[0]; 3] }).collect();
- Some(Lut { n1: len, d1, n3: 0, d3: vec![], dmin: [from[0]; 3], dmax: [from[1]; 3] })
-}
-
-/// Parse a Sony Imageworks `.spi3d` lattice: `SPILUT 1.0`, `3 3`, the sizes, then one
-/// `r g b R G B` line per lattice point (indices, then the colour).
-pub fn parse_spi3d(text: &str) -> Option {
- let mut lines = text.lines().map(str::trim).filter(|l| !l.is_empty());
- if !lines.next()?.starts_with("SPILUT") {
- return None;
- }
- lines.next()?;
- let size: Vec = lines.next()?.split_whitespace().map(|t| t.parse().ok()).collect::>()?;
- let n = *size.first()?;
- if size.len() != 3 || size.iter().any(|s| *s != n) || !(2..=129).contains(&n) {
- return None;
- }
- let mut d3 = vec![[0.0f32; 3]; n * n * n];
- let mut seen = 0usize;
- for line in lines {
- let v: Vec<&str> = line.split_whitespace().collect();
- let [r, g, b, cr, cg, cb] = v.as_slice() else { return None };
- let (r, g, b): (usize, usize, usize) = (r.parse().ok()?, g.parse().ok()?, b.parse().ok()?);
- if r >= n || g >= n || b >= n {
- return None;
- }
- // Our lattice is red fastest.
- *d3.get_mut(r + g * n + b * n * n)? = [cr.parse().ok()?, cg.parse().ok()?, cb.parse().ok()?];
- seen += 1;
- }
- (seen == n * n * n).then_some(Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] })
-}
-
-/// Parse an Autodesk `.3dl` lattice (integers, blue fastest; an optional input-mesh line).
-pub fn parse_3dl(text: &str) -> Option {
- let mut mesh: Option> = None;
- let mut rows: Vec<[f64; 3]> = vec![];
- let mut out_bits: Option = None;
- for line in text.lines() {
- let l = line.trim();
- if l.is_empty() || l.starts_with('#') || l.starts_with('<') {
- continue;
- }
- if l.starts_with(|c: char| c.is_ascii_alphabetic()) {
- // "Mesh " (Lustre header); other keywords are ignored.
- let t: Vec<&str> = l.split_whitespace().collect();
- if t[0].eq_ignore_ascii_case("mesh") && t.len() >= 3 {
- out_bits = t[2].parse().ok();
- }
- continue;
- }
- let v: Vec = l.split_whitespace().filter_map(|t| t.parse().ok()).collect();
- if v.len() > 3 && mesh.is_none() && rows.is_empty() {
- mesh = Some(v);
- } else if v.len() == 3 {
- rows.push([v[0], v[1], v[2]]);
- } else {
- return None;
- }
- }
- let is_cube = |k: usize| {
- let n = (k as f64).cbrt().round() as usize;
- n * n * n == k
- };
- // A 3-entry input mesh (3³ lattice) looks like a data row: tell them apart by the count.
- if mesh.is_none() && !is_cube(rows.len()) && rows.len() == 28 {
- mesh = Some(rows.remove(0).to_vec());
- }
- let n = match &mesh {
- Some(m) => m.len(),
- None => (rows.len() as f64).cbrt().round() as usize,
- };
- if n < 2 || rows.len() != n * n * n {
- return None;
- }
- let maxv = rows.iter().flat_map(|r| r.iter()).fold(0.0f64, |m, &v| m.max(v));
- let out_max = match out_bits {
- Some(b) if b > 0 && b < 32 => (1u64 << b) as f64 - 1.0,
- _ => [255.0, 1023.0, 4095.0, 65535.0].into_iter().find(|&m| maxv <= m).unwrap_or(maxv.max(1.0)),
- };
- // .3dl rows: red slowest, blue fastest. Our lattice is red fastest.
- let mut d3 = vec![[0.0f32; 3]; n * n * n];
- for (k, r) in rows.iter().enumerate() {
- let (ri, gi, bi) = (k / (n * n), (k / n) % n, k % n);
- d3[ri + gi * n + bi * n * n] = r.map(|v| (v / out_max) as f32);
- }
- Some(Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] })
-}
-
-/// Parse a cineSpace `.csp` LUT (1D or 3D, with its three pre-LUT shapers).
-pub fn parse_csp(text: &str) -> Option<(Lut, [Vec<(f32, f32)>; 3])> {
- let mut lines = text.lines().map(str::trim).filter(|l| !l.is_empty());
- if !lines.next()?.starts_with("CSPLUTV100") {
- return None;
- }
- let kind = lines.next()?;
- let mut lines = lines.peekable();
- if lines.peek().is_some_and(|l| l.starts_with("BEGIN METADATA")) {
- for l in lines.by_ref() {
- if l.starts_with("END METADATA") {
- break;
- }
- }
- }
- let nums = |l: &str| -> Option> { l.split_whitespace().map(|t| t.parse().ok()).collect() };
- let mut shaper: [Vec<(f32, f32)>; 3] = Default::default();
- for ch in shaper.iter_mut() {
- let n: usize = lines.next()?.parse().ok()?;
- let ins = nums(lines.next()?)?;
- let outs = nums(lines.next()?)?;
- if ins.len() != n || outs.len() != n || n < 2 {
- return None;
- }
- *ch = ins.into_iter().zip(outs).collect();
- }
- if kind.starts_with("3D") {
- let sz = nums(lines.next()?)?;
- if sz.len() != 3 || sz[0] != sz[1] || sz[1] != sz[2] {
- return None;
- }
- let n = sz[0] as usize;
- let mut d3 = Vec::with_capacity(n * n * n);
- for _ in 0..n * n * n {
- let v = nums(lines.next()?)?;
- if v.len() != 3 {
- return None;
- }
- d3.push([v[0], v[1], v[2]]);
- }
- (n >= 2).then_some((Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] }, shaper))
- } else {
- let n: usize = lines.next()?.parse().ok()?;
- let mut d1 = Vec::with_capacity(n);
- for _ in 0..n {
- let v = nums(lines.next()?)?;
- if v.len() != 3 {
- return None;
- }
- d1.push([v[0], v[1], v[2]]);
- }
- (n >= 2).then_some((Lut { n1: n, d1, n3: 0, d3: vec![], dmin: [0.0; 3], dmax: [1.0; 3] }, shaper))
- }
-}
-
-fn shape(curve: &[(f32, f32)], x: f32) -> f32 {
- if curve.len() < 2 {
- return x;
- }
- let i = curve.partition_point(|p| p.0 < x).clamp(1, curve.len() - 1);
- let (a, b) = (curve[i - 1], curve[i]);
- let t = ((x - a.0) / (b.0 - a.0).max(1e-12)).clamp(0.0, 1.0);
- a.1 + (b.1 - a.1) * t
-}
-
-fn shape_inv(curve: &[(f32, f32)], y: f32) -> f32 {
- let flipped: Vec<(f32, f32)> = curve.iter().map(|&(a, b)| (b, a)).collect();
- shape(&flipped, y)
-}
-
-/// Parse transform text by its format (detected from `ext` or the content).
-pub fn parse_file(text: &str, ext: &str) -> Option {
- let ext = ext.to_ascii_lowercase();
- if ext == "cc" || ext == "ccc" || ext == "cdl" || text.contains(">>>;
-
-/// Load (and cache) a transform from a file path or inline content.
-pub fn load_file(src: &str) -> Option> {
- let src_t = src.trim();
- if src_t.is_empty() {
- return None;
- }
- static CACHE: OnceLock = OnceLock::new();
- let cache = CACHE.get_or_init(|| Mutex::new(HashMap::new()));
- if let Ok(m) = cache.lock()
- && let Some(v) = m.get(src)
- {
- return v.clone();
- }
- let inline = src.contains('\n');
- let parsed = if inline {
- parse_file(src, "")
- } else {
- let ext = std::path::Path::new(src_t).extension().and_then(std::ffi::OsStr::to_str).unwrap_or("");
- std::fs::read_to_string(src_t).ok().and_then(|t| parse_file(&t, ext))
- }
- .map(Arc::new);
- if let Ok(mut m) = cache.lock() {
- m.insert(src.to_string(), parsed.clone());
- }
- parsed
-}
-
-impl FileXform {
- pub fn apply(&self, c: [f32; 3], interp: u32, inverse: bool, ccc_id: &str) -> [f32; 3] {
- match self {
- FileXform::Cdl(list) => {
- let cdl = list.iter().find(|(id, _)| !ccc_id.is_empty() && id == ccc_id).or(list.first()).map(|(_, c)| *c).unwrap_or_default();
- let c64 = c.map(|v| v as f64);
- let o = if inverse { cdl.invert(c64, true) } else { cdl.apply(c64, true) };
- o.map(|v| v as f32)
- }
- FileXform::Matrix { m, offset } => crate::ocio_config::matrix_apply(m, offset, c.map(|v| v as f64), inverse).map(|v| v as f32),
- FileXform::Lut { lut, shaper } => {
- let fwd = |c: [f32; 3]| {
- let c = match shaper {
- Some(s) => [shape(&s[0], c[0]), shape(&s[1], c[1]), shape(&s[2], c[2])],
- None => c,
- };
- lut.apply_interp(c, interp)
- };
- if !inverse {
- return fwd(c);
- }
- if lut.n3 == 0 {
- // 1D: invert each channel exactly through the (monotone) tables.
- let mut x = c;
- if lut.n1 > 1 {
- x = [0, 1, 2].map(|i| {
- let curve: Vec<(f32, f32)> =
- (0..lut.n1).map(|k| (lut.d1[k][i], lut.dmin[i] + (lut.dmax[i] - lut.dmin[i]) * k as f32 / (lut.n1 - 1) as f32)).collect();
- shape(&curve, c[i])
- });
- }
- if let Some(s) = shaper {
- x = [shape_inv(&s[0], x[0]), shape_inv(&s[1], x[1]), shape_inv(&s[2], x[2])];
- }
- return x;
- }
- // 3D: damped fixed-point (Newton with an identity Jacobian) from the target.
- let mut x = c;
- for _ in 0..40 {
- let y = fwd(x);
- let e = [c[0] - y[0], c[1] - y[1], c[2] - y[2]];
- if e.iter().all(|v| v.abs() < 1e-6) {
- break;
- }
- x = [x[0] + e[0], x[1] + e[1], x[2] + e[2]];
- }
- x
- }
- }
- }
-}
-
-// ---------------------------------------------------------------- displays, views and looks
-
-/// Displays of the built-in config: (name, display primaries/white, encoding).
-pub const DISPLAYS: &[(&str, [[f64; 2]; 3], Tf)] =
- &[("sRGB", REC709, Tf::Srgb), ("Rec.1886 Rec.709", REC709, Tf::Gamma(2.4)), ("Display P3", P3, Tf::Srgb), ("Rec.2100-PQ", REC2020, Tf::Pq)];
-
-pub const VIEWS: &[&str] = &["Standard", "Tone Mapped", "Raw"];
-
-/// Configuration popup: the built-in config, or a custom `.ocio` file (Config File: a path or
-/// the config's text; spaces chosen by name, see [`crate::ocio_config`]).
-pub const CONFIGS: &[&str] = &["Built-in (EffectCraft minimal)", "Custom (.ocio file)"];
-
-/// Built-in looks: CDLs applied in ACEScct.
-pub fn looks() -> Vec<(&'static str, Cdl)> {
- let grey = 0.413_588_402_492_442_1; // ACEScct of 0.18
- let c = |slope: [f64; 3], offset: [f64; 3], sat: f64| Cdl { slope, offset, power: [1.0; 3], sat };
- vec![
- ("Warm", c([1.04, 1.0, 0.94], [0.0; 3], 1.0)),
- ("Cool", c([0.95, 1.0, 1.06], [0.0; 3], 1.0)),
- ("High Contrast", c([1.25; 3], [grey * (1.0 - 1.25); 3], 1.0)),
- ("Low Contrast", c([0.8; 3], [grey * (1.0 - 0.8); 3], 1.0)),
- ("Desaturated", c([1.0; 3], [0.0; 3], 0.6)),
- ("Vivid", c([1.0; 3], [0.0; 3], 1.3)),
- ]
-}
-
-/// Extended Reinhard roll-off (white point 16): maps 0..∞ into 0..1, ≈ identity near 0.
-fn tonemap(v: f64) -> f64 {
- let w2 = 256.0;
- if v <= 0.0 { v } else { v * (1.0 + v / w2) / (1.0 + v) }
-}
-
-fn tonemap_inv(y: f64) -> f64 {
- if y <= 0.0 {
- return y;
- }
- // Solve v² / w² + v (1 − y) − y = 0.
- let (a, b, c) = (1.0 / 256.0, 1.0 - y, -y);
- (-b + (b * b - 4.0 * a * c).sqrt()) / (2.0 * a)
-}
-
-/// Display transform of an input-space colour (`inverse`: display code values → input space).
-pub fn display_xform(input: &Space, display: usize, view: usize, inverse: bool) -> impl Fn([f32; 3]) -> [f32; 3] + Sync {
- let (_, prims, tf) = DISPLAYS[display.min(DISPLAYS.len() - 1)];
- let disp = Space { name: "display", prims: Some((prims, D65)), tf: Tf::Linear, raw: false };
- let raw = view == 2 || input.raw;
- let m_in = Xform::new(&Space { tf: Tf::Linear, ..*input }, &disp);
- let m_out = Xform::new(&disp, &Space { tf: Tf::Linear, ..*input });
- let in_tf = input.tf;
- move |c: [f32; 3]| {
- if raw {
- return c;
- }
- if !inverse {
- let lin = c.map(|v| in_tf.decode(v as f64) as f32);
- let d = m_in.apply(lin);
- d.map(|v| {
- let v = v as f64;
- let v = if view == 1 { tonemap(v) } else { v };
- tf.encode(v) as f32
- })
- } else {
- let d = c.map(|v| {
- let l = tf.decode(v as f64);
- (if view == 1 { tonemap_inv(l) } else { l }) as f32
- });
- m_out.apply(d).map(|v| in_tf.encode(v as f64) as f32)
- }
- }
-}
-
-// ---------------------------------------------------------------- effects
-
-fn spec(id: &'static str, name: &'static str, cat: &'static str, params: Vec, render: crate::RenderFn) -> EffectSpec {
- EffectSpec { id, name, category: cat, params, render, gpu: false, float: true }
-}
-
-fn space_param(id: &'static str, name: &'static str, default: u32) -> crate::ParamSpec {
- p(id, name, Value::Enum(default), popup(&space_names()))
-}
-
-fn direction() -> crate::ParamSpec {
- p("direction", "Direction", Value::Enum(0), popup(&["Forward", "Inverse"]))
-}
-
-fn map_px(b: &mut Buf, f: impl Fn([f32; 3]) -> [f32; 3] + Sync) {
- b.img.data.par_iter_mut().for_each(|px| {
- let (c, a) = unpremul(*px);
- if a <= 0.0 {
- return;
- }
- let o = f(c);
- *px = [o[0] * a, o[1] * a, o[2] * a, a];
- });
-}
-
-fn space_at(i: u32) -> &'static Space {
- &SPACES[(i as usize).min(SPACES.len() - 1)]
-}
-
-/// The effects that take Configuration ▸ Custom (a `.ocio` file).
-pub(crate) const CUSTOM_CONFIG_FX: [&str; 2] = ["ec.color.ociocolorspace", "ec.color.ociodisplay"];
-
-/// Effect `id`'s transform under Configuration ▸ Custom: the config's conversion from the source
-/// space to the destination space (Color Space Transform) or through a display's view (Display
-/// Transform), see [`crate::ocio_config`]. `Ok(None)` with the built-in configuration; an error
-/// (the pixels pass through) when the config can't be read or has no such colour space.
-fn custom_xf(id: &str, pr: &crate::Params) -> Result, String> {
- use crate::ocio_config::Xf;
- if !CUSTOM_CONFIG_FX.contains(&id) || pr.e("config") != 1 {
- return Ok(None);
- }
- let cfg = crate::ocio_config::load_config(pr.s("configFile")).map_err(|e| format!("Can't read the OCIO config: {e}"))?;
- // A space by its typed name, else by the built-in popup's name.
- let space = |name: &str, popup: u32| {
- let name = if name.trim().is_empty() { space_at(popup).name } else { name.trim() };
- cfg.space(name).ok_or_else(|| format!("The OCIO config has no color space `{name}`"))
- };
- let a = space(pr.s("sourceName"), pr.e("source"))?;
- let inverse = pr.e("direction") == 1;
- if id == "ec.color.ociodisplay" {
- let (dn, vn) = display_view_names(pr);
- let xf = cfg.display_path(a, dn, vn);
- return Ok(Some(if inverse { Xf::Inverse(Box::new(xf)) } else { xf }));
- }
- let z = space(pr.s("destinationName"), pr.e("destination"))?;
- // Inverse: the conversion the other way (OCIO's inverse ColorSpaceTransform).
- Ok(Some(if inverse { cfg.path(z, a) } else { cfg.path(a, z) }))
-}
-
-/// The display and view a Display Transform names: the typed names, else the popups'.
-fn display_view_names(pr: &crate::Params) -> (&str, &str) {
- let display = DISPLAYS.get(pr.e("display") as usize).map_or("", |d| d.0);
- let view = VIEWS.get(pr.e("view") as usize).copied().unwrap_or("");
- let typed = |k: &str, popup| if pr.s(k).trim().is_empty() { popup } else { pr.s(k).trim() };
- (typed("displayName", display), typed("viewName", view))
-}
-
-/// Effect Controls' warning for effect `id`: a custom OCIO configuration that can't be read, has
-/// no such colour space, display or view, or uses transforms EffectCraft can't apply (colours
-/// pass through those steps, #410). `None` when the effect renders as asked.
-pub fn warning(id: &str, pr: &crate::Params) -> Option {
- let xf = match custom_xf(id, pr) {
- Ok(x) => x?,
- Err(e) => return Some(format!("{e}: the colors pass through.")),
- };
- let mut notes = vec![];
- if id == "ec.color.ociodisplay"
- && let Ok(cfg) = crate::ocio_config::load_config(pr.s("configFile"))
- {
- let (dn, vn) = display_view_names(pr);
- if let Some((d, v)) = cfg.view(dn, vn)
- && (!d.eq_ignore_ascii_case(dn) || !v.name.eq_ignore_ascii_case(vn))
- {
- notes.push(format!("The OCIO config has no display `{dn}` with a view `{vn}`: showing {d} / {}.", v.name));
- }
- }
- let missing = xf.unsupported_list();
- if !missing.is_empty() {
- notes.push(format!("Not supported, the colors pass through: {}.", missing.join(", ")));
- }
- (!notes.is_empty()).then(|| notes.join(" "))
-}
-
-/// Configuration ▸ Custom: render through the config's transform. `false` with the built-in
-/// configuration (the caller renders it).
-fn custom_render(id: &str, ctx: &EffectCtx, b: &mut Buf) -> bool {
- match custom_xf(id, ctx.params) {
- Ok(None) => false,
- Ok(Some(xf)) => {
- map_px(b, |c| xf.apply(c.map(|v| v as f64), false).map(|v| v as f32));
- true
- }
- // A config that can't be read, or an unknown space: the pixels pass through.
- Err(_) => true,
- }
-}
-
-fn ocio_cst(ctx: &EffectCtx, mut b: Buf) -> Buf {
- if custom_render("ec.color.ociocolorspace", ctx, &mut b) {
- return b;
- }
- let (a, z) = (space_at(ctx.params.e("source")), space_at(ctx.params.e("destination")));
- let (a, z) = if ctx.params.e("direction") == 1 { (z, a) } else { (a, z) };
- if a.name == z.name {
- return b;
- }
- let x = Xform::new(a, z);
- map_px(&mut b, |c| x.apply(c));
- b
-}
-
-fn cdl_from_params(pr: &crate::Params) -> Cdl {
- Cdl {
- slope: [pr.f("slopeRed"), pr.f("slopeGreen"), pr.f("slopeBlue")],
- offset: [pr.f("offsetRed"), pr.f("offsetGreen"), pr.f("offsetBlue")],
- power: [pr.f("powerRed").max(0.0), pr.f("powerGreen").max(0.0), pr.f("powerBlue").max(0.0)],
- sat: pr.f("saturation").max(0.0),
- }
-}
-
-fn ocio_cdl(ctx: &EffectCtx, mut b: Buf) -> Buf {
- let cdl = cdl_from_params(ctx.params);
- if cdl == Cdl::default() {
- return b;
- }
- let clamp = ctx.params.e("style") == 0;
- let inv = ctx.params.e("direction") == 1;
- map_px(&mut b, |c| {
- let c = c.map(|v| v as f64);
- let o = if inv { cdl.invert(c, clamp) } else { cdl.apply(c, clamp) };
- o.map(|v| v as f32)
- });
- b
-}
-
-fn ocio_display(ctx: &EffectCtx, mut b: Buf) -> Buf {
- if custom_render("ec.color.ociodisplay", ctx, &mut b) {
- return b;
- }
- let input = space_at(ctx.params.e("source"));
- let f = display_xform(input, ctx.params.e("display") as usize, ctx.params.e("view") as usize, ctx.params.e("direction") == 1);
- map_px(&mut b, f);
- b
-}
-
-fn ocio_file(ctx: &EffectCtx, mut b: Buf) -> Buf {
- let Some(x) = load_file(ctx.params.s("file")) else { return b };
- let interp = match ctx.params.e("interpolation") {
- 0 => 0,
- 1 => 1,
- _ => 2,
- };
- let inv = ctx.params.e("direction") == 1;
- let id = ctx.params.s("cccId").to_string();
- map_px(&mut b, |c| x.apply(c, interp, inv, &id));
- b
-}
-
-/// Parse a looks string: comma/space separated names, `-Name` = inverse.
-pub fn parse_looks(s: &str) -> Vec<(Cdl, bool)> {
- let all = looks();
- s.split([',', ':'])
- .map(str::trim)
- .filter(|t| !t.is_empty())
- .filter_map(|t| {
- let (inv, n) = match t.strip_prefix('-') {
- Some(r) => (true, r.trim()),
- None => (false, t.trim_start_matches('+').trim()),
- };
- all.iter().find(|(name, _)| name.eq_ignore_ascii_case(n)).map(|(_, c)| (*c, inv))
- })
- .collect()
-}
-
-fn ocio_look(ctx: &EffectCtx, mut b: Buf) -> Buf {
- let mut list = parse_looks(ctx.params.s("looks"));
- let pick = ctx.params.e("look");
- if pick > 0
- && let Some((_, c)) = looks().get(pick as usize - 1)
- {
- list.insert(0, (*c, false));
- }
- if list.is_empty() {
- return b;
- }
- let (src, dst) = (space_at(ctx.params.e("source")), space_at(ctx.params.e("destination")));
- let inv = ctx.params.e("direction") == 1;
- let cct = &ACES_CCT;
- let (a, z) = if inv { (dst, src) } else { (src, dst) };
- let to_p = Xform::new(a, cct);
- let from_p = Xform::new(cct, z);
- if inv {
- list.reverse();
- }
- map_px(&mut b, |c| {
- let mut v = to_p.apply(c).map(|x| x as f64);
- for (cdl, li) in &list {
- v = if *li != inv { cdl.invert(v, false) } else { cdl.apply(v, false) };
- }
- from_p.apply(v.map(|x| x as f32))
- });
- b
-}
-
-// ---- Color Profile Converter (Utility)
-
-pub const PROFILES: &[&str] = &["Project Working Space", "sRGB IEC61966-2.1", "HDTV (Rec. 709)", "Rec. 2020", "Display P3", "ACEScg", "ACES2065-1"];
-
-fn profile(ctx: &EffectCtx, i: u32) -> (Space, bool) {
- let ws = |cs: ColorSpace| match cs {
- ColorSpace::Srgb => sp("sRGB", REC709, D65, Tf::Srgb),
- ColorSpace::Rec709 => sp("Rec.709", REC709, D65, Tf::Gamma(2.4)),
- ColorSpace::Rec2020 => sp("Rec.2020", REC2020, D65, Tf::Gamma(2.4)),
- ColorSpace::DisplayP3 => sp("Display P3", P3, D65, Tf::Srgb),
- ColorSpace::AcesCg => ACES_CG,
- ColorSpace::Aces2065 => ACES2065_1,
- // HDR encodings are output spaces, never a working space.
- ColorSpace::Rec2100Pq | ColorSpace::Rec2100Hlg => sp("Rec.2020", REC2020, D65, Tf::Gamma(2.4)),
- };
- match i {
- 0 => (ws(ctx.env.working_space.unwrap_or(ColorSpace::Srgb)), ctx.env.working_linear),
- 1 => (ws(ColorSpace::Srgb), false),
- 2 => (ws(ColorSpace::Rec709), false),
- 3 => (ws(ColorSpace::Rec2020), false),
- 4 => (ws(ColorSpace::DisplayP3), false),
- 5 => (ACES_CG, true),
- _ => (ACES2065_1, true),
- }
-}
-
-/// Gamut compression for the perceptual intent: pull out-of-gamut (negative) colours toward
-/// their luminance just enough to bring every channel to ≥ 0, rolling off smoothly.
-fn compress_gamut(c: [f64; 3], luma: [f64; 3]) -> [f64; 3] {
- let l = c[0] * luma[0] + c[1] * luma[1] + c[2] * luma[2];
- if l <= 0.0 {
- return c.map(|v| v.max(0.0));
- }
- let mn = c.iter().cloned().fold(f64::INFINITY, f64::min);
- if mn >= 0.0 {
- return c;
- }
- // Fraction of the way toward grey that reaches zero on the most negative channel.
- let t = (l / (l - mn)).clamp(0.0, 1.0);
- c.map(|v| l + (v - l) * t)
-}
-
-fn profile_converter(ctx: &EffectCtx, mut b: Buf) -> Buf {
- let (inp, in_lin_default) = profile(ctx, ctx.params.e("inputProfile"));
- let (out, out_lin_default) = profile(ctx, ctx.params.e("outputProfile"));
- let in_lin = ctx.params.b("linearizeInputProfile") || in_lin_default && ctx.params.e("inputProfile") == 0;
- let out_lin = ctx.params.b("linearizeOutputProfile") || out_lin_default && ctx.params.e("outputProfile") == 0;
- let intent = ctx.params.e("intent");
- let dec = if in_lin { Tf::Linear } else { inp.tf };
- let enc = if out_lin { Tf::Linear } else { out.tf };
- // Absolute colorimetric keeps the source white (no adaptation); the others adapt.
- let m = if intent == 3 { mul(&invert(&out.to_ref(false)), &inp.to_ref(false)) } else { matrix(&inp, &out) };
- let identity = dec == enc && (0..3).all(|i| (0..3).all(|j| (m[i][j] - IDENTITY[i][j]).abs() < 1e-9));
- if identity {
- return b;
- }
- let out_luma = out.to_ref(true)[1];
- map_px(&mut b, |c| {
- let l = c.map(|v| dec.decode(v as f64));
- let mut o = mul_vec(&m, l);
- match intent {
- 0 => o = compress_gamut(o, out_luma),
- 2 => o = o.map(|v| v.max(0.0)),
- _ => {}
- }
- o.map(|v| enc.encode(v) as f32)
- });
- b
-}
-
-// ---- Colour programs (the GPU compositor's colour-management kernels)
-
-/// One per-pixel step of a colour transform, in the order the CPU effect applies them (see
-/// [`color_program`]).
-#[derive(Clone, Debug)]
-pub enum ColorOp {
- /// Transfer function, encoded → linear.
- Decode(Tf),
- /// Transfer function, linear → encoded.
- Encode(Tf),
- /// Linear-RGB matrix.
- Matrix([[f32; 3]; 3]),
- /// ASC CDL (forward or exact inverse; `clamp` = the v1.2 style).
- Cdl { cdl: Cdl, clamp: bool, inverse: bool },
- /// The Tone Mapped view's roll-off (or its inverse).
- Tonemap { inverse: bool },
- /// Color Profile Converter's perceptual gamut compression toward luminance `luma`.
- Gamut([f64; 3]),
- /// Negative channels to 0 (the saturation intent).
- Max0,
- /// A LUT (0 nearest, 1 trilinear, 2 tetrahedral) with an optional per-channel shaper, forward
- /// or inverse (as [`FileXform::apply`]).
- Lut { lut: Arc, shaper: Option; 3]>>, interp: u32, inverse: bool },
- /// `m × (c + pre) + post` (a custom config's MatrixTransform and RangeTransform).
- Affine { m: [[f32; 3]; 3], pre: [f32; 3], post: [f32; 3] },
- /// `max(c, 0) ^ p` per channel (ExponentTransform).
- Pow([f32; 3]),
- /// LogTransform / LogAffineTransform, forward or inverse (as `ocio_config::Xf::apply`).
- LogAffine { base: f32, log_slope: [f32; 3], log_offset: [f32; 3], lin_slope: [f32; 3], lin_offset: [f32; 3], inverse: bool },
- /// ExponentWithLinearTransform, forward (decode) or inverse (as
- /// [`crate::ocio_config::moncurve`]).
- MonCurve { gamma: [f32; 3], offset: [f32; 3], inverse: bool, mirror: bool },
- /// Clamp each channel to `lo..=hi` (a clamping RangeTransform; ±`f32::MAX` = unbounded).
- Clamp { lo: [f32; 3], hi: [f32; 3] },
-}
-
-/// The ops of a matrix-and-offset transform (MatrixTransform, `.spimtx`), forward or inverse
-/// (as [`crate::ocio_config::matrix_apply`]).
-fn matrix_ops(m: &[f64; 16], offset: &[f64; 4], inverse: bool, ops: &mut Vec) {
- if !inverse {
- let m = [0, 1, 2].map(|r| [m[r * 4] as f32, m[r * 4 + 1] as f32, m[r * 4 + 2] as f32]);
- ops.push(ColorOp::Affine { m, pre: [0.0; 3], post: [offset[0] as f32, offset[1] as f32, offset[2] as f32] });
- } else if let Some(inv) = crate::ocio_config::mat3_inverse(m) {
- let m = inv.map(|r| r.map(|v| v as f32));
- ops.push(ColorOp::Affine { m, pre: [-offset[0] as f32, -offset[1] as f32, -offset[2] as f32], post: [0.0; 3] });
- }
-}
-
-/// The ops of a LUT / CDL / matrix file transform (as [`FileXform::apply`]).
-fn file_ops(x: &FileXform, interp: u32, inverse: bool, ccc_id: &str, ops: &mut Vec) {
- match x {
- FileXform::Cdl(list) => {
- let cdl = list.iter().find(|(i, _)| !ccc_id.is_empty() && i == ccc_id).or(list.first()).map(|(_, c)| *c).unwrap_or_default();
- ops.push(ColorOp::Cdl { cdl, clamp: true, inverse });
- }
- FileXform::Lut { lut, shaper } => {
- ops.push(ColorOp::Lut { lut: Arc::new(lut.clone()), shaper: shaper.clone().map(Arc::new), interp, inverse });
- }
- FileXform::Matrix { m, offset } => matrix_ops(m, offset, inverse, ops),
- }
-}
-
-/// The ops of a custom config's transform `x` (as `Xf::apply`).
-fn config_xf_ops(x: &crate::ocio_config::Xf, inverse: bool, ops: &mut Vec) {
- use crate::ocio_config::Xf;
- let f3 = |v: &[f64; 3]| v.map(|x| x as f32);
- match x {
- Xf::Inverse(x) => config_xf_ops(x, !inverse, ops),
- Xf::Matrix { m, offset } => matrix_ops(m, offset, inverse, ops),
- Xf::File { xf: Some(x), interp, ccc, .. } => file_ops(x, *interp, inverse, ccc, ops),
- Xf::ExponentLinear { gamma, offset, mirror } => ops.push(ColorOp::MonCurve { gamma: f3(gamma), offset: f3(offset), inverse, mirror: *mirror }),
- // A BuiltinTransform's curve: forward decodes.
- Xf::Curve(tf) => ops.push(if inverse { ColorOp::Encode(*tf) } else { ColorOp::Decode(*tf) }),
- Xf::Named(_) => {}
- Xf::File { xf: None, .. } | Xf::Unsupported(_) => {}
- Xf::Exponent(e) => ops.push(ColorOp::Pow([0, 1, 2].map(|k| (if inverse { 1.0 / e[k].max(1e-9) } else { e[k] }) as f32))),
- Xf::Log { base } => {
- ops.push(ColorOp::LogAffine { base: *base as f32, log_slope: [1.0; 3], log_offset: [0.0; 3], lin_slope: [1.0; 3], lin_offset: [0.0; 3], inverse })
- }
- Xf::LogAffine { base, log_slope, log_offset, lin_slope, lin_offset } => ops.push(ColorOp::LogAffine {
- base: *base as f32,
- log_slope: f3(log_slope),
- log_offset: f3(log_offset),
- lin_slope: f3(lin_slope),
- lin_offset: f3(lin_offset),
- inverse,
- }),
- Xf::Cdl(cdl) => ops.push(ColorOp::Cdl { cdl: *cdl, clamp: true, inverse }),
- Xf::Range(r) => {
- let (k, off, lo, hi) = r.parts(inverse);
- let k = k as f32;
- ops.push(ColorOp::Affine { m: [[k, 0.0, 0.0], [0.0, k, 0.0], [0.0, 0.0, k]], pre: [0.0; 3], post: [off as f32; 3] });
- if lo.is_finite() || hi.is_finite() {
- let bound = |v: f64| (v as f32).clamp(-f32::MAX, f32::MAX);
- ops.push(ColorOp::Clamp { lo: [bound(lo); 3], hi: [bound(hi); 3] });
- }
- }
- Xf::Group(list) => {
- if inverse {
- list.iter().rev().for_each(|x| config_xf_ops(x, true, ops));
- } else {
- list.iter().for_each(|x| config_xf_ops(x, false, ops));
- }
- }
- }
-}
-
-/// How a colour program meets premultiplied pixels.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Straight {
- /// `unpremul` (colour 0 below alpha 1e-6); fully transparent pixels untouched (OCIO effects).
- Unpremul,
- /// Colour ÷ alpha; fully transparent pixels untouched (`Image::map_straight`, Apply Color LUT).
- Divide,
-}
-
-fn xform_ops(x: &Xform, ops: &mut Vec) {
- if x.dec != Tf::Linear {
- ops.push(ColorOp::Decode(x.dec));
- }
- if !x.ident {
- ops.push(ColorOp::Matrix(x.m));
- }
- if x.enc != Tf::Linear {
- ops.push(ColorOp::Encode(x.enc));
- }
-}
-
-/// Effect `id`'s per-pixel transform as a list of [`ColorOp`]s that reproduces the CPU effect
-/// (empty = the layer passes through; custom OCIO configs compile their transforms too). `None`
-/// for another effect.
-pub fn color_program(id: &str, ctx: &EffectCtx) -> Option<(Vec, Straight)> {
- let pr = ctx.params;
- let mut ops = vec![];
- // Configuration ▸ Custom compiles the config's transforms (a config that can't be read, or
- // names unknown spaces, passes the pixels through).
- match custom_xf(id, pr) {
- Ok(None) => {}
- Ok(Some(xf)) => {
- config_xf_ops(&xf, false, &mut ops);
- return Some((ops, Straight::Unpremul));
- }
- Err(_) => return Some((ops, Straight::Unpremul)),
- }
- match id {
- "ec.utility.applylut" => {
- if let Some(lut) = crate::utility::load_lut(pr.s("lut")) {
- ops.push(ColorOp::Lut { lut, shaper: None, interp: 2, inverse: false });
- }
- return Some((ops, Straight::Divide));
- }
- "ec.color.ociocolorspace" => {
- let (a, z) = (space_at(pr.e("source")), space_at(pr.e("destination")));
- let (a, z) = if pr.e("direction") == 1 { (z, a) } else { (a, z) };
- if a.name != z.name {
- xform_ops(&Xform::new(a, z), &mut ops);
- }
- }
- "ec.color.ociocdl" => {
- let cdl = cdl_from_params(pr);
- if cdl != Cdl::default() {
- ops.push(ColorOp::Cdl { cdl, clamp: pr.e("style") == 0, inverse: pr.e("direction") == 1 });
- }
- }
- "ec.color.ociodisplay" => {
- let input = space_at(pr.e("source"));
- let (display, view, inverse) = (pr.e("display") as usize, pr.e("view") as usize, pr.e("direction") == 1);
- let (_, prims, tf) = DISPLAYS[display.min(DISPLAYS.len() - 1)];
- if view != 2 && !input.raw {
- let disp = Space { name: "display", prims: Some((prims, D65)), tf: Tf::Linear, raw: false };
- let lin = Space { tf: Tf::Linear, ..*input };
- if !inverse {
- ops.push(ColorOp::Decode(input.tf));
- xform_ops(&Xform::new(&lin, &disp), &mut ops);
- if view == 1 {
- ops.push(ColorOp::Tonemap { inverse: false });
- }
- ops.push(ColorOp::Encode(tf));
- } else {
- ops.push(ColorOp::Decode(tf));
- if view == 1 {
- ops.push(ColorOp::Tonemap { inverse: true });
- }
- xform_ops(&Xform::new(&disp, &lin), &mut ops);
- ops.push(ColorOp::Encode(input.tf));
- }
- }
- }
- "ec.color.ociofile" => {
- if let Some(x) = load_file(pr.s("file")) {
- let interp = match pr.e("interpolation") {
- 0 => 0,
- 1 => 1,
- _ => 2,
- };
- file_ops(&x, interp, pr.e("direction") == 1, pr.s("cccId"), &mut ops);
- }
- }
- "ec.color.ociolook" => {
- let mut list = parse_looks(pr.s("looks"));
- let pick = pr.e("look");
- if pick > 0
- && let Some((_, c)) = looks().get(pick as usize - 1)
- {
- list.insert(0, (*c, false));
- }
- if !list.is_empty() {
- let (src, dst) = (space_at(pr.e("source")), space_at(pr.e("destination")));
- let inv = pr.e("direction") == 1;
- let cct = &ACES_CCT;
- let (a, z) = if inv { (dst, src) } else { (src, dst) };
- if inv {
- list.reverse();
- }
- xform_ops(&Xform::new(a, cct), &mut ops);
- for (cdl, li) in &list {
- ops.push(ColorOp::Cdl { cdl: *cdl, clamp: false, inverse: *li != inv });
- }
- xform_ops(&Xform::new(cct, z), &mut ops);
- }
- }
- "ec.utility.colorprofileconverter" => {
- let (inp, in_lin_default) = profile(ctx, pr.e("inputProfile"));
- let (out, out_lin_default) = profile(ctx, pr.e("outputProfile"));
- let in_lin = pr.b("linearizeInputProfile") || in_lin_default && pr.e("inputProfile") == 0;
- let out_lin = pr.b("linearizeOutputProfile") || out_lin_default && pr.e("outputProfile") == 0;
- let intent = pr.e("intent");
- let dec = if in_lin { Tf::Linear } else { inp.tf };
- let enc = if out_lin { Tf::Linear } else { out.tf };
- let m = if intent == 3 { mul(&invert(&out.to_ref(false)), &inp.to_ref(false)) } else { matrix(&inp, &out) };
- let identity = dec == enc && (0..3).all(|i| (0..3).all(|j| (m[i][j] - IDENTITY[i][j]).abs() < 1e-9));
- if !identity {
- ops.push(ColorOp::Decode(dec));
- ops.push(ColorOp::Matrix(m.map(|r| r.map(|v| v as f32))));
- match intent {
- 0 => ops.push(ColorOp::Gamut(out.to_ref(true)[1])),
- 2 => ops.push(ColorOp::Max0),
- _ => {}
- }
- ops.push(ColorOp::Encode(enc));
- }
- }
- _ => return None,
- }
- Some((ops, Straight::Unpremul))
-}
-
-// ---- Color Stabilizer
-
-/// Mean straight colour of a square (half-size `r` layer pixels) around layer point `pt`.
-fn sample_mean(b: &Buf, pt: [f64; 2], r: f64) -> [f64; 3] {
- let (cx, cy) = b.to_px(pt);
- let rr = (r * b.scale).max(0.5);
- let (x0, x1) = ((cx - rr).floor().max(0.0) as i64, ((cx + rr).ceil() as i64).min(b.img.width as i64));
- let (y0, y1) = ((cy - rr).floor().max(0.0) as i64, ((cy + rr).ceil() as i64).min(b.img.height as i64));
- let mut acc = [0.0f64; 4];
- for y in y0..y1 {
- for x in x0..x1 {
- let p = b.img.get(x, y);
- for k in 0..4 {
- acc[k] += p[k] as f64;
- }
- }
- }
- if acc[3] <= 1e-9 {
- return [0.0; 3];
- }
- [acc[0] / acc[3], acc[1] / acc[3], acc[2] / acc[3]]
-}
-
-/// Monotone piecewise-quadratic curve through (0,0), three samples and (1,1) (linear between
-/// them is enough for a stabiliser and stays monotone).
-fn curve3(xs: [f64; 3], ys: [f64; 3], v: f64) -> f64 {
- let mut pts = vec![(0.0, 0.0)];
- let mut pairs: Vec<(f64, f64)> = xs.iter().cloned().zip(ys.iter().cloned()).collect();
- pairs.sort_by(|a, b| a.0.total_cmp(&b.0));
- for (x, y) in pairs {
- if pts.last().is_some_and(|l| x > l.0 + 1e-4) && x < 1.0 - 1e-4 {
- pts.push((x, y));
- }
- }
- pts.push((1.0, 1.0));
- let i = pts.partition_point(|p| p.0 < v).clamp(1, pts.len() - 1);
- let (a, c) = (pts[i - 1], pts[i]);
- a.1 + (c.1 - a.1) * (v - a.0) / (c.0 - a.0).max(1e-9)
-}
-
-/// Color Stabilizer's correction of buffer `b` as one piecewise-linear map per channel (points
-/// with increasing x; the end segments extend), the same maps [`color_stabilizer`] applies.
-/// `None` without a host or reference frame (the layer passes through). (The GPU effect.)
-pub fn color_stabilizer_maps(ctx: &EffectCtx, b: &Buf) -> Option<[Vec<(f64, f64)>; 3]> {
- let reference = ctx.env.host?.self_at(ctx.params.f("referenceFrame"), ctx.env.effect_index)?;
- let r = ctx.params.f("sampleSize").max(0.5);
- let pts = [ctx.params.v2("blackPoint"), ctx.params.v2("midPoint"), ctx.params.v2("whitePoint")];
- let cur = pts.map(|pt| sample_mean(b, pt, r));
- let refv = pts.map(|pt| sample_mean(&reference, pt, r));
- let mode = ctx.params.e("stabilize");
- Some([0, 1, 2].map(|k| {
- let offset = |c0: f64, r0: f64| vec![(0.0, r0 - c0), (1.0, 1.0 + r0 - c0)];
- match mode {
- 0 => offset(cur[0][k], refv[0][k]),
- 1 => {
- let (c0, c1, r0, r1) = (cur[0][k], cur[2][k], refv[0][k], refv[2][k]);
- if (c1 - c0).abs() < 1e-6 {
- offset(c0, r0)
- } else if c0 < c1 {
- vec![(c0, r0), (c1, r1)]
- } else {
- vec![(c1, r1), (c0, r0)]
- }
- }
- _ => {
- let mut v = vec![(0.0, 0.0)];
- let mut pairs: Vec<(f64, f64)> = (0..3).map(|i| (cur[i][k], refv[i][k])).collect();
- pairs.sort_by(|a, b| a.0.total_cmp(&b.0));
- for (x, y) in pairs {
- if v.last().is_some_and(|l| x > l.0 + 1e-4) && x < 1.0 - 1e-4 {
- v.push((x, y));
- }
- }
- v.push((1.0, 1.0));
- v
- }
- }
- }))
-}
-
-fn color_stabilizer(ctx: &EffectCtx, mut b: Buf) -> Buf {
- let Some(host) = ctx.env.host else { return b };
- let Some(reference) = host.self_at(ctx.params.f("referenceFrame"), ctx.env.effect_index) else { return b };
- let r = ctx.params.f("sampleSize").max(0.5);
- let pts = [ctx.params.v2("blackPoint"), ctx.params.v2("midPoint"), ctx.params.v2("whitePoint")];
- let cur = pts.map(|pt| sample_mean(&b, pt, r));
- let refv = pts.map(|pt| sample_mean(&reference, pt, r));
- let mode = ctx.params.e("stabilize");
- map_px(&mut b, |c| {
- [0, 1, 2].map(|k| {
- let v = c[k] as f64;
- let o = match mode {
- // Brightness: one sample (black point) — offset each channel.
- 0 => v + refv[0][k] - cur[0][k],
- // Levels: black and white samples — linear map per channel.
- 1 => {
- let (c0, c1, r0, r1) = (cur[0][k], cur[2][k], refv[0][k], refv[2][k]);
- if (c1 - c0).abs() < 1e-6 { v + r0 - c0 } else { r0 + (v - c0) * (r1 - r0) / (c1 - c0) }
- }
- // Curves: three samples — a curve through them per channel.
- _ => curve3([cur[0][k], cur[1][k], cur[2][k]], [refv[0][k], refv[1][k], refv[2][k]], v),
- };
- o as f32
- })
- });
- b
-}
-
-fn sl(lo: f64, hi: f64, smin: f64, smax: f64) -> ParamUi {
- slider(lo, hi, smin, smax, 3)
-}
-
-pub fn specs() -> Vec {
- let cc = "Color Correction";
- let srgb = SPACES.iter().position(|s| s.name == "sRGB").unwrap_or(0) as u32;
- let lin709 = SPACES.iter().position(|s| s.name == "Linear Rec.709 (sRGB)").unwrap_or(0) as u32;
- let acescg = SPACES.iter().position(|s| s.name == "ACEScg").unwrap_or(0) as u32;
- let mut look_opts = vec!["None"];
- look_opts.extend(looks().iter().map(|(n, _)| *n));
- vec![
- spec(
- "ec.color.ociocdl",
- "OCIO CDL Transform",
- cc,
- vec![
- p("slopeRed", "Slope Red", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
- p("slopeGreen", "Slope Green", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
- p("slopeBlue", "Slope Blue", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
- p("offsetRed", "Offset Red", num(0.0), sl(-100.0, 100.0, -1.0, 1.0)),
- p("offsetGreen", "Offset Green", num(0.0), sl(-100.0, 100.0, -1.0, 1.0)),
- p("offsetBlue", "Offset Blue", num(0.0), sl(-100.0, 100.0, -1.0, 1.0)),
- p("powerRed", "Power Red", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
- p("powerGreen", "Power Green", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
- p("powerBlue", "Power Blue", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
- p("saturation", "Saturation", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
- p("style", "Style", Value::Enum(0), popup(&["ASC CDL v1.2", "No Clamp"])),
- direction(),
- ],
- ocio_cdl,
- ),
- spec(
- "ec.color.ociocolorspace",
- "OCIO Color Space Transform",
- cc,
- vec![
- p("config", "Configuration", Value::Enum(0), popup(CONFIGS)),
- p("configFile", "Config File (.ocio)", Value::Str(String::new()), crate::file_ui(&["ocio"])),
- space_param("source", "Source", lin709),
- p("sourceName", "Source (config name)", Value::Str(String::new()), ParamUi::Text),
- space_param("destination", "Destination", srgb),
- p("destinationName", "Destination (config name)", Value::Str(String::new()), ParamUi::Text),
- direction(),
- ],
- ocio_cst,
- ),
- spec(
- "ec.color.ociodisplay",
- "OCIO Display Transform",
- cc,
- vec![
- p("config", "Configuration", Value::Enum(0), popup(CONFIGS)),
- p("configFile", "Config File (.ocio)", Value::Str(String::new()), crate::file_ui(&["ocio"])),
- space_param("source", "Input Color Space", lin709),
- p("sourceName", "Source (config name)", Value::Str(String::new()), ParamUi::Text),
- p("display", "Display Device", Value::Enum(0), popup(&DISPLAYS.iter().map(|d| d.0).collect::>())),
- p("displayName", "Display (config name)", Value::Str(String::new()), ParamUi::Text),
- p("view", "View Transform", Value::Enum(0), popup(VIEWS)),
- p("viewName", "View (config name)", Value::Str(String::new()), ParamUi::Text),
- direction(),
- ],
- ocio_display,
- ),
- // `file`: a path to a .cube/.3dl/.csp/.cc/.ccc/.cdl file, or the file's text itself.
- spec(
- "ec.color.ociofile",
- "OCIO File Transform",
- cc,
- vec![
- p("file", "File", Value::Str(String::new()), crate::file_ui(&["cube", "3dl", "csp", "cc", "ccc", "cdl", "spi1d", "spi3d", "spimtx"])),
- p("cccId", "CCC ID", Value::Str(String::new()), ParamUi::Text),
- p("interpolation", "Interpolation", Value::Enum(3), popup(&["Nearest", "Linear", "Tetrahedral", "Best"])),
- direction(),
- ],
- ocio_file,
- ),
- spec(
- "ec.color.ociolook",
- "OCIO Look Transform",
- cc,
- vec![
- p("config", "Configuration", Value::Enum(0), popup(&["Built-in (EffectCraft minimal)"])),
- space_param("source", "Source", acescg),
- space_param("destination", "Destination", acescg),
- p("look", "Look", Value::Enum(0), popup(&look_opts)),
- p("looks", "Looks", Value::Str(String::new()), ParamUi::Text),
- direction(),
- ],
- ocio_look,
- ),
- spec(
- "ec.color.colorstabilizer",
- "Color Stabilizer",
- cc,
- vec![
- // The pivot frame (After Effects' Set Frame button stores it).
- p("referenceFrame", "Reference Frame (s)", num(0.0), slider(-100000.0, 100000.0, 0.0, 60.0, 2)),
- p("stabilize", "Stabilize", Value::Enum(0), popup(&["Brightness", "Levels", "Curves"])),
- p("blackPoint", "Black Point", Value::Vec2([0.25, 0.75]), ParamUi::Point),
- p("midPoint", "Mid Point", Value::Vec2([0.5, 0.5]), ParamUi::Point),
- p("whitePoint", "White Point", Value::Vec2([0.75, 0.25]), ParamUi::Point),
- p("sampleSize", "Sample Size", num(5.0), slider(1.0, 100.0, 1.0, 50.0, 0)),
- ],
- color_stabilizer,
- ),
- spec(
- "ec.utility.colorprofileconverter",
- "Color Profile Converter",
- "Utility",
- vec![
- p("inputProfile", "Input Profile", Value::Enum(0), popup(PROFILES)),
- p("linearizeInputProfile", "Linearize Input Profile", Value::Bool(false), ParamUi::Checkbox),
- p("outputProfile", "Output Profile", Value::Enum(1), popup(PROFILES)),
- p("linearizeOutputProfile", "Linearize Output Profile", Value::Bool(false), ParamUi::Checkbox),
- p("intent", "Intent", Value::Enum(1), popup(&["Perceptual", "Relative Colorimetric", "Saturation", "Absolute Colorimetric"])),
- // Our built-in profiles share a zero black point and none is scene-referred, so
- // these two are kept for compatibility and do not change the result.
- p("useBlackPointCompensation", "Use Black Point Compensation", Value::Bool(true), ParamUi::Checkbox),
- p("sceneRefCompensation", "Scene-ref. Profile Compensation", Value::Enum(2), popup(&["On", "Off", "Use Project Setting"])),
- ],
- profile_converter,
- ),
- ]
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use crate::{EffectEnv, EffectHost, Image, LayerPixels, run_fx};
-
- fn close(a: M3, b: M3, tol: f64) {
- for i in 0..3 {
- for j in 0..3 {
- assert!((a[i][j] - b[i][j]).abs() < tol, "{a:?} vs {b:?}");
- }
- }
- }
-
- #[test]
- fn aces_matrices_match_published_values() {
- let ap0 = space_by_name("ACES2065-1").unwrap();
- let ap1 = space_by_name("ACEScg").unwrap();
- // Academy S-2014-004 AP0 → AP1.
- close(
- matrix(ap0, ap1),
- [
- [1.451_439_316_1, -0.236_510_746_9, -0.214_928_569_3],
- [-0.076_553_773_4, 1.176_229_699_8, -0.099_675_926_4],
- [0.008_316_148_4, -0.006_032_449_8, 0.997_716_301_4],
- ],
- 2e-4,
- );
- // ACEScg → linear Rec.709 with Bradford adaptation (published ACES config value).
- let lin = space_by_name("Linear Rec.709 (sRGB)").unwrap();
- close(matrix(ap1, lin), [[1.705_05, -0.621_79, -0.083_26], [-0.130_26, 1.140_80, -0.010_55], [-0.024_00, -0.128_97, 1.152_97]], 2e-3);
- // White maps to white.
- let w = mul_vec(&matrix(ap1, lin), [1.0, 1.0, 1.0]);
- assert!(w.iter().all(|v| (v - 1.0).abs() < 1e-3), "{w:?}");
- }
-
- #[test]
- fn transfer_functions_round_trip() {
- for tf in [Tf::Srgb, Tf::Gamma(2.4), Tf::AcesCct, Tf::Pq] {
- for v in [0.0, 0.001, 0.18, 0.5, 1.0, 4.0] {
- let r = tf.decode(tf.encode(v));
- assert!((r - v).abs() < 1e-6 * v.max(1.0), "{tf:?} {v} {r}");
- }
- }
- // ACEScct of 18 % grey (S-2016-001).
- assert!((Tf::AcesCct.encode(0.18) - 0.413_588).abs() < 1e-5);
- // PQ: 100 nits (1.0) encodes to ≈ 0.508.
- assert!((Tf::Pq.encode(1.0) - 0.508).abs() < 1e-3);
- }
-
- #[test]
- fn color_space_transform_effect_round_trips() {
- let img = Image::filled(4, 4, [0.2, 0.5, 0.7, 1.0]);
- let srgb = SPACES.iter().position(|s| s.name == "sRGB").unwrap() as u32;
- let cg = SPACES.iter().position(|s| s.name == "ACEScg").unwrap() as u32;
- let a = run_fx("ec.color.ociocolorspace", &[("source", Value::Enum(srgb)), ("destination", Value::Enum(cg))], img.clone(), 0.0, EffectEnv::default());
- assert_ne!(a.img.data, img.data);
- let b = run_fx("ec.color.ociocolorspace", &[("source", Value::Enum(cg)), ("destination", Value::Enum(srgb))], a.img.clone(), 0.0, EffectEnv::default());
- let c = run_fx(
- "ec.color.ociocolorspace",
- &[("source", Value::Enum(srgb)), ("destination", Value::Enum(cg)), ("direction", Value::Enum(1))],
- a.img,
- 0.0,
- EffectEnv::default(),
- );
- for (x, y) in b.img.data.iter().zip(&img.data).chain(c.img.data.iter().zip(&img.data)) {
- assert!((0..4).all(|k| (x[k] - y[k]).abs() < 1e-4), "{x:?} {y:?}");
- }
- }
-
- #[test]
- fn cdl_math() {
- let cdl = Cdl { slope: [1.2, 1.0, 0.8], offset: [0.05, 0.0, -0.02], power: [1.1, 1.0, 0.9], sat: 0.8 };
- let c = [0.3, 0.5, 0.7];
- // Hand computation of the v1.2 formula.
- let sop = [(0.3f64 * 1.2 + 0.05).powf(1.1), 0.5, (0.7f64 * 0.8 - 0.02).powf(0.9)];
- let l = sop[0] * 0.2126 + sop[1] * 0.7152 + sop[2] * 0.0722;
- let want = sop.map(|v| l + 0.8 * (v - l));
- let got = cdl.apply(c, true);
- for k in 0..3 {
- assert!((got[k] - want[k]).abs() < 1e-12);
- }
- let back = cdl.invert(got, true);
- for k in 0..3 {
- assert!((back[k] - c[k]).abs() < 1e-9);
- }
- // v1.2 clamps, No Clamp keeps negatives.
- let neg = Cdl { offset: [-0.5; 3], ..Cdl::default() };
- assert_eq!(neg.apply([0.2; 3], true), [0.0; 3]);
- assert!((neg.apply([0.2; 3], false)[0] + 0.3).abs() < 1e-12);
- let img = Image::filled(2, 2, [0.3, 0.5, 0.7, 1.0]);
- let out = run_fx("ec.color.ociocdl", &[("slopeRed", num(1.2)), ("offsetRed", num(0.05)), ("powerRed", num(1.1))], img, 0.0, EffectEnv::default());
- let r = (0.3f64 * 1.2 + 0.05).powf(1.1);
- assert!((out.img.get(0, 0)[0] as f64 - r).abs() < 1e-5);
- }
-
- fn identity_lattice(n: usize, f: impl Fn([f32; 3]) -> [f32; 3]) -> Vec<[f32; 3]> {
- let mut v = vec![];
- for b in 0..n {
- for g in 0..n {
- for r in 0..n {
- let s = (n - 1) as f32;
- v.push(f([r as f32 / s, g as f32 / s, b as f32 / s]));
- }
- }
- }
- v
- }
-
- /// Sony Imageworks `.spi1d`, `.spi3d` and `.spimtx` (Blender's configs use them, #410), and
- /// malformed ones rejected without panicking.
- #[test]
- fn spi_files_parse() {
- let spi1d = "Version 1\nFrom 0.0 2.0\nLength 3\nComponents 1\n{\n0.0\n0.25\n1.0\n}\n";
- let x = parse_file(spi1d, "spi1d").unwrap();
- let o = x.apply([1.0, 0.5, 2.0], 1, false, "");
- assert!((o[0] - 0.25).abs() < 1e-6 && (o[1] - 0.125).abs() < 1e-6 && (o[2] - 1.0).abs() < 1e-6, "{o:?}");
- let back = x.apply(o, 1, true, "");
- assert!((back[0] - 1.0).abs() < 1e-5 && (back[2] - 2.0).abs() < 1e-5, "{back:?}");
- let three = parse_spi1d("Version 1\nFrom 0 1\nLength 2\nComponents 3\n{\n0 0 0\n1 0.5 2\n}\n").unwrap();
- assert_eq!(three.d1, vec![[0.0; 3], [1.0, 0.5, 2.0]]);
- let mut spi3d = String::from("SPILUT 1.0\n3 3\n2 2 2\n");
- for (r, g, b) in (0..8).map(|i| (i & 1, (i >> 1) & 1, i >> 2)) {
- spi3d += &format!("{r} {g} {b} {} {} {}\n", r as f32 * 0.5, g, b);
- }
- let x = parse_file(&spi3d, "spi3d").unwrap();
- let o = x.apply([1.0, 0.5, 0.25], 1, false, "");
- assert!((o[0] - 0.5).abs() < 1e-6 && (o[1] - 0.5).abs() < 1e-6 && (o[2] - 0.25).abs() < 1e-6, "{o:?}");
- let m = parse_file("2 0 0 6553.5\n0 1 0 0\n0 0 1 0\n", "spimtx").unwrap();
- let o = m.apply([0.25, 0.5, 1.0], 1, false, "");
- assert!((o[0] - 0.6).abs() < 1e-6 && o[1] == 0.5 && o[2] == 1.0, "{o:?}");
- assert!((m.apply(o, 1, true, "")[0] - 0.25).abs() < 1e-6);
- for bad in [
- "Version 1\nFrom 0 1\nLength 99999999999\nComponents 1\n{\n0\n}\n",
- "Version 1\nFrom 1 0\nLength 2\nComponents 1\n{\n0\n1\n}\n",
- "Version 1\nFrom 0 1\nLength 3\nComponents 1\n{\n0\n1\n}\n",
- "Version 1\nFrom 0 1\nLength 2\nComponents 2\n{\n0 0\n1 1\n}\n",
- ] {
- assert!(parse_spi1d(bad).is_none(), "{bad}");
- }
- assert!(parse_spi3d("SPILUT 1.0\n3 3\n4000 4000 4000\n").is_none());
- assert!(parse_spi3d("SPILUT 1.0\n3 3\n2 2 2\n9 0 0 1 1 1\n").is_none());
- assert!(parse_spi3d("SPILUT 1.0\n3 3\n2 2 2\n0 0 0 1 1 1\n").is_none(), "incomplete lattice");
- assert!(parse_spimtx("1 0 0\n0 1 0\n").is_none());
- assert!(parse_spimtx("NaN 0 0 0 0 1 0 0 0 0 1 0").is_none());
- }
-
- #[test]
- fn lut_files_parse_and_interpolate() {
- // .cube with a non-linear lattice: trilinear between lattice points.
- let f = |c: [f32; 3]| [c[0] * c[0], c[1], 1.0 - c[2]];
- let mut cube = String::from("LUT_3D_SIZE 3\n");
- for r in identity_lattice(3, f) {
- cube += &format!("{} {} {}\n", r[0], r[1], r[2]);
- }
- let Some(FileXform::Lut { lut, .. }) = parse_file(&cube, "cube") else { panic!() };
- // Trilinear between 0.5 (0.25) and 1.0 (1.0) at 0.75 → 0.625.
- let o = lut.apply_interp([0.75, 0.3, 0.2], 1);
- assert!((o[0] - 0.625).abs() < 1e-6 && (o[1] - 0.3).abs() < 1e-6 && (o[2] - 0.8).abs() < 1e-6, "{o:?}");
- // Nearest snaps.
- assert_eq!(lut.apply_interp([0.74, 0.0, 0.0], 0)[0], 0.25);
- // .3dl (blue fastest, 10-bit integers, mesh line).
- let mut tdl = String::from("0 511 1023\n");
- for r in 0..3 {
- for g in 0..3 {
- for b in 0..3 {
- let v = [r, g, b].map(|i| i as f64 * 511.5);
- tdl += &format!("{} {} {}\n", v[0].round(), v[1].round(), (1023.0 - v[2]).round());
- }
- }
- }
- let Some(FileXform::Lut { lut, .. }) = parse_file(&tdl, "3dl") else { panic!() };
- let o = lut.apply_interp([0.25, 0.5, 0.25], 1);
- assert!((o[0] - 0.25).abs() < 2e-3 && (o[1] - 0.5).abs() < 2e-3 && (o[2] - 0.75).abs() < 2e-3, "{o:?}");
- // .csp with a squaring pre-LUT on red and an identity 2³ lattice.
- let mut csp = String::from("CSPLUTV100\n3D\n\n3\n0 0.5 1\n0 0.25 1\n2\n0 1\n0 1\n2\n0 1\n0 1\n\n2 2 2\n");
- for r in identity_lattice(2, |c| c) {
- csp += &format!("{} {} {}\n", r[0], r[1], r[2]);
- }
- let x = parse_file(&csp, "csp").unwrap();
- let o = x.apply([0.5, 0.4, 0.6], 2, false, "");
- assert!((o[0] - 0.25).abs() < 1e-6 && (o[1] - 0.4).abs() < 1e-6, "{o:?}");
- let inv = x.apply(o, 2, true, "");
- assert!((inv[0] - 0.5).abs() < 1e-4, "{inv:?}");
- // CDL collection: pick by id.
- let ccc = r#"2 2 20 0 01 1 1
- 0.5 0.5 0.51"#;
- let x = parse_file(ccc, "ccc").unwrap();
- assert!((x.apply([0.4; 3], 2, false, "b")[0] - 0.2).abs() < 1e-6);
- assert!((x.apply([0.4; 3], 2, false, "a")[0] - 0.8).abs() < 1e-6);
- assert!((x.apply([0.4; 3], 2, false, "")[0] - 0.8).abs() < 1e-6);
- // Effect with inline content; inverse of a 3D lattice.
- let img = Image::filled(2, 2, [0.6, 0.3, 0.2, 1.0]);
- let out = run_fx("ec.color.ociofile", &[("file", Value::Str(cube.clone()))], img.clone(), 0.0, EffectEnv::default());
- let back = run_fx("ec.color.ociofile", &[("file", Value::Str(cube)), ("direction", Value::Enum(1))], out.img, 0.0, EffectEnv::default());
- assert!((back.img.get(0, 0)[0] - 0.6).abs() < 1e-3, "{:?}", back.img.get(0, 0));
- assert!(parse_file("garbage", "3dl").is_none());
- }
-
- #[test]
- fn display_and_look_transforms() {
- // Linear 0.18 through the sRGB display / Standard view = sRGB encoding of 0.18.
- let img = Image::filled(2, 2, [0.18, 0.18, 0.18, 1.0]);
- let out = run_fx("ec.color.ociodisplay", &[], img.clone(), 0.0, EffectEnv::default());
- assert!((out.img.get(0, 0)[0] as f64 - Tf::Srgb.encode(0.18)).abs() < 1e-5);
- let back = run_fx("ec.color.ociodisplay", &[("direction", Value::Enum(1))], out.img, 0.0, EffectEnv::default());
- assert!((back.img.get(0, 0)[0] - 0.18).abs() < 1e-5);
- // Tone mapped view keeps highlights below 1.
- let hot = Image::filled(1, 1, [8.0, 8.0, 8.0, 1.0]);
- let tm = run_fx("ec.color.ociodisplay", &[("view", Value::Enum(1))], hot, 0.0, EffectEnv::default());
- assert!(tm.img.get(0, 0)[0] < 1.0);
- assert!((tonemap_inv(tonemap(3.0)) - 3.0).abs() < 1e-9);
- // Looks: Warm raises red over blue; its inverse undoes it.
- let grey = Image::filled(1, 1, [0.18, 0.18, 0.18, 1.0]);
- let w = run_fx("ec.color.ociolook", &[("looks", Value::Str("Warm".into()))], grey.clone(), 0.0, EffectEnv::default());
- let px = w.img.get(0, 0);
- assert!(px[0] > px[2]);
- let u = run_fx("ec.color.ociolook", &[("looks", Value::Str("-Warm".into()))], w.img, 0.0, EffectEnv::default());
- assert!((u.img.get(0, 0)[0] - 0.18).abs() < 1e-4 && (u.img.get(0, 0)[2] - 0.18).abs() < 1e-4);
- assert_eq!(parse_looks("Warm, -Cool, nope").len(), 2);
- }
-
- #[test]
- fn profile_converter_converts_and_round_trips() {
- let img = Image::filled(2, 2, [0.8, 0.4, 0.1, 1.0]);
- // sRGB → Rec. 2020 (relative), then back.
- let a = run_fx(
- "ec.utility.colorprofileconverter",
- &[("inputProfile", Value::Enum(1)), ("outputProfile", Value::Enum(3))],
- img.clone(),
- 0.0,
- EffectEnv::default(),
- );
- assert_ne!(a.img.data, img.data);
- let b = run_fx(
- "ec.utility.colorprofileconverter",
- &[("inputProfile", Value::Enum(3)), ("outputProfile", Value::Enum(1))],
- a.img,
- 0.0,
- EffectEnv::default(),
- );
- assert!((0..3).all(|k| (b.img.get(0, 0)[k] - img.get(0, 0)[k]).abs() < 1e-4));
- // Same profile both sides: identity. Working space defaults to sRGB.
- let c = run_fx(
- "ec.utility.colorprofileconverter",
- &[("inputProfile", Value::Enum(0)), ("outputProfile", Value::Enum(1))],
- img.clone(),
- 0.0,
- EffectEnv::default(),
- );
- assert_eq!(c.img.data, img.data);
- // Perceptual pulls out-of-gamut colours inside: saturated Rec.2020 green into sRGB.
- let g = Image::filled(1, 1, [0.0, 1.0, 0.0, 1.0]);
- let rel = run_fx(
- "ec.utility.colorprofileconverter",
- &[("inputProfile", Value::Enum(3)), ("outputProfile", Value::Enum(1))],
- g.clone(),
- 0.0,
- EffectEnv::default(),
- );
- assert!(rel.img.get(0, 0)[0] < 0.0);
- let per = run_fx(
- "ec.utility.colorprofileconverter",
- &[("inputProfile", Value::Enum(3)), ("outputProfile", Value::Enum(1)), ("intent", Value::Enum(0))],
- g,
- 0.0,
- EffectEnv::default(),
- );
- assert!(per.img.get(0, 0).iter().all(|v| *v >= -1e-6));
- }
-
- struct RefHost(Image);
- impl EffectHost for RefHost {
- fn layer(&self, _: u64, _: bool) -> Option {
- None
- }
- fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option> {
- None
- }
- fn self_at(&self, _: f64, _: usize) -> Option {
- Some(Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 })
- }
- }
-
- #[test]
- fn color_stabilizer_matches_the_reference_frame() {
- let mk = |k: f32, o: f32| {
- let mut img = Image::new(40, 40);
- for y in 0..40 {
- for x in 0..40 {
- let v = (x as f32 / 40.0) * k + o;
- img.set(x, y, [v, v * 0.9, v * 0.8, 1.0]);
- }
- }
- img
- };
- let reference = mk(1.0, 0.0);
- let flicker = mk(0.8, 0.1);
- let host = RefHost(reference.clone());
- let env = EffectEnv { host: Some(&host), ..Default::default() };
- let pts = [("blackPoint", Value::Vec2([5.0, 20.0])), ("midPoint", Value::Vec2([20.0, 20.0])), ("whitePoint", Value::Vec2([35.0, 20.0]))];
- let mut vals: Vec<(&str, Value)> = pts.to_vec();
- vals.push(("stabilize", Value::Enum(1)));
- vals.push(("sampleSize", num(1.0)));
- let out = run_fx("ec.color.colorstabilizer", &vals, flicker.clone(), 0.0, env);
- for x in [5i64, 20, 35] {
- let (o, r) = (out.img.get(x, 20), reference.get(x, 20));
- assert!((o[0] - r[0]).abs() < 0.01, "x {x}: {o:?} vs {r:?}");
- }
- // Deterministic, and a no-op without a host.
- let again = run_fx("ec.color.colorstabilizer", &vals, flicker.clone(), 0.0, env);
- assert_eq!(out.img.data, again.img.data);
- let none = run_fx("ec.color.colorstabilizer", &vals, flicker.clone(), 0.0, EffectEnv::default());
- assert_eq!(none.img.data, flicker.data);
- // Brightness mode corrects an offset at the black point.
- let lifted = mk(1.0, 0.1);
- let mut vals2: Vec<(&str, Value)> = pts.to_vec();
- vals2.push(("sampleSize", num(1.0)));
- let b = run_fx("ec.color.colorstabilizer", &vals2, lifted, 0.0, env);
- assert!((b.img.get(5, 20)[0] - reference.get(5, 20)[0]).abs() < 0.01);
- }
-}
+mod tests;
diff --git a/crates/effects/src/ocio/cdl.rs b/crates/effects/src/ocio/cdl.rs
new file mode 100644
index 000000000..1feab04a2
--- /dev/null
+++ b/crates/effects/src/ocio/cdl.rs
@@ -0,0 +1,115 @@
+use super::*;
+
+// ---------------------------------------------------------------- ASC CDL
+
+/// An ASC Colour Decision List correction.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Cdl {
+ pub slope: [f64; 3],
+ pub offset: [f64; 3],
+ pub power: [f64; 3],
+ pub sat: f64,
+}
+
+impl Default for Cdl {
+ fn default() -> Self {
+ Cdl { slope: [1.0; 3], offset: [0.0; 3], power: [1.0; 3], sat: 1.0 }
+ }
+}
+
+const LUMA: [f64; 3] = [0.2126, 0.7152, 0.0722];
+
+impl Cdl {
+ /// Forward CDL. `clamp` = the v1.2 style (results clamped to 0..1 after SOP and saturation).
+ pub fn apply(&self, c: [f64; 3], clamp: bool) -> [f64; 3] {
+ let mut o = [0.0; 3];
+ for i in 0..3 {
+ let v = c[i] * self.slope[i] + self.offset[i];
+ o[i] = if clamp {
+ v.clamp(0.0, 1.0).powf(self.power[i])
+ } else if v >= 0.0 {
+ v.powf(self.power[i])
+ } else {
+ v
+ };
+ }
+ let l = o[0] * LUMA[0] + o[1] * LUMA[1] + o[2] * LUMA[2];
+ let o = o.map(|v| l + self.sat * (v - l));
+ if clamp { o.map(|v| v.clamp(0.0, 1.0)) } else { o }
+ }
+ /// Exact inverse of [`Cdl::apply`] (inside the clamped range).
+ pub fn invert(&self, c: [f64; 3], clamp: bool) -> [f64; 3] {
+ let c = if clamp { c.map(|v| v.clamp(0.0, 1.0)) } else { c };
+ let l = c[0] * LUMA[0] + c[1] * LUMA[1] + c[2] * LUMA[2];
+ let s = if self.sat.abs() < 1e-9 { 1e-9 } else { self.sat };
+ let o = c.map(|v| l + (v - l) / s);
+ let mut r = [0.0; 3];
+ for i in 0..3 {
+ let v = if clamp { o[i].clamp(0.0, 1.0) } else { o[i] };
+ let pw = self.power[i].max(1e-9);
+ let u = if v >= 0.0 { v.powf(1.0 / pw) } else { v };
+ let sl = if self.slope[i].abs() < 1e-9 { 1e-9 } else { self.slope[i] };
+ r[i] = (u - self.offset[i]) / sl;
+ }
+ if clamp { r.map(|v| v.clamp(0.0, 1.0)) } else { r }
+ }
+}
+
+fn tag<'a>(xml: &'a str, name: &str) -> Option<&'a str> {
+ let open = xml.find(&format!("<{name}"))?;
+ let gt = open + xml[open..].find('>')?;
+ if xml[..gt].ends_with('/') {
+ return Some("");
+ }
+ let close = xml[gt..].find(&format!(""))? + gt;
+ Some(&xml[gt + 1..close])
+}
+
+fn nums3(s: &str) -> Option<[f64; 3]> {
+ let v: Vec = s.split_whitespace().filter_map(|t| t.parse().ok()).collect();
+ (v.len() >= 3).then(|| [v[0], v[1], v[2]])
+}
+
+fn parse_cc(block: &str) -> Cdl {
+ let mut c = Cdl::default();
+ if let Some(s) = tag(block, "Slope").and_then(nums3) {
+ c.slope = s;
+ }
+ if let Some(s) = tag(block, "Offset").and_then(nums3) {
+ c.offset = s;
+ }
+ if let Some(s) = tag(block, "Power").and_then(nums3) {
+ c.power = s;
+ }
+ if let Some(s) = tag(block, "Saturation").and_then(|t| t.trim().parse().ok()) {
+ c.sat = s;
+ }
+ c
+}
+
+/// Parse ASC CDL XML (`.cc`, `.ccc`, `.cdl`): every `` with its `id`.
+pub fn parse_cdl_xml(xml: &str) -> Vec<(String, Cdl)> {
+ let mut out = vec![];
+ let mut rest = xml;
+ while let Some(i) = rest.find("').unwrap_or(after.len());
+ let head = &after[..head_end];
+ let id = head
+ .find("id=")
+ .and_then(|k| {
+ let q = head[k + 3..].chars().next()?;
+ let s = &head[k + 4..];
+ s.find(q).map(|e| s[..e].to_string())
+ })
+ .unwrap_or_default();
+ let end = after.find("").map(|e| e + "".len()).unwrap_or(after.len());
+ out.push((id, parse_cc(&after[..end])));
+ rest = &after[end..];
+ }
+ out
+}
+
+pub(super) fn sl(lo: f64, hi: f64, smin: f64, smax: f64) -> ParamUi {
+ slider(lo, hi, smin, smax, 3)
+}
diff --git a/crates/effects/src/ocio/effects.rs b/crates/effects/src/ocio/effects.rs
new file mode 100644
index 000000000..7d07011a4
--- /dev/null
+++ b/crates/effects/src/ocio/effects.rs
@@ -0,0 +1,467 @@
+use super::cdl::Cdl;
+use super::lut::load_file;
+use super::space::{ACES_CCT, ACES_CG, ACES2065_1, D65, IDENTITY, P3, REC709, REC2020, SPACES, Space, Tf, Xform, matrix, sp, space_names};
+use super::*;
+
+// ---------------------------------------------------------------- displays, views and looks
+
+/// Displays of the built-in config: (name, display primaries/white, encoding).
+pub const DISPLAYS: &[(&str, [[f64; 2]; 3], Tf)] =
+ &[("sRGB", REC709, Tf::Srgb), ("Rec.1886 Rec.709", REC709, Tf::Gamma(2.4)), ("Display P3", P3, Tf::Srgb), ("Rec.2100-PQ", REC2020, Tf::Pq)];
+
+pub const VIEWS: &[&str] = &["Standard", "Tone Mapped", "Raw"];
+
+/// Configuration popup: the built-in config, or a custom `.ocio` file (Config File: a path or
+/// the config's text; spaces chosen by name, see [`crate::ocio_config`]).
+pub const CONFIGS: &[&str] = &["Built-in (EffectCraft minimal)", "Custom (.ocio file)"];
+
+/// Built-in looks: CDLs applied in ACEScct.
+pub fn looks() -> Vec<(&'static str, Cdl)> {
+ let grey = 0.413_588_402_492_442_1; // ACEScct of 0.18
+ let c = |slope: [f64; 3], offset: [f64; 3], sat: f64| Cdl { slope, offset, power: [1.0; 3], sat };
+ vec![
+ ("Warm", c([1.04, 1.0, 0.94], [0.0; 3], 1.0)),
+ ("Cool", c([0.95, 1.0, 1.06], [0.0; 3], 1.0)),
+ ("High Contrast", c([1.25; 3], [grey * (1.0 - 1.25); 3], 1.0)),
+ ("Low Contrast", c([0.8; 3], [grey * (1.0 - 0.8); 3], 1.0)),
+ ("Desaturated", c([1.0; 3], [0.0; 3], 0.6)),
+ ("Vivid", c([1.0; 3], [0.0; 3], 1.3)),
+ ]
+}
+
+/// Extended Reinhard roll-off (white point 16): maps 0..∞ into 0..1, ≈ identity near 0.
+pub(super) fn tonemap(v: f64) -> f64 {
+ let w2 = 256.0;
+ if v <= 0.0 { v } else { v * (1.0 + v / w2) / (1.0 + v) }
+}
+
+pub(super) fn tonemap_inv(y: f64) -> f64 {
+ if y <= 0.0 {
+ return y;
+ }
+ // Solve v² / w² + v (1 − y) − y = 0.
+ let (a, b, c) = (1.0 / 256.0, 1.0 - y, -y);
+ (-b + (b * b - 4.0 * a * c).sqrt()) / (2.0 * a)
+}
+
+/// Display transform of an input-space colour (`inverse`: display code values → input space).
+pub fn display_xform(input: &Space, display: usize, view: usize, inverse: bool) -> impl Fn([f32; 3]) -> [f32; 3] + Sync {
+ let (_, prims, tf) = DISPLAYS[display.min(DISPLAYS.len() - 1)];
+ let disp = Space { name: "display", prims: Some((prims, D65)), tf: Tf::Linear, raw: false };
+ let raw = view == 2 || input.raw;
+ let m_in = Xform::new(&Space { tf: Tf::Linear, ..*input }, &disp);
+ let m_out = Xform::new(&disp, &Space { tf: Tf::Linear, ..*input });
+ let in_tf = input.tf;
+ move |c: [f32; 3]| {
+ if raw {
+ return c;
+ }
+ if !inverse {
+ let lin = c.map(|v| in_tf.decode(v as f64) as f32);
+ let d = m_in.apply(lin);
+ d.map(|v| {
+ let v = v as f64;
+ let v = if view == 1 { tonemap(v) } else { v };
+ tf.encode(v) as f32
+ })
+ } else {
+ let d = c.map(|v| {
+ let l = tf.decode(v as f64);
+ (if view == 1 { tonemap_inv(l) } else { l }) as f32
+ });
+ m_out.apply(d).map(|v| in_tf.encode(v as f64) as f32)
+ }
+ }
+}
+
+// ---------------------------------------------------------------- effects
+
+pub(super) fn spec(id: &'static str, name: &'static str, cat: &'static str, params: Vec, render: crate::RenderFn) -> EffectSpec {
+ EffectSpec { id, name, category: cat, params, render, gpu: false, float: true }
+}
+
+pub(super) fn space_param(id: &'static str, name: &'static str, default: u32) -> crate::ParamSpec {
+ p(id, name, Value::Enum(default), popup(&space_names()))
+}
+
+pub(super) fn direction() -> crate::ParamSpec {
+ p("direction", "Direction", Value::Enum(0), popup(&["Forward", "Inverse"]))
+}
+
+fn map_px(b: &mut Buf, f: impl Fn([f32; 3]) -> [f32; 3] + Sync) {
+ b.img.data.par_iter_mut().for_each(|px| {
+ let (c, a) = unpremul(*px);
+ if a <= 0.0 {
+ return;
+ }
+ let o = f(c);
+ *px = [o[0] * a, o[1] * a, o[2] * a, a];
+ });
+}
+
+pub(super) fn space_at(i: u32) -> &'static Space {
+ &SPACES[(i as usize).min(SPACES.len() - 1)]
+}
+
+/// The effects that take Configuration ▸ Custom (a `.ocio` file).
+pub(crate) const CUSTOM_CONFIG_FX: [&str; 2] = ["ec.color.ociocolorspace", "ec.color.ociodisplay"];
+
+/// Effect `id`'s transform under Configuration ▸ Custom: the config's conversion from the source
+/// space to the destination space (Color Space Transform) or through a display's view (Display
+/// Transform), see [`crate::ocio_config`]. `Ok(None)` with the built-in configuration; an error
+/// (the pixels pass through) when the config can't be read or has no such colour space.
+pub(super) fn custom_xf(id: &str, pr: &crate::Params) -> Result, String> {
+ use crate::ocio_config::Xf;
+ if !CUSTOM_CONFIG_FX.contains(&id) || pr.e("config") != 1 {
+ return Ok(None);
+ }
+ let cfg = crate::ocio_config::load_config(pr.s("configFile")).map_err(|e| format!("Can't read the OCIO config: {e}"))?;
+ // A space by its typed name, else by the built-in popup's name.
+ let space = |name: &str, popup: u32| {
+ let name = if name.trim().is_empty() { space_at(popup).name } else { name.trim() };
+ cfg.space(name).ok_or_else(|| format!("The OCIO config has no color space `{name}`"))
+ };
+ let a = space(pr.s("sourceName"), pr.e("source"))?;
+ let inverse = pr.e("direction") == 1;
+ if id == "ec.color.ociodisplay" {
+ let (dn, vn) = display_view_names(pr);
+ let xf = cfg.display_path(a, dn, vn);
+ return Ok(Some(if inverse { Xf::Inverse(Box::new(xf)) } else { xf }));
+ }
+ let z = space(pr.s("destinationName"), pr.e("destination"))?;
+ // Inverse: the conversion the other way (OCIO's inverse ColorSpaceTransform).
+ Ok(Some(if inverse { cfg.path(z, a) } else { cfg.path(a, z) }))
+}
+
+/// The display and view a Display Transform names: the typed names, else the popups'.
+fn display_view_names(pr: &crate::Params) -> (&str, &str) {
+ let display = DISPLAYS.get(pr.e("display") as usize).map_or("", |d| d.0);
+ let view = VIEWS.get(pr.e("view") as usize).copied().unwrap_or("");
+ let typed = |k: &str, popup| if pr.s(k).trim().is_empty() { popup } else { pr.s(k).trim() };
+ (typed("displayName", display), typed("viewName", view))
+}
+
+/// Effect Controls' warning for effect `id`: a custom OCIO configuration that can't be read, has
+/// no such colour space, display or view, or uses transforms EffectCraft can't apply (colours
+/// pass through those steps, #410). `None` when the effect renders as asked.
+pub fn warning(id: &str, pr: &crate::Params) -> Option {
+ let xf = match custom_xf(id, pr) {
+ Ok(x) => x?,
+ Err(e) => return Some(format!("{e}: the colors pass through.")),
+ };
+ let mut notes = vec![];
+ if id == "ec.color.ociodisplay"
+ && let Ok(cfg) = crate::ocio_config::load_config(pr.s("configFile"))
+ {
+ let (dn, vn) = display_view_names(pr);
+ if let Some((d, v)) = cfg.view(dn, vn)
+ && (!d.eq_ignore_ascii_case(dn) || !v.name.eq_ignore_ascii_case(vn))
+ {
+ notes.push(format!("The OCIO config has no display `{dn}` with a view `{vn}`: showing {d} / {}.", v.name));
+ }
+ }
+ let missing = xf.unsupported_list();
+ if !missing.is_empty() {
+ notes.push(format!("Not supported, the colors pass through: {}.", missing.join(", ")));
+ }
+ (!notes.is_empty()).then(|| notes.join(" "))
+}
+
+/// Configuration ▸ Custom: render through the config's transform. `false` with the built-in
+/// configuration (the caller renders it).
+fn custom_render(id: &str, ctx: &EffectCtx, b: &mut Buf) -> bool {
+ match custom_xf(id, ctx.params) {
+ Ok(None) => false,
+ Ok(Some(xf)) => {
+ map_px(b, |c| xf.apply(c.map(|v| v as f64), false).map(|v| v as f32));
+ true
+ }
+ // A config that can't be read, or an unknown space: the pixels pass through.
+ Err(_) => true,
+ }
+}
+
+pub(super) fn ocio_cst(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ if custom_render("ec.color.ociocolorspace", ctx, &mut b) {
+ return b;
+ }
+ let (a, z) = (space_at(ctx.params.e("source")), space_at(ctx.params.e("destination")));
+ let (a, z) = if ctx.params.e("direction") == 1 { (z, a) } else { (a, z) };
+ if a.name == z.name {
+ return b;
+ }
+ let x = Xform::new(a, z);
+ map_px(&mut b, |c| x.apply(c));
+ b
+}
+
+pub(super) fn cdl_from_params(pr: &crate::Params) -> Cdl {
+ Cdl {
+ slope: [pr.f("slopeRed"), pr.f("slopeGreen"), pr.f("slopeBlue")],
+ offset: [pr.f("offsetRed"), pr.f("offsetGreen"), pr.f("offsetBlue")],
+ power: [pr.f("powerRed").max(0.0), pr.f("powerGreen").max(0.0), pr.f("powerBlue").max(0.0)],
+ sat: pr.f("saturation").max(0.0),
+ }
+}
+
+pub(super) fn ocio_cdl(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ let cdl = cdl_from_params(ctx.params);
+ if cdl == Cdl::default() {
+ return b;
+ }
+ let clamp = ctx.params.e("style") == 0;
+ let inv = ctx.params.e("direction") == 1;
+ map_px(&mut b, |c| {
+ let c = c.map(|v| v as f64);
+ let o = if inv { cdl.invert(c, clamp) } else { cdl.apply(c, clamp) };
+ o.map(|v| v as f32)
+ });
+ b
+}
+
+pub(super) fn ocio_display(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ if custom_render("ec.color.ociodisplay", ctx, &mut b) {
+ return b;
+ }
+ let input = space_at(ctx.params.e("source"));
+ let f = display_xform(input, ctx.params.e("display") as usize, ctx.params.e("view") as usize, ctx.params.e("direction") == 1);
+ map_px(&mut b, f);
+ b
+}
+
+pub(super) fn ocio_file(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ let Some(x) = load_file(ctx.params.s("file")) else { return b };
+ let interp = match ctx.params.e("interpolation") {
+ 0 => 0,
+ 1 => 1,
+ _ => 2,
+ };
+ let inv = ctx.params.e("direction") == 1;
+ let id = ctx.params.s("cccId").to_string();
+ map_px(&mut b, |c| x.apply(c, interp, inv, &id));
+ b
+}
+
+/// Parse a looks string: comma/space separated names, `-Name` = inverse.
+pub fn parse_looks(s: &str) -> Vec<(Cdl, bool)> {
+ let all = looks();
+ s.split([',', ':'])
+ .map(str::trim)
+ .filter(|t| !t.is_empty())
+ .filter_map(|t| {
+ let (inv, n) = match t.strip_prefix('-') {
+ Some(r) => (true, r.trim()),
+ None => (false, t.trim_start_matches('+').trim()),
+ };
+ all.iter().find(|(name, _)| name.eq_ignore_ascii_case(n)).map(|(_, c)| (*c, inv))
+ })
+ .collect()
+}
+
+pub(super) fn ocio_look(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ let mut list = parse_looks(ctx.params.s("looks"));
+ let pick = ctx.params.e("look");
+ if pick > 0
+ && let Some((_, c)) = looks().get(pick as usize - 1)
+ {
+ list.insert(0, (*c, false));
+ }
+ if list.is_empty() {
+ return b;
+ }
+ let (src, dst) = (space_at(ctx.params.e("source")), space_at(ctx.params.e("destination")));
+ let inv = ctx.params.e("direction") == 1;
+ let cct = &ACES_CCT;
+ let (a, z) = if inv { (dst, src) } else { (src, dst) };
+ let to_p = Xform::new(a, cct);
+ let from_p = Xform::new(cct, z);
+ if inv {
+ list.reverse();
+ }
+ map_px(&mut b, |c| {
+ let mut v = to_p.apply(c).map(|x| x as f64);
+ for (cdl, li) in &list {
+ v = if *li != inv { cdl.invert(v, false) } else { cdl.apply(v, false) };
+ }
+ from_p.apply(v.map(|x| x as f32))
+ });
+ b
+}
+
+// ---- Color Profile Converter (Utility)
+
+pub const PROFILES: &[&str] = &["Project Working Space", "sRGB IEC61966-2.1", "HDTV (Rec. 709)", "Rec. 2020", "Display P3", "ACEScg", "ACES2065-1"];
+
+pub(super) fn profile(ctx: &EffectCtx, i: u32) -> (Space, bool) {
+ let ws = |cs: ColorSpace| match cs {
+ ColorSpace::Srgb => sp("sRGB", REC709, D65, Tf::Srgb),
+ ColorSpace::Rec709 => sp("Rec.709", REC709, D65, Tf::Gamma(2.4)),
+ ColorSpace::Rec2020 => sp("Rec.2020", REC2020, D65, Tf::Gamma(2.4)),
+ ColorSpace::DisplayP3 => sp("Display P3", P3, D65, Tf::Srgb),
+ ColorSpace::AcesCg => ACES_CG,
+ ColorSpace::Aces2065 => ACES2065_1,
+ // HDR encodings are output spaces, never a working space.
+ ColorSpace::Rec2100Pq | ColorSpace::Rec2100Hlg => sp("Rec.2020", REC2020, D65, Tf::Gamma(2.4)),
+ };
+ match i {
+ 0 => (ws(ctx.env.working_space.unwrap_or(ColorSpace::Srgb)), ctx.env.working_linear),
+ 1 => (ws(ColorSpace::Srgb), false),
+ 2 => (ws(ColorSpace::Rec709), false),
+ 3 => (ws(ColorSpace::Rec2020), false),
+ 4 => (ws(ColorSpace::DisplayP3), false),
+ 5 => (ACES_CG, true),
+ _ => (ACES2065_1, true),
+ }
+}
+
+/// Gamut compression for the perceptual intent: pull out-of-gamut (negative) colours toward
+/// their luminance just enough to bring every channel to ≥ 0, rolling off smoothly.
+fn compress_gamut(c: [f64; 3], luma: [f64; 3]) -> [f64; 3] {
+ let l = c[0] * luma[0] + c[1] * luma[1] + c[2] * luma[2];
+ if l <= 0.0 {
+ return c.map(|v| v.max(0.0));
+ }
+ let mn = c.iter().cloned().fold(f64::INFINITY, f64::min);
+ if mn >= 0.0 {
+ return c;
+ }
+ // Fraction of the way toward grey that reaches zero on the most negative channel.
+ let t = (l / (l - mn)).clamp(0.0, 1.0);
+ c.map(|v| l + (v - l) * t)
+}
+
+pub(super) fn profile_converter(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ let (inp, in_lin_default) = profile(ctx, ctx.params.e("inputProfile"));
+ let (out, out_lin_default) = profile(ctx, ctx.params.e("outputProfile"));
+ let in_lin = ctx.params.b("linearizeInputProfile") || in_lin_default && ctx.params.e("inputProfile") == 0;
+ let out_lin = ctx.params.b("linearizeOutputProfile") || out_lin_default && ctx.params.e("outputProfile") == 0;
+ let intent = ctx.params.e("intent");
+ let dec = if in_lin { Tf::Linear } else { inp.tf };
+ let enc = if out_lin { Tf::Linear } else { out.tf };
+ // Absolute colorimetric keeps the source white (no adaptation); the others adapt.
+ let m = if intent == 3 { mul(&invert(&out.to_ref(false)), &inp.to_ref(false)) } else { matrix(&inp, &out) };
+ let identity = dec == enc && (0..3).all(|i| (0..3).all(|j| (m[i][j] - IDENTITY[i][j]).abs() < 1e-9));
+ if identity {
+ return b;
+ }
+ let out_luma = out.to_ref(true)[1];
+ map_px(&mut b, |c| {
+ let l = c.map(|v| dec.decode(v as f64));
+ let mut o = mul_vec(&m, l);
+ match intent {
+ 0 => o = compress_gamut(o, out_luma),
+ 2 => o = o.map(|v| v.max(0.0)),
+ _ => {}
+ }
+ o.map(|v| enc.encode(v) as f32)
+ });
+ b
+}
+
+// ---- Color Stabilizer
+
+/// Mean straight colour of a square (half-size `r` layer pixels) around layer point `pt`.
+fn sample_mean(b: &Buf, pt: [f64; 2], r: f64) -> [f64; 3] {
+ let (cx, cy) = b.to_px(pt);
+ let rr = (r * b.scale).max(0.5);
+ let (x0, x1) = ((cx - rr).floor().max(0.0) as i64, ((cx + rr).ceil() as i64).min(b.img.width as i64));
+ let (y0, y1) = ((cy - rr).floor().max(0.0) as i64, ((cy + rr).ceil() as i64).min(b.img.height as i64));
+ let mut acc = [0.0f64; 4];
+ for y in y0..y1 {
+ for x in x0..x1 {
+ let p = b.img.get(x, y);
+ for k in 0..4 {
+ acc[k] += p[k] as f64;
+ }
+ }
+ }
+ if acc[3] <= 1e-9 {
+ return [0.0; 3];
+ }
+ [acc[0] / acc[3], acc[1] / acc[3], acc[2] / acc[3]]
+}
+
+/// Monotone piecewise-quadratic curve through (0,0), three samples and (1,1) (linear between
+/// them is enough for a stabiliser and stays monotone).
+fn curve3(xs: [f64; 3], ys: [f64; 3], v: f64) -> f64 {
+ let mut pts = vec![(0.0, 0.0)];
+ let mut pairs: Vec<(f64, f64)> = xs.iter().cloned().zip(ys.iter().cloned()).collect();
+ pairs.sort_by(|a, b| a.0.total_cmp(&b.0));
+ for (x, y) in pairs {
+ if pts.last().is_some_and(|l| x > l.0 + 1e-4) && x < 1.0 - 1e-4 {
+ pts.push((x, y));
+ }
+ }
+ pts.push((1.0, 1.0));
+ let i = pts.partition_point(|p| p.0 < v).clamp(1, pts.len() - 1);
+ let (a, c) = (pts[i - 1], pts[i]);
+ a.1 + (c.1 - a.1) * (v - a.0) / (c.0 - a.0).max(1e-9)
+}
+
+/// Color Stabilizer's correction of buffer `b` as one piecewise-linear map per channel (points
+/// with increasing x; the end segments extend), the same maps `color_stabilizer` applies.
+/// `None` without a host or reference frame (the layer passes through). (The GPU effect.)
+pub fn color_stabilizer_maps(ctx: &EffectCtx, b: &Buf) -> Option<[Vec<(f64, f64)>; 3]> {
+ let reference = ctx.env.host?.self_at(ctx.params.f("referenceFrame"), ctx.env.effect_index)?;
+ let r = ctx.params.f("sampleSize").max(0.5);
+ let pts = [ctx.params.v2("blackPoint"), ctx.params.v2("midPoint"), ctx.params.v2("whitePoint")];
+ let cur = pts.map(|pt| sample_mean(b, pt, r));
+ let refv = pts.map(|pt| sample_mean(&reference, pt, r));
+ let mode = ctx.params.e("stabilize");
+ Some([0, 1, 2].map(|k| {
+ let offset = |c0: f64, r0: f64| vec![(0.0, r0 - c0), (1.0, 1.0 + r0 - c0)];
+ match mode {
+ 0 => offset(cur[0][k], refv[0][k]),
+ 1 => {
+ let (c0, c1, r0, r1) = (cur[0][k], cur[2][k], refv[0][k], refv[2][k]);
+ if (c1 - c0).abs() < 1e-6 {
+ offset(c0, r0)
+ } else if c0 < c1 {
+ vec![(c0, r0), (c1, r1)]
+ } else {
+ vec![(c1, r1), (c0, r0)]
+ }
+ }
+ _ => {
+ let mut v = vec![(0.0, 0.0)];
+ let mut pairs: Vec<(f64, f64)> = (0..3).map(|i| (cur[i][k], refv[i][k])).collect();
+ pairs.sort_by(|a, b| a.0.total_cmp(&b.0));
+ for (x, y) in pairs {
+ if v.last().is_some_and(|l| x > l.0 + 1e-4) && x < 1.0 - 1e-4 {
+ v.push((x, y));
+ }
+ }
+ v.push((1.0, 1.0));
+ v
+ }
+ }
+ }))
+}
+
+pub(super) fn color_stabilizer(ctx: &EffectCtx, mut b: Buf) -> Buf {
+ let Some(host) = ctx.env.host else { return b };
+ let Some(reference) = host.self_at(ctx.params.f("referenceFrame"), ctx.env.effect_index) else { return b };
+ let r = ctx.params.f("sampleSize").max(0.5);
+ let pts = [ctx.params.v2("blackPoint"), ctx.params.v2("midPoint"), ctx.params.v2("whitePoint")];
+ let cur = pts.map(|pt| sample_mean(&b, pt, r));
+ let refv = pts.map(|pt| sample_mean(&reference, pt, r));
+ let mode = ctx.params.e("stabilize");
+ map_px(&mut b, |c| {
+ [0, 1, 2].map(|k| {
+ let v = c[k] as f64;
+ let o = match mode {
+ // Brightness: one sample (black point) — offset each channel.
+ 0 => v + refv[0][k] - cur[0][k],
+ // Levels: black and white samples — linear map per channel.
+ 1 => {
+ let (c0, c1, r0, r1) = (cur[0][k], cur[2][k], refv[0][k], refv[2][k]);
+ if (c1 - c0).abs() < 1e-6 { v + r0 - c0 } else { r0 + (v - c0) * (r1 - r0) / (c1 - c0) }
+ }
+ // Curves: three samples — a curve through them per channel.
+ _ => curve3([cur[0][k], cur[1][k], cur[2][k]], [refv[0][k], refv[1][k], refv[2][k]], v),
+ };
+ o as f32
+ })
+ });
+ b
+}
diff --git a/crates/effects/src/ocio/lut.rs b/crates/effects/src/ocio/lut.rs
new file mode 100644
index 000000000..ff4cbd935
--- /dev/null
+++ b/crates/effects/src/ocio/lut.rs
@@ -0,0 +1,331 @@
+use super::cdl::{Cdl, parse_cdl_xml};
+use super::*;
+
+// ---------------------------------------------------------------- LUT files
+
+/// A loaded transform file.
+#[derive(Clone, Debug)]
+pub enum FileXform {
+ /// A lattice/1D LUT with an optional per-channel piecewise-linear shaper (cineSpace pre-LUT).
+ Lut { lut: Lut, shaper: Option<[Vec<(f32, f32)>; 3]> },
+ /// CDL corrections by id (in file order).
+ Cdl(Vec<(String, Cdl)>),
+ /// A matrix with offset (Sony Imageworks `.spimtx`), as a MatrixTransform's.
+ Matrix { m: [f64; 16], offset: [f64; 4] },
+}
+
+/// Parse a Sony Imageworks `.spimtx` matrix: three rows of four numbers, three matrix columns
+/// and an offset in 16-bit code values (÷ 65535).
+pub fn parse_spimtx(text: &str) -> Option {
+ let v: Vec = text.split_whitespace().map(|t| t.parse().ok()).collect::>()?;
+ if v.len() != 12 || v.iter().any(|x| !x.is_finite()) {
+ return None;
+ }
+ let mut m = [0.0; 16];
+ let mut offset = [0.0; 4];
+ for (r, row) in v.as_chunks::<4>().0.iter().enumerate() {
+ m[r * 4..r * 4 + 3].copy_from_slice(&row[..3]);
+ offset[r] = row[3] / 65535.0;
+ }
+ m[15] = 1.0;
+ Some(FileXform::Matrix { m, offset })
+}
+
+/// Parse a Sony Imageworks `.spi1d` 1D LUT: `From `, `Length `, `Components
+/// <1 | 3>`, then `{` the values `}`.
+pub fn parse_spi1d(text: &str) -> Option {
+ let (mut from, mut len, mut comps) = ([0.0f32, 1.0], 0usize, 1usize);
+ let mut values: Vec = vec![];
+ let mut body = false;
+ for line in text.lines().map(str::trim).filter(|l| !l.is_empty()) {
+ if body {
+ if line.starts_with('}') {
+ break;
+ }
+ for t in line.split_whitespace() {
+ values.push(t.parse().ok()?);
+ }
+ continue;
+ }
+ let mut t = line.split_whitespace();
+ match t.next()? {
+ "{" => body = true,
+ "From" => from = [t.next()?.parse().ok()?, t.next()?.parse().ok()?],
+ "Length" => len = t.next()?.parse().ok()?,
+ "Components" => comps = t.next()?.parse().ok()?,
+ _ => {}
+ }
+ }
+ // A 1D table is interpolated by index, so cap it like the lattices (2²⁴ entries).
+ if !(2..=1 << 24).contains(&len)
+ || !matches!(comps, 1 | 3)
+ || values.len() != len.checked_mul(comps)?
+ || from[1] <= from[0]
+ || from.iter().any(|v| !v.is_finite())
+ {
+ return None;
+ }
+ let d1 = values.chunks_exact(comps).map(|c| if comps == 3 { [c[0], c[1], c[2]] } else { [c[0]; 3] }).collect();
+ Some(Lut { n1: len, d1, n3: 0, d3: vec![], dmin: [from[0]; 3], dmax: [from[1]; 3] })
+}
+
+/// Parse a Sony Imageworks `.spi3d` lattice: `SPILUT 1.0`, `3 3`, the sizes, then one
+/// `r g b R G B` line per lattice point (indices, then the colour).
+pub fn parse_spi3d(text: &str) -> Option {
+ let mut lines = text.lines().map(str::trim).filter(|l| !l.is_empty());
+ if !lines.next()?.starts_with("SPILUT") {
+ return None;
+ }
+ lines.next()?;
+ let size: Vec = lines.next()?.split_whitespace().map(|t| t.parse().ok()).collect::>()?;
+ let n = *size.first()?;
+ if size.len() != 3 || size.iter().any(|s| *s != n) || !(2..=129).contains(&n) {
+ return None;
+ }
+ let mut d3 = vec![[0.0f32; 3]; n * n * n];
+ let mut seen = 0usize;
+ for line in lines {
+ let v: Vec<&str> = line.split_whitespace().collect();
+ let [r, g, b, cr, cg, cb] = v.as_slice() else { return None };
+ let (r, g, b): (usize, usize, usize) = (r.parse().ok()?, g.parse().ok()?, b.parse().ok()?);
+ if r >= n || g >= n || b >= n {
+ return None;
+ }
+ // Our lattice is red fastest.
+ *d3.get_mut(r + g * n + b * n * n)? = [cr.parse().ok()?, cg.parse().ok()?, cb.parse().ok()?];
+ seen += 1;
+ }
+ (seen == n * n * n).then_some(Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] })
+}
+
+/// Parse an Autodesk `.3dl` lattice (integers, blue fastest; an optional input-mesh line).
+pub fn parse_3dl(text: &str) -> Option {
+ let mut mesh: Option> = None;
+ let mut rows: Vec<[f64; 3]> = vec![];
+ let mut out_bits: Option = None;
+ for line in text.lines() {
+ let l = line.trim();
+ if l.is_empty() || l.starts_with('#') || l.starts_with('<') {
+ continue;
+ }
+ if l.starts_with(|c: char| c.is_ascii_alphabetic()) {
+ // "Mesh " (Lustre header); other keywords are ignored.
+ let t: Vec<&str> = l.split_whitespace().collect();
+ if t[0].eq_ignore_ascii_case("mesh") && t.len() >= 3 {
+ out_bits = t[2].parse().ok();
+ }
+ continue;
+ }
+ let v: Vec = l.split_whitespace().filter_map(|t| t.parse().ok()).collect();
+ if v.len() > 3 && mesh.is_none() && rows.is_empty() {
+ mesh = Some(v);
+ } else if v.len() == 3 {
+ rows.push([v[0], v[1], v[2]]);
+ } else {
+ return None;
+ }
+ }
+ let is_cube = |k: usize| {
+ let n = (k as f64).cbrt().round() as usize;
+ n * n * n == k
+ };
+ // A 3-entry input mesh (3³ lattice) looks like a data row: tell them apart by the count.
+ if mesh.is_none() && !is_cube(rows.len()) && rows.len() == 28 {
+ mesh = Some(rows.remove(0).to_vec());
+ }
+ let n = match &mesh {
+ Some(m) => m.len(),
+ None => (rows.len() as f64).cbrt().round() as usize,
+ };
+ if n < 2 || rows.len() != n * n * n {
+ return None;
+ }
+ let maxv = rows.iter().flat_map(|r| r.iter()).fold(0.0f64, |m, &v| m.max(v));
+ let out_max = match out_bits {
+ Some(b) if b > 0 && b < 32 => (1u64 << b) as f64 - 1.0,
+ _ => [255.0, 1023.0, 4095.0, 65535.0].into_iter().find(|&m| maxv <= m).unwrap_or(maxv.max(1.0)),
+ };
+ // .3dl rows: red slowest, blue fastest. Our lattice is red fastest.
+ let mut d3 = vec![[0.0f32; 3]; n * n * n];
+ for (k, r) in rows.iter().enumerate() {
+ let (ri, gi, bi) = (k / (n * n), (k / n) % n, k % n);
+ d3[ri + gi * n + bi * n * n] = r.map(|v| (v / out_max) as f32);
+ }
+ Some(Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] })
+}
+
+/// Parse a cineSpace `.csp` LUT (1D or 3D, with its three pre-LUT shapers).
+pub fn parse_csp(text: &str) -> Option<(Lut, [Vec<(f32, f32)>; 3])> {
+ let mut lines = text.lines().map(str::trim).filter(|l| !l.is_empty());
+ if !lines.next()?.starts_with("CSPLUTV100") {
+ return None;
+ }
+ let kind = lines.next()?;
+ let mut lines = lines.peekable();
+ if lines.peek().is_some_and(|l| l.starts_with("BEGIN METADATA")) {
+ for l in lines.by_ref() {
+ if l.starts_with("END METADATA") {
+ break;
+ }
+ }
+ }
+ let nums = |l: &str| -> Option> { l.split_whitespace().map(|t| t.parse().ok()).collect() };
+ let mut shaper: [Vec<(f32, f32)>; 3] = Default::default();
+ for ch in shaper.iter_mut() {
+ let n: usize = lines.next()?.parse().ok()?;
+ let ins = nums(lines.next()?)?;
+ let outs = nums(lines.next()?)?;
+ if ins.len() != n || outs.len() != n || n < 2 {
+ return None;
+ }
+ *ch = ins.into_iter().zip(outs).collect();
+ }
+ if kind.starts_with("3D") {
+ let sz = nums(lines.next()?)?;
+ if sz.len() != 3 || sz[0] != sz[1] || sz[1] != sz[2] {
+ return None;
+ }
+ let n = sz[0] as usize;
+ let mut d3 = Vec::with_capacity(n * n * n);
+ for _ in 0..n * n * n {
+ let v = nums(lines.next()?)?;
+ if v.len() != 3 {
+ return None;
+ }
+ d3.push([v[0], v[1], v[2]]);
+ }
+ (n >= 2).then_some((Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] }, shaper))
+ } else {
+ let n: usize = lines.next()?.parse().ok()?;
+ let mut d1 = Vec::with_capacity(n);
+ for _ in 0..n {
+ let v = nums(lines.next()?)?;
+ if v.len() != 3 {
+ return None;
+ }
+ d1.push([v[0], v[1], v[2]]);
+ }
+ (n >= 2).then_some((Lut { n1: n, d1, n3: 0, d3: vec![], dmin: [0.0; 3], dmax: [1.0; 3] }, shaper))
+ }
+}
+
+fn shape(curve: &[(f32, f32)], x: f32) -> f32 {
+ if curve.len() < 2 {
+ return x;
+ }
+ let i = curve.partition_point(|p| p.0 < x).clamp(1, curve.len() - 1);
+ let (a, b) = (curve[i - 1], curve[i]);
+ let t = ((x - a.0) / (b.0 - a.0).max(1e-12)).clamp(0.0, 1.0);
+ a.1 + (b.1 - a.1) * t
+}
+
+fn shape_inv(curve: &[(f32, f32)], y: f32) -> f32 {
+ let flipped: Vec<(f32, f32)> = curve.iter().map(|&(a, b)| (b, a)).collect();
+ shape(&flipped, y)
+}
+
+/// Parse transform text by its format (detected from `ext` or the content).
+pub fn parse_file(text: &str, ext: &str) -> Option {
+ let ext = ext.to_ascii_lowercase();
+ if ext == "cc" || ext == "ccc" || ext == "cdl" || text.contains(">>>;
+
+/// Load (and cache) a transform from a file path or inline content.
+pub fn load_file(src: &str) -> Option> {
+ let src_t = src.trim();
+ if src_t.is_empty() {
+ return None;
+ }
+ static CACHE: OnceLock = OnceLock::new();
+ let cache = CACHE.get_or_init(|| Mutex::new(HashMap::new()));
+ if let Ok(m) = cache.lock()
+ && let Some(v) = m.get(src)
+ {
+ return v.clone();
+ }
+ let inline = src.contains('\n');
+ let parsed = if inline {
+ parse_file(src, "")
+ } else {
+ let ext = std::path::Path::new(src_t).extension().and_then(std::ffi::OsStr::to_str).unwrap_or("");
+ std::fs::read_to_string(src_t).ok().and_then(|t| parse_file(&t, ext))
+ }
+ .map(Arc::new);
+ if let Ok(mut m) = cache.lock() {
+ m.insert(src.to_string(), parsed.clone());
+ }
+ parsed
+}
+
+impl FileXform {
+ pub fn apply(&self, c: [f32; 3], interp: u32, inverse: bool, ccc_id: &str) -> [f32; 3] {
+ match self {
+ FileXform::Cdl(list) => {
+ let cdl = list.iter().find(|(id, _)| !ccc_id.is_empty() && id == ccc_id).or(list.first()).map(|(_, c)| *c).unwrap_or_default();
+ let c64 = c.map(|v| v as f64);
+ let o = if inverse { cdl.invert(c64, true) } else { cdl.apply(c64, true) };
+ o.map(|v| v as f32)
+ }
+ FileXform::Matrix { m, offset } => crate::ocio_config::matrix_apply(m, offset, c.map(|v| v as f64), inverse).map(|v| v as f32),
+ FileXform::Lut { lut, shaper } => {
+ let fwd = |c: [f32; 3]| {
+ let c = match shaper {
+ Some(s) => [shape(&s[0], c[0]), shape(&s[1], c[1]), shape(&s[2], c[2])],
+ None => c,
+ };
+ lut.apply_interp(c, interp)
+ };
+ if !inverse {
+ return fwd(c);
+ }
+ if lut.n3 == 0 {
+ // 1D: invert each channel exactly through the (monotone) tables.
+ let mut x = c;
+ if lut.n1 > 1 {
+ x = [0, 1, 2].map(|i| {
+ let curve: Vec<(f32, f32)> =
+ (0..lut.n1).map(|k| (lut.d1[k][i], lut.dmin[i] + (lut.dmax[i] - lut.dmin[i]) * k as f32 / (lut.n1 - 1) as f32)).collect();
+ shape(&curve, c[i])
+ });
+ }
+ if let Some(s) = shaper {
+ x = [shape_inv(&s[0], x[0]), shape_inv(&s[1], x[1]), shape_inv(&s[2], x[2])];
+ }
+ return x;
+ }
+ // 3D: damped fixed-point (Newton with an identity Jacobian) from the target.
+ let mut x = c;
+ for _ in 0..40 {
+ let y = fwd(x);
+ let e = [c[0] - y[0], c[1] - y[1], c[2] - y[2]];
+ if e.iter().all(|v| v.abs() < 1e-6) {
+ break;
+ }
+ x = [x[0] + e[0], x[1] + e[1], x[2] + e[2]];
+ }
+ x
+ }
+ }
+ }
+}
diff --git a/crates/effects/src/ocio/program.rs b/crates/effects/src/ocio/program.rs
new file mode 100644
index 000000000..ab9c4ea78
--- /dev/null
+++ b/crates/effects/src/ocio/program.rs
@@ -0,0 +1,252 @@
+use super::cdl::Cdl;
+use super::effects::{DISPLAYS, cdl_from_params, custom_xf, looks, parse_looks, profile, space_at};
+use super::lut::{FileXform, load_file};
+use super::space::{ACES_CCT, D65, IDENTITY, Space, Tf, Xform, matrix};
+use super::*;
+
+// ---- Colour programs (the GPU compositor's colour-management kernels)
+
+/// One per-pixel step of a colour transform, in the order the CPU effect applies them (see
+/// [`color_program`]).
+#[derive(Clone, Debug)]
+pub enum ColorOp {
+ /// Transfer function, encoded → linear.
+ Decode(Tf),
+ /// Transfer function, linear → encoded.
+ Encode(Tf),
+ /// Linear-RGB matrix.
+ Matrix([[f32; 3]; 3]),
+ /// ASC CDL (forward or exact inverse; `clamp` = the v1.2 style).
+ Cdl { cdl: Cdl, clamp: bool, inverse: bool },
+ /// The Tone Mapped view's roll-off (or its inverse).
+ Tonemap { inverse: bool },
+ /// Color Profile Converter's perceptual gamut compression toward luminance `luma`.
+ Gamut([f64; 3]),
+ /// Negative channels to 0 (the saturation intent).
+ Max0,
+ /// A LUT (0 nearest, 1 trilinear, 2 tetrahedral) with an optional per-channel shaper, forward
+ /// or inverse (as `FileXform::apply`).
+ Lut { lut: Arc, shaper: Option; 3]>>, interp: u32, inverse: bool },
+ /// `m × (c + pre) + post` (a custom config's MatrixTransform and RangeTransform).
+ Affine { m: [[f32; 3]; 3], pre: [f32; 3], post: [f32; 3] },
+ /// `max(c, 0) ^ p` per channel (ExponentTransform).
+ Pow([f32; 3]),
+ /// LogTransform / LogAffineTransform, forward or inverse (as `ocio_config::Xf::apply`).
+ LogAffine { base: f32, log_slope: [f32; 3], log_offset: [f32; 3], lin_slope: [f32; 3], lin_offset: [f32; 3], inverse: bool },
+ /// ExponentWithLinearTransform, forward (decode) or inverse (as
+ /// [`crate::ocio_config::moncurve`]).
+ MonCurve { gamma: [f32; 3], offset: [f32; 3], inverse: bool, mirror: bool },
+ /// Clamp each channel to `lo..=hi` (a clamping RangeTransform; ±`f32::MAX` = unbounded).
+ Clamp { lo: [f32; 3], hi: [f32; 3] },
+}
+
+/// The ops of a matrix-and-offset transform (MatrixTransform, `.spimtx`), forward or inverse
+/// (as [`crate::ocio_config::matrix_apply`]).
+fn matrix_ops(m: &[f64; 16], offset: &[f64; 4], inverse: bool, ops: &mut Vec) {
+ if !inverse {
+ let m = [0, 1, 2].map(|r| [m[r * 4] as f32, m[r * 4 + 1] as f32, m[r * 4 + 2] as f32]);
+ ops.push(ColorOp::Affine { m, pre: [0.0; 3], post: [offset[0] as f32, offset[1] as f32, offset[2] as f32] });
+ } else if let Some(inv) = crate::ocio_config::mat3_inverse(m) {
+ let m = inv.map(|r| r.map(|v| v as f32));
+ ops.push(ColorOp::Affine { m, pre: [-offset[0] as f32, -offset[1] as f32, -offset[2] as f32], post: [0.0; 3] });
+ }
+}
+
+/// The ops of a LUT / CDL / matrix file transform (as [`FileXform::apply`]).
+fn file_ops(x: &FileXform, interp: u32, inverse: bool, ccc_id: &str, ops: &mut Vec) {
+ match x {
+ FileXform::Cdl(list) => {
+ let cdl = list.iter().find(|(i, _)| !ccc_id.is_empty() && i == ccc_id).or(list.first()).map(|(_, c)| *c).unwrap_or_default();
+ ops.push(ColorOp::Cdl { cdl, clamp: true, inverse });
+ }
+ FileXform::Lut { lut, shaper } => {
+ ops.push(ColorOp::Lut { lut: Arc::new(lut.clone()), shaper: shaper.clone().map(Arc::new), interp, inverse });
+ }
+ FileXform::Matrix { m, offset } => matrix_ops(m, offset, inverse, ops),
+ }
+}
+
+/// The ops of a custom config's transform `x` (as `Xf::apply`).
+fn config_xf_ops(x: &crate::ocio_config::Xf, inverse: bool, ops: &mut Vec) {
+ use crate::ocio_config::Xf;
+ let f3 = |v: &[f64; 3]| v.map(|x| x as f32);
+ match x {
+ Xf::Inverse(x) => config_xf_ops(x, !inverse, ops),
+ Xf::Matrix { m, offset } => matrix_ops(m, offset, inverse, ops),
+ Xf::File { xf: Some(x), interp, ccc, .. } => file_ops(x, *interp, inverse, ccc, ops),
+ Xf::ExponentLinear { gamma, offset, mirror } => ops.push(ColorOp::MonCurve { gamma: f3(gamma), offset: f3(offset), inverse, mirror: *mirror }),
+ // A BuiltinTransform's curve: forward decodes.
+ Xf::Curve(tf) => ops.push(if inverse { ColorOp::Encode(*tf) } else { ColorOp::Decode(*tf) }),
+ Xf::Named(_) => {}
+ Xf::File { xf: None, .. } | Xf::Unsupported(_) => {}
+ Xf::Exponent(e) => ops.push(ColorOp::Pow([0, 1, 2].map(|k| (if inverse { 1.0 / e[k].max(1e-9) } else { e[k] }) as f32))),
+ Xf::Log { base } => {
+ ops.push(ColorOp::LogAffine { base: *base as f32, log_slope: [1.0; 3], log_offset: [0.0; 3], lin_slope: [1.0; 3], lin_offset: [0.0; 3], inverse })
+ }
+ Xf::LogAffine { base, log_slope, log_offset, lin_slope, lin_offset } => ops.push(ColorOp::LogAffine {
+ base: *base as f32,
+ log_slope: f3(log_slope),
+ log_offset: f3(log_offset),
+ lin_slope: f3(lin_slope),
+ lin_offset: f3(lin_offset),
+ inverse,
+ }),
+ Xf::Cdl(cdl) => ops.push(ColorOp::Cdl { cdl: *cdl, clamp: true, inverse }),
+ Xf::Range(r) => {
+ let (k, off, lo, hi) = r.parts(inverse);
+ let k = k as f32;
+ ops.push(ColorOp::Affine { m: [[k, 0.0, 0.0], [0.0, k, 0.0], [0.0, 0.0, k]], pre: [0.0; 3], post: [off as f32; 3] });
+ if lo.is_finite() || hi.is_finite() {
+ let bound = |v: f64| (v as f32).clamp(-f32::MAX, f32::MAX);
+ ops.push(ColorOp::Clamp { lo: [bound(lo); 3], hi: [bound(hi); 3] });
+ }
+ }
+ Xf::Group(list) => {
+ if inverse {
+ list.iter().rev().for_each(|x| config_xf_ops(x, true, ops));
+ } else {
+ list.iter().for_each(|x| config_xf_ops(x, false, ops));
+ }
+ }
+ }
+}
+
+/// How a colour program meets premultiplied pixels.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Straight {
+ /// `unpremul` (colour 0 below alpha 1e-6); fully transparent pixels untouched (OCIO effects).
+ Unpremul,
+ /// Colour ÷ alpha; fully transparent pixels untouched (`Image::map_straight`, Apply Color LUT).
+ Divide,
+}
+
+fn xform_ops(x: &Xform, ops: &mut Vec) {
+ if x.dec != Tf::Linear {
+ ops.push(ColorOp::Decode(x.dec));
+ }
+ if !x.ident {
+ ops.push(ColorOp::Matrix(x.m));
+ }
+ if x.enc != Tf::Linear {
+ ops.push(ColorOp::Encode(x.enc));
+ }
+}
+
+/// Effect `id`'s per-pixel transform as a list of [`ColorOp`]s that reproduces the CPU effect
+/// (empty = the layer passes through; custom OCIO configs compile their transforms too). `None`
+/// for another effect.
+pub fn color_program(id: &str, ctx: &EffectCtx) -> Option<(Vec, Straight)> {
+ let pr = ctx.params;
+ let mut ops = vec![];
+ // Configuration ▸ Custom compiles the config's transforms (a config that can't be read, or
+ // names unknown spaces, passes the pixels through).
+ match custom_xf(id, pr) {
+ Ok(None) => {}
+ Ok(Some(xf)) => {
+ config_xf_ops(&xf, false, &mut ops);
+ return Some((ops, Straight::Unpremul));
+ }
+ Err(_) => return Some((ops, Straight::Unpremul)),
+ }
+ match id {
+ "ec.utility.applylut" => {
+ if let Some(lut) = crate::utility::load_lut(pr.s("lut")) {
+ ops.push(ColorOp::Lut { lut, shaper: None, interp: 2, inverse: false });
+ }
+ return Some((ops, Straight::Divide));
+ }
+ "ec.color.ociocolorspace" => {
+ let (a, z) = (space_at(pr.e("source")), space_at(pr.e("destination")));
+ let (a, z) = if pr.e("direction") == 1 { (z, a) } else { (a, z) };
+ if a.name != z.name {
+ xform_ops(&Xform::new(a, z), &mut ops);
+ }
+ }
+ "ec.color.ociocdl" => {
+ let cdl = cdl_from_params(pr);
+ if cdl != Cdl::default() {
+ ops.push(ColorOp::Cdl { cdl, clamp: pr.e("style") == 0, inverse: pr.e("direction") == 1 });
+ }
+ }
+ "ec.color.ociodisplay" => {
+ let input = space_at(pr.e("source"));
+ let (display, view, inverse) = (pr.e("display") as usize, pr.e("view") as usize, pr.e("direction") == 1);
+ let (_, prims, tf) = DISPLAYS[display.min(DISPLAYS.len() - 1)];
+ if view != 2 && !input.raw {
+ let disp = Space { name: "display", prims: Some((prims, D65)), tf: Tf::Linear, raw: false };
+ let lin = Space { tf: Tf::Linear, ..*input };
+ if !inverse {
+ ops.push(ColorOp::Decode(input.tf));
+ xform_ops(&Xform::new(&lin, &disp), &mut ops);
+ if view == 1 {
+ ops.push(ColorOp::Tonemap { inverse: false });
+ }
+ ops.push(ColorOp::Encode(tf));
+ } else {
+ ops.push(ColorOp::Decode(tf));
+ if view == 1 {
+ ops.push(ColorOp::Tonemap { inverse: true });
+ }
+ xform_ops(&Xform::new(&disp, &lin), &mut ops);
+ ops.push(ColorOp::Encode(input.tf));
+ }
+ }
+ }
+ "ec.color.ociofile" => {
+ if let Some(x) = load_file(pr.s("file")) {
+ let interp = match pr.e("interpolation") {
+ 0 => 0,
+ 1 => 1,
+ _ => 2,
+ };
+ file_ops(&x, interp, pr.e("direction") == 1, pr.s("cccId"), &mut ops);
+ }
+ }
+ "ec.color.ociolook" => {
+ let mut list = parse_looks(pr.s("looks"));
+ let pick = pr.e("look");
+ if pick > 0
+ && let Some((_, c)) = looks().get(pick as usize - 1)
+ {
+ list.insert(0, (*c, false));
+ }
+ if !list.is_empty() {
+ let (src, dst) = (space_at(pr.e("source")), space_at(pr.e("destination")));
+ let inv = pr.e("direction") == 1;
+ let cct = &ACES_CCT;
+ let (a, z) = if inv { (dst, src) } else { (src, dst) };
+ if inv {
+ list.reverse();
+ }
+ xform_ops(&Xform::new(a, cct), &mut ops);
+ for (cdl, li) in &list {
+ ops.push(ColorOp::Cdl { cdl: *cdl, clamp: false, inverse: *li != inv });
+ }
+ xform_ops(&Xform::new(cct, z), &mut ops);
+ }
+ }
+ "ec.utility.colorprofileconverter" => {
+ let (inp, in_lin_default) = profile(ctx, pr.e("inputProfile"));
+ let (out, out_lin_default) = profile(ctx, pr.e("outputProfile"));
+ let in_lin = pr.b("linearizeInputProfile") || in_lin_default && pr.e("inputProfile") == 0;
+ let out_lin = pr.b("linearizeOutputProfile") || out_lin_default && pr.e("outputProfile") == 0;
+ let intent = pr.e("intent");
+ let dec = if in_lin { Tf::Linear } else { inp.tf };
+ let enc = if out_lin { Tf::Linear } else { out.tf };
+ let m = if intent == 3 { mul(&invert(&out.to_ref(false)), &inp.to_ref(false)) } else { matrix(&inp, &out) };
+ let identity = dec == enc && (0..3).all(|i| (0..3).all(|j| (m[i][j] - IDENTITY[i][j]).abs() < 1e-9));
+ if !identity {
+ ops.push(ColorOp::Decode(dec));
+ ops.push(ColorOp::Matrix(m.map(|r| r.map(|v| v as f32))));
+ match intent {
+ 0 => ops.push(ColorOp::Gamut(out.to_ref(true)[1])),
+ 2 => ops.push(ColorOp::Max0),
+ _ => {}
+ }
+ ops.push(ColorOp::Encode(enc));
+ }
+ }
+ _ => return None,
+ }
+ Some((ops, Straight::Unpremul))
+}
diff --git a/crates/effects/src/ocio/registry.rs b/crates/effects/src/ocio/registry.rs
new file mode 100644
index 000000000..b020b053b
--- /dev/null
+++ b/crates/effects/src/ocio/registry.rs
@@ -0,0 +1,129 @@
+use super::cdl::sl;
+use super::effects::{
+ CONFIGS, DISPLAYS, PROFILES, VIEWS, color_stabilizer, direction, looks, ocio_cdl, ocio_cst, ocio_display, ocio_file, ocio_look, profile_converter,
+ space_param, spec,
+};
+use super::space::SPACES;
+use super::*;
+
+pub fn specs() -> Vec {
+ let cc = "Color Correction";
+ let srgb = SPACES.iter().position(|s| s.name == "sRGB").unwrap_or(0) as u32;
+ let lin709 = SPACES.iter().position(|s| s.name == "Linear Rec.709 (sRGB)").unwrap_or(0) as u32;
+ let acescg = SPACES.iter().position(|s| s.name == "ACEScg").unwrap_or(0) as u32;
+ let mut look_opts = vec!["None"];
+ look_opts.extend(looks().iter().map(|(n, _)| *n));
+ vec![
+ spec(
+ "ec.color.ociocdl",
+ "OCIO CDL Transform",
+ cc,
+ vec![
+ p("slopeRed", "Slope Red", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+ p("slopeGreen", "Slope Green", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+ p("slopeBlue", "Slope Blue", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+ p("offsetRed", "Offset Red", num(0.0), sl(-100.0, 100.0, -1.0, 1.0)),
+ p("offsetGreen", "Offset Green", num(0.0), sl(-100.0, 100.0, -1.0, 1.0)),
+ p("offsetBlue", "Offset Blue", num(0.0), sl(-100.0, 100.0, -1.0, 1.0)),
+ p("powerRed", "Power Red", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+ p("powerGreen", "Power Green", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+ p("powerBlue", "Power Blue", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+ p("saturation", "Saturation", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+ p("style", "Style", Value::Enum(0), popup(&["ASC CDL v1.2", "No Clamp"])),
+ direction(),
+ ],
+ ocio_cdl,
+ ),
+ spec(
+ "ec.color.ociocolorspace",
+ "OCIO Color Space Transform",
+ cc,
+ vec![
+ p("config", "Configuration", Value::Enum(0), popup(CONFIGS)),
+ p("configFile", "Config File (.ocio)", Value::Str(String::new()), crate::file_ui(&["ocio"])),
+ space_param("source", "Source", lin709),
+ p("sourceName", "Source (config name)", Value::Str(String::new()), ParamUi::Text),
+ space_param("destination", "Destination", srgb),
+ p("destinationName", "Destination (config name)", Value::Str(String::new()), ParamUi::Text),
+ direction(),
+ ],
+ ocio_cst,
+ ),
+ spec(
+ "ec.color.ociodisplay",
+ "OCIO Display Transform",
+ cc,
+ vec![
+ p("config", "Configuration", Value::Enum(0), popup(CONFIGS)),
+ p("configFile", "Config File (.ocio)", Value::Str(String::new()), crate::file_ui(&["ocio"])),
+ space_param("source", "Input Color Space", lin709),
+ p("sourceName", "Source (config name)", Value::Str(String::new()), ParamUi::Text),
+ p("display", "Display Device", Value::Enum(0), popup(&DISPLAYS.iter().map(|d| d.0).collect::>())),
+ p("displayName", "Display (config name)", Value::Str(String::new()), ParamUi::Text),
+ p("view", "View Transform", Value::Enum(0), popup(VIEWS)),
+ p("viewName", "View (config name)", Value::Str(String::new()), ParamUi::Text),
+ direction(),
+ ],
+ ocio_display,
+ ),
+ // `file`: a path to a .cube/.3dl/.csp/.cc/.ccc/.cdl file, or the file's text itself.
+ spec(
+ "ec.color.ociofile",
+ "OCIO File Transform",
+ cc,
+ vec![
+ p("file", "File", Value::Str(String::new()), crate::file_ui(&["cube", "3dl", "csp", "cc", "ccc", "cdl", "spi1d", "spi3d", "spimtx"])),
+ p("cccId", "CCC ID", Value::Str(String::new()), ParamUi::Text),
+ p("interpolation", "Interpolation", Value::Enum(3), popup(&["Nearest", "Linear", "Tetrahedral", "Best"])),
+ direction(),
+ ],
+ ocio_file,
+ ),
+ spec(
+ "ec.color.ociolook",
+ "OCIO Look Transform",
+ cc,
+ vec![
+ p("config", "Configuration", Value::Enum(0), popup(&["Built-in (EffectCraft minimal)"])),
+ space_param("source", "Source", acescg),
+ space_param("destination", "Destination", acescg),
+ p("look", "Look", Value::Enum(0), popup(&look_opts)),
+ p("looks", "Looks", Value::Str(String::new()), ParamUi::Text),
+ direction(),
+ ],
+ ocio_look,
+ ),
+ spec(
+ "ec.color.colorstabilizer",
+ "Color Stabilizer",
+ cc,
+ vec![
+ // The pivot frame (After Effects' Set Frame button stores it).
+ p("referenceFrame", "Reference Frame (s)", num(0.0), slider(-100000.0, 100000.0, 0.0, 60.0, 2)),
+ p("stabilize", "Stabilize", Value::Enum(0), popup(&["Brightness", "Levels", "Curves"])),
+ p("blackPoint", "Black Point", Value::Vec2([0.25, 0.75]), ParamUi::Point),
+ p("midPoint", "Mid Point", Value::Vec2([0.5, 0.5]), ParamUi::Point),
+ p("whitePoint", "White Point", Value::Vec2([0.75, 0.25]), ParamUi::Point),
+ p("sampleSize", "Sample Size", num(5.0), slider(1.0, 100.0, 1.0, 50.0, 0)),
+ ],
+ color_stabilizer,
+ ),
+ spec(
+ "ec.utility.colorprofileconverter",
+ "Color Profile Converter",
+ "Utility",
+ vec![
+ p("inputProfile", "Input Profile", Value::Enum(0), popup(PROFILES)),
+ p("linearizeInputProfile", "Linearize Input Profile", Value::Bool(false), ParamUi::Checkbox),
+ p("outputProfile", "Output Profile", Value::Enum(1), popup(PROFILES)),
+ p("linearizeOutputProfile", "Linearize Output Profile", Value::Bool(false), ParamUi::Checkbox),
+ p("intent", "Intent", Value::Enum(1), popup(&["Perceptual", "Relative Colorimetric", "Saturation", "Absolute Colorimetric"])),
+ // Our built-in profiles share a zero black point and none is scene-referred, so
+ // these two are kept for compatibility and do not change the result.
+ p("useBlackPointCompensation", "Use Black Point Compensation", Value::Bool(true), ParamUi::Checkbox),
+ p("sceneRefCompensation", "Scene-ref. Profile Compensation", Value::Enum(2), popup(&["On", "Off", "Use Project Setting"])),
+ ],
+ profile_converter,
+ ),
+ ]
+}
diff --git a/crates/effects/src/ocio/space.rs b/crates/effects/src/ocio/space.rs
new file mode 100644
index 000000000..44fcf84d0
--- /dev/null
+++ b/crates/effects/src/ocio/space.rs
@@ -0,0 +1,214 @@
+use super::*;
+
+pub(super) type M3 = [[f64; 3]; 3];
+
+pub(crate) const D65: [f64; 2] = [0.3127, 0.3290];
+
+const ACES_WHITE: [f64; 2] = [0.32168, 0.33767];
+
+const AP0: [[f64; 2]; 3] = [[0.7347, 0.2653], [0.0, 1.0], [0.0001, -0.0770]];
+
+const AP1: [[f64; 2]; 3] = [[0.713, 0.293], [0.165, 0.830], [0.128, 0.044]];
+
+pub(crate) const REC709: [[f64; 2]; 3] = [[0.640, 0.330], [0.300, 0.600], [0.150, 0.060]];
+
+pub(crate) const REC2020: [[f64; 2]; 3] = [[0.708, 0.292], [0.170, 0.797], [0.131, 0.046]];
+
+pub(crate) const P3: [[f64; 2]; 3] = [[0.680, 0.320], [0.265, 0.690], [0.150, 0.060]];
+
+pub(super) const IDENTITY: M3 = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
+
+/// Transfer functions (encoded ↔ linear).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Tf {
+ Linear,
+ Srgb,
+ Gamma(f64),
+ AcesCct,
+ /// ACEScc (Academy S-2014-003), the pure-log grading encoding.
+ AcesCc,
+ /// SMPTE ST 2084 with 1.0 = 100 cd/m².
+ Pq,
+}
+
+/// ACEScc: the lowest code value (linear 0 and below) and the end of its toe (linear 2⁻¹⁵).
+const ACESCC_MIN: f64 = (-16.0 + 9.72) / 17.52;
+
+const ACESCC_TOE: f64 = (-15.0 + 9.72) / 17.52;
+
+impl Tf {
+ pub fn decode(self, v: f64) -> f64 {
+ match self {
+ Tf::Linear => v,
+ Tf::Srgb => {
+ let a = v.abs();
+ let l = if a <= 0.04045 { a / 12.92 } else { ((a + 0.055) / 1.055).powf(2.4) };
+ l.copysign(v)
+ }
+ Tf::Gamma(g) => v.abs().powf(g).copysign(v),
+ Tf::AcesCct => {
+ if v <= 0.155_251_141_552_511 {
+ (v - 0.072_905_534_195_835_5) / 10.540_237_741_654_5
+ } else if v < (65504f64.log2() + 9.72) / 17.52 {
+ 2f64.powf(v * 17.52 - 9.72)
+ } else {
+ 65504.0
+ }
+ }
+ Tf::AcesCc => {
+ if v < ACESCC_TOE {
+ (2f64.powf(v * 17.52 - 9.72) - 2f64.powi(-16)) * 2.0
+ } else if v < (65504f64.log2() + 9.72) / 17.52 {
+ 2f64.powf(v * 17.52 - 9.72)
+ } else {
+ 65504.0
+ }
+ }
+ Tf::Pq => {
+ let (m1, m2, c1, c2, c3) = pq_consts();
+ let e = v.max(0.0).powf(1.0 / m2);
+ let l = ((e - c1).max(0.0) / (c2 - c3 * e)).powf(1.0 / m1);
+ l * 100.0
+ }
+ }
+ }
+ pub fn encode(self, v: f64) -> f64 {
+ match self {
+ Tf::Linear => v,
+ Tf::Srgb => {
+ let a = v.abs();
+ let e = if a <= 0.003_130_8 { a * 12.92 } else { 1.055 * a.powf(1.0 / 2.4) - 0.055 };
+ e.copysign(v)
+ }
+ Tf::Gamma(g) => v.abs().powf(1.0 / g).copysign(v),
+ Tf::AcesCct => {
+ if v <= 0.007_812_5 {
+ 10.540_237_741_654_5 * v + 0.072_905_534_195_835_5
+ } else {
+ (v.log2() + 9.72) / 17.52
+ }
+ }
+ Tf::AcesCc => {
+ if v <= 0.0 {
+ ACESCC_MIN
+ } else if v < 2f64.powi(-15) {
+ ((2f64.powi(-16) + v * 0.5).log2() + 9.72) / 17.52
+ } else {
+ (v.log2() + 9.72) / 17.52
+ }
+ }
+ Tf::Pq => {
+ let (m1, m2, c1, c2, c3) = pq_consts();
+ let y = (v / 100.0).max(0.0).powf(m1);
+ ((c1 + c2 * y) / (1.0 + c3 * y)).powf(m2)
+ }
+ }
+ }
+}
+
+fn pq_consts() -> (f64, f64, f64, f64, f64) {
+ (2610.0 / 16384.0, 2523.0 / 4096.0 * 128.0, 3424.0 / 4096.0, 2413.0 / 4096.0 * 32.0, 2392.0 / 4096.0 * 32.0)
+}
+
+/// A colour space of the built-in config.
+#[derive(Clone, Copy, Debug)]
+pub struct Space {
+ pub name: &'static str,
+ /// Primaries and white (None = CIE XYZ itself).
+ pub prims: Option<([[f64; 2]; 3], [f64; 2])>,
+ pub tf: Tf,
+ /// Passes data through untouched.
+ pub raw: bool,
+}
+
+pub(crate) const fn sp(name: &'static str, prims: [[f64; 2]; 3], white: [f64; 2], tf: Tf) -> Space {
+ Space { name, prims: Some((prims, white)), tf, raw: false }
+}
+
+/// The built-in configuration's colour spaces, in popup order.
+pub(crate) const ACES2065_1: Space = sp("ACES2065-1", AP0, ACES_WHITE, Tf::Linear);
+
+pub(crate) const ACES_CG: Space = sp("ACEScg", AP1, ACES_WHITE, Tf::Linear);
+
+pub(super) const ACES_CCT: Space = sp("ACEScct", AP1, ACES_WHITE, Tf::AcesCct);
+
+pub const SPACES: &[Space] = &[
+ ACES2065_1,
+ ACES_CG,
+ ACES_CCT,
+ sp("Linear Rec.709 (sRGB)", REC709, D65, Tf::Linear),
+ sp("sRGB", REC709, D65, Tf::Srgb),
+ sp("Gamma 2.4 Rec.709", REC709, D65, Tf::Gamma(2.4)),
+ sp("Linear Rec.2020", REC2020, D65, Tf::Linear),
+ sp("Gamma 2.4 Rec.2020", REC2020, D65, Tf::Gamma(2.4)),
+ sp("Linear P3-D65", P3, D65, Tf::Linear),
+ sp("Display P3", P3, D65, Tf::Srgb),
+ Space { name: "CIE-XYZ-D65", prims: None, tf: Tf::Linear, raw: false },
+ Space { name: "Raw", prims: None, tf: Tf::Linear, raw: true },
+];
+
+pub fn space_names() -> Vec<&'static str> {
+ SPACES.iter().map(|s| s.name).collect()
+}
+
+#[cfg(test)]
+pub fn space_by_name(n: &str) -> Option<&'static Space> {
+ SPACES.iter().find(|s| s.name.eq_ignore_ascii_case(n))
+}
+
+/// Bradford chromatic adaptation from white `src` to white `dst` (xy).
+pub fn bradford(src: [f64; 2], dst: [f64; 2]) -> M3 {
+ if src == dst {
+ return IDENTITY;
+ }
+ const MB: M3 = [[0.8951, 0.2664, -0.1614], [-0.7502, 1.7135, 0.0367], [0.0389, -0.0685, 1.0296]];
+ let xyz = |c: [f64; 2]| [c[0] / c[1], 1.0, (1.0 - c[0] - c[1]) / c[1]];
+ let s = mul_vec(&MB, xyz(src));
+ let d = mul_vec(&MB, xyz(dst));
+ let diag = [[d[0] / s[0], 0.0, 0.0], [0.0, d[1] / s[1], 0.0], [0.0, 0.0, d[2] / s[2]]];
+ mul(&invert(&MB), &mul(&diag, &MB))
+}
+
+impl Space {
+ /// Linear RGB → XYZ D65 (Bradford-adapted when `adapt`, else the space's own white).
+ pub fn to_ref(self, adapt: bool) -> M3 {
+ match self.prims {
+ None => IDENTITY,
+ Some((p, w)) => {
+ let m = rgb_to_xyz(p, w);
+ if adapt { mul(&bradford(w, D65), &m) } else { m }
+ }
+ }
+ }
+}
+
+/// Linear-RGB matrix from space `a` to space `b`.
+pub fn matrix(a: &Space, b: &Space) -> M3 {
+ mul(&invert(&b.to_ref(true)), &a.to_ref(true))
+}
+
+/// A compiled colour-space conversion.
+#[derive(Clone, Copy, Debug)]
+pub struct Xform {
+ pub(super) dec: Tf,
+ pub(super) m: [[f32; 3]; 3],
+ pub(super) ident: bool,
+ pub(super) enc: Tf,
+}
+
+impl Xform {
+ pub fn new(a: &Space, b: &Space) -> Xform {
+ if a.raw || b.raw {
+ return Xform { dec: Tf::Linear, m: IDENTITY.map(|r| r.map(|v| v as f32)), ident: true, enc: Tf::Linear };
+ }
+ let m = matrix(a, b);
+ let ident = (0..3).all(|i| (0..3).all(|j| (m[i][j] - IDENTITY[i][j]).abs() < 1e-12));
+ Xform { dec: a.tf, m: m.map(|r| r.map(|v| v as f32)), ident, enc: b.tf }
+ }
+ #[inline]
+ pub fn apply(&self, c: [f32; 3]) -> [f32; 3] {
+ let l = c.map(|v| self.dec.decode(v as f64) as f32);
+ let l = if self.ident { l } else { [0, 1, 2].map(|i| self.m[i][0] * l[0] + self.m[i][1] * l[1] + self.m[i][2] * l[2]) };
+ l.map(|v| self.enc.encode(v as f64) as f32)
+ }
+}
diff --git a/crates/effects/src/ocio/tests.rs b/crates/effects/src/ocio/tests.rs
new file mode 100644
index 000000000..edbc6eff2
--- /dev/null
+++ b/crates/effects/src/ocio/tests.rs
@@ -0,0 +1,313 @@
+use super::*;
+use crate::{EffectEnv, EffectHost, Image, LayerPixels, run_fx};
+
+fn close(a: M3, b: M3, tol: f64) {
+ for i in 0..3 {
+ for j in 0..3 {
+ assert!((a[i][j] - b[i][j]).abs() < tol, "{a:?} vs {b:?}");
+ }
+ }
+}
+
+#[test]
+fn aces_matrices_match_published_values() {
+ let ap0 = space_by_name("ACES2065-1").unwrap();
+ let ap1 = space_by_name("ACEScg").unwrap();
+ // Academy S-2014-004 AP0 → AP1.
+ close(
+ matrix(ap0, ap1),
+ [
+ [1.451_439_316_1, -0.236_510_746_9, -0.214_928_569_3],
+ [-0.076_553_773_4, 1.176_229_699_8, -0.099_675_926_4],
+ [0.008_316_148_4, -0.006_032_449_8, 0.997_716_301_4],
+ ],
+ 2e-4,
+ );
+ // ACEScg → linear Rec.709 with Bradford adaptation (published ACES config value).
+ let lin = space_by_name("Linear Rec.709 (sRGB)").unwrap();
+ close(matrix(ap1, lin), [[1.705_05, -0.621_79, -0.083_26], [-0.130_26, 1.140_80, -0.010_55], [-0.024_00, -0.128_97, 1.152_97]], 2e-3);
+ // White maps to white.
+ let w = mul_vec(&matrix(ap1, lin), [1.0, 1.0, 1.0]);
+ assert!(w.iter().all(|v| (v - 1.0).abs() < 1e-3), "{w:?}");
+}
+
+#[test]
+fn transfer_functions_round_trip() {
+ for tf in [Tf::Srgb, Tf::Gamma(2.4), Tf::AcesCct, Tf::Pq] {
+ for v in [0.0, 0.001, 0.18, 0.5, 1.0, 4.0] {
+ let r = tf.decode(tf.encode(v));
+ assert!((r - v).abs() < 1e-6 * v.max(1.0), "{tf:?} {v} {r}");
+ }
+ }
+ // ACEScct of 18 % grey (S-2016-001).
+ assert!((Tf::AcesCct.encode(0.18) - 0.413_588).abs() < 1e-5);
+ // PQ: 100 nits (1.0) encodes to ≈ 0.508.
+ assert!((Tf::Pq.encode(1.0) - 0.508).abs() < 1e-3);
+}
+
+#[test]
+fn color_space_transform_effect_round_trips() {
+ let img = Image::filled(4, 4, [0.2, 0.5, 0.7, 1.0]);
+ let srgb = SPACES.iter().position(|s| s.name == "sRGB").unwrap() as u32;
+ let cg = SPACES.iter().position(|s| s.name == "ACEScg").unwrap() as u32;
+ let a = run_fx("ec.color.ociocolorspace", &[("source", Value::Enum(srgb)), ("destination", Value::Enum(cg))], img.clone(), 0.0, EffectEnv::default());
+ assert_ne!(a.img.data, img.data);
+ let b = run_fx("ec.color.ociocolorspace", &[("source", Value::Enum(cg)), ("destination", Value::Enum(srgb))], a.img.clone(), 0.0, EffectEnv::default());
+ let c = run_fx(
+ "ec.color.ociocolorspace",
+ &[("source", Value::Enum(srgb)), ("destination", Value::Enum(cg)), ("direction", Value::Enum(1))],
+ a.img,
+ 0.0,
+ EffectEnv::default(),
+ );
+ for (x, y) in b.img.data.iter().zip(&img.data).chain(c.img.data.iter().zip(&img.data)) {
+ assert!((0..4).all(|k| (x[k] - y[k]).abs() < 1e-4), "{x:?} {y:?}");
+ }
+}
+
+#[test]
+fn cdl_math() {
+ let cdl = Cdl { slope: [1.2, 1.0, 0.8], offset: [0.05, 0.0, -0.02], power: [1.1, 1.0, 0.9], sat: 0.8 };
+ let c = [0.3, 0.5, 0.7];
+ // Hand computation of the v1.2 formula.
+ let sop = [(0.3f64 * 1.2 + 0.05).powf(1.1), 0.5, (0.7f64 * 0.8 - 0.02).powf(0.9)];
+ let l = sop[0] * 0.2126 + sop[1] * 0.7152 + sop[2] * 0.0722;
+ let want = sop.map(|v| l + 0.8 * (v - l));
+ let got = cdl.apply(c, true);
+ for k in 0..3 {
+ assert!((got[k] - want[k]).abs() < 1e-12);
+ }
+ let back = cdl.invert(got, true);
+ for k in 0..3 {
+ assert!((back[k] - c[k]).abs() < 1e-9);
+ }
+ // v1.2 clamps, No Clamp keeps negatives.
+ let neg = Cdl { offset: [-0.5; 3], ..Cdl::default() };
+ assert_eq!(neg.apply([0.2; 3], true), [0.0; 3]);
+ assert!((neg.apply([0.2; 3], false)[0] + 0.3).abs() < 1e-12);
+ let img = Image::filled(2, 2, [0.3, 0.5, 0.7, 1.0]);
+ let out = run_fx("ec.color.ociocdl", &[("slopeRed", num(1.2)), ("offsetRed", num(0.05)), ("powerRed", num(1.1))], img, 0.0, EffectEnv::default());
+ let r = (0.3f64 * 1.2 + 0.05).powf(1.1);
+ assert!((out.img.get(0, 0)[0] as f64 - r).abs() < 1e-5);
+}
+
+fn identity_lattice(n: usize, f: impl Fn([f32; 3]) -> [f32; 3]) -> Vec<[f32; 3]> {
+ let mut v = vec![];
+ for b in 0..n {
+ for g in 0..n {
+ for r in 0..n {
+ let s = (n - 1) as f32;
+ v.push(f([r as f32 / s, g as f32 / s, b as f32 / s]));
+ }
+ }
+ }
+ v
+}
+
+/// Sony Imageworks `.spi1d`, `.spi3d` and `.spimtx` (Blender's configs use them, #410), and
+/// malformed ones rejected without panicking.
+#[test]
+fn spi_files_parse() {
+ let spi1d = "Version 1\nFrom 0.0 2.0\nLength 3\nComponents 1\n{\n0.0\n0.25\n1.0\n}\n";
+ let x = parse_file(spi1d, "spi1d").unwrap();
+ let o = x.apply([1.0, 0.5, 2.0], 1, false, "");
+ assert!((o[0] - 0.25).abs() < 1e-6 && (o[1] - 0.125).abs() < 1e-6 && (o[2] - 1.0).abs() < 1e-6, "{o:?}");
+ let back = x.apply(o, 1, true, "");
+ assert!((back[0] - 1.0).abs() < 1e-5 && (back[2] - 2.0).abs() < 1e-5, "{back:?}");
+ let three = parse_spi1d("Version 1\nFrom 0 1\nLength 2\nComponents 3\n{\n0 0 0\n1 0.5 2\n}\n").unwrap();
+ assert_eq!(three.d1, vec![[0.0; 3], [1.0, 0.5, 2.0]]);
+ let mut spi3d = String::from("SPILUT 1.0\n3 3\n2 2 2\n");
+ for (r, g, b) in (0..8).map(|i| (i & 1, (i >> 1) & 1, i >> 2)) {
+ spi3d += &format!("{r} {g} {b} {} {} {}\n", r as f32 * 0.5, g, b);
+ }
+ let x = parse_file(&spi3d, "spi3d").unwrap();
+ let o = x.apply([1.0, 0.5, 0.25], 1, false, "");
+ assert!((o[0] - 0.5).abs() < 1e-6 && (o[1] - 0.5).abs() < 1e-6 && (o[2] - 0.25).abs() < 1e-6, "{o:?}");
+ let m = parse_file("2 0 0 6553.5\n0 1 0 0\n0 0 1 0\n", "spimtx").unwrap();
+ let o = m.apply([0.25, 0.5, 1.0], 1, false, "");
+ assert!((o[0] - 0.6).abs() < 1e-6 && o[1] == 0.5 && o[2] == 1.0, "{o:?}");
+ assert!((m.apply(o, 1, true, "")[0] - 0.25).abs() < 1e-6);
+ for bad in [
+ "Version 1\nFrom 0 1\nLength 99999999999\nComponents 1\n{\n0\n}\n",
+ "Version 1\nFrom 1 0\nLength 2\nComponents 1\n{\n0\n1\n}\n",
+ "Version 1\nFrom 0 1\nLength 3\nComponents 1\n{\n0\n1\n}\n",
+ "Version 1\nFrom 0 1\nLength 2\nComponents 2\n{\n0 0\n1 1\n}\n",
+ ] {
+ assert!(parse_spi1d(bad).is_none(), "{bad}");
+ }
+ assert!(parse_spi3d("SPILUT 1.0\n3 3\n4000 4000 4000\n").is_none());
+ assert!(parse_spi3d("SPILUT 1.0\n3 3\n2 2 2\n9 0 0 1 1 1\n").is_none());
+ assert!(parse_spi3d("SPILUT 1.0\n3 3\n2 2 2\n0 0 0 1 1 1\n").is_none(), "incomplete lattice");
+ assert!(parse_spimtx("1 0 0\n0 1 0\n").is_none());
+ assert!(parse_spimtx("NaN 0 0 0 0 1 0 0 0 0 1 0").is_none());
+}
+
+#[test]
+fn lut_files_parse_and_interpolate() {
+ // .cube with a non-linear lattice: trilinear between lattice points.
+ let f = |c: [f32; 3]| [c[0] * c[0], c[1], 1.0 - c[2]];
+ let mut cube = String::from("LUT_3D_SIZE 3\n");
+ for r in identity_lattice(3, f) {
+ cube += &format!("{} {} {}\n", r[0], r[1], r[2]);
+ }
+ let Some(FileXform::Lut { lut, .. }) = parse_file(&cube, "cube") else { panic!() };
+ // Trilinear between 0.5 (0.25) and 1.0 (1.0) at 0.75 → 0.625.
+ let o = lut.apply_interp([0.75, 0.3, 0.2], 1);
+ assert!((o[0] - 0.625).abs() < 1e-6 && (o[1] - 0.3).abs() < 1e-6 && (o[2] - 0.8).abs() < 1e-6, "{o:?}");
+ // Nearest snaps.
+ assert_eq!(lut.apply_interp([0.74, 0.0, 0.0], 0)[0], 0.25);
+ // .3dl (blue fastest, 10-bit integers, mesh line).
+ let mut tdl = String::from("0 511 1023\n");
+ for r in 0..3 {
+ for g in 0..3 {
+ for b in 0..3 {
+ let v = [r, g, b].map(|i| i as f64 * 511.5);
+ tdl += &format!("{} {} {}\n", v[0].round(), v[1].round(), (1023.0 - v[2]).round());
+ }
+ }
+ }
+ let Some(FileXform::Lut { lut, .. }) = parse_file(&tdl, "3dl") else { panic!() };
+ let o = lut.apply_interp([0.25, 0.5, 0.25], 1);
+ assert!((o[0] - 0.25).abs() < 2e-3 && (o[1] - 0.5).abs() < 2e-3 && (o[2] - 0.75).abs() < 2e-3, "{o:?}");
+ // .csp with a squaring pre-LUT on red and an identity 2³ lattice.
+ let mut csp = String::from("CSPLUTV100\n3D\n\n3\n0 0.5 1\n0 0.25 1\n2\n0 1\n0 1\n2\n0 1\n0 1\n\n2 2 2\n");
+ for r in identity_lattice(2, |c| c) {
+ csp += &format!("{} {} {}\n", r[0], r[1], r[2]);
+ }
+ let x = parse_file(&csp, "csp").unwrap();
+ let o = x.apply([0.5, 0.4, 0.6], 2, false, "");
+ assert!((o[0] - 0.25).abs() < 1e-6 && (o[1] - 0.4).abs() < 1e-6, "{o:?}");
+ let inv = x.apply(o, 2, true, "");
+ assert!((inv[0] - 0.5).abs() < 1e-4, "{inv:?}");
+ // CDL collection: pick by id.
+ let ccc = r#"2 2 20 0 01 1 1
+ 0.5 0.5 0.51"#;
+ let x = parse_file(ccc, "ccc").unwrap();
+ assert!((x.apply([0.4; 3], 2, false, "b")[0] - 0.2).abs() < 1e-6);
+ assert!((x.apply([0.4; 3], 2, false, "a")[0] - 0.8).abs() < 1e-6);
+ assert!((x.apply([0.4; 3], 2, false, "")[0] - 0.8).abs() < 1e-6);
+ // Effect with inline content; inverse of a 3D lattice.
+ let img = Image::filled(2, 2, [0.6, 0.3, 0.2, 1.0]);
+ let out = run_fx("ec.color.ociofile", &[("file", Value::Str(cube.clone()))], img.clone(), 0.0, EffectEnv::default());
+ let back = run_fx("ec.color.ociofile", &[("file", Value::Str(cube)), ("direction", Value::Enum(1))], out.img, 0.0, EffectEnv::default());
+ assert!((back.img.get(0, 0)[0] - 0.6).abs() < 1e-3, "{:?}", back.img.get(0, 0));
+ assert!(parse_file("garbage", "3dl").is_none());
+}
+
+#[test]
+fn display_and_look_transforms() {
+ // Linear 0.18 through the sRGB display / Standard view = sRGB encoding of 0.18.
+ let img = Image::filled(2, 2, [0.18, 0.18, 0.18, 1.0]);
+ let out = run_fx("ec.color.ociodisplay", &[], img.clone(), 0.0, EffectEnv::default());
+ assert!((out.img.get(0, 0)[0] as f64 - Tf::Srgb.encode(0.18)).abs() < 1e-5);
+ let back = run_fx("ec.color.ociodisplay", &[("direction", Value::Enum(1))], out.img, 0.0, EffectEnv::default());
+ assert!((back.img.get(0, 0)[0] - 0.18).abs() < 1e-5);
+ // Tone mapped view keeps highlights below 1.
+ let hot = Image::filled(1, 1, [8.0, 8.0, 8.0, 1.0]);
+ let tm = run_fx("ec.color.ociodisplay", &[("view", Value::Enum(1))], hot, 0.0, EffectEnv::default());
+ assert!(tm.img.get(0, 0)[0] < 1.0);
+ assert!((tonemap_inv(tonemap(3.0)) - 3.0).abs() < 1e-9);
+ // Looks: Warm raises red over blue; its inverse undoes it.
+ let grey = Image::filled(1, 1, [0.18, 0.18, 0.18, 1.0]);
+ let w = run_fx("ec.color.ociolook", &[("looks", Value::Str("Warm".into()))], grey.clone(), 0.0, EffectEnv::default());
+ let px = w.img.get(0, 0);
+ assert!(px[0] > px[2]);
+ let u = run_fx("ec.color.ociolook", &[("looks", Value::Str("-Warm".into()))], w.img, 0.0, EffectEnv::default());
+ assert!((u.img.get(0, 0)[0] - 0.18).abs() < 1e-4 && (u.img.get(0, 0)[2] - 0.18).abs() < 1e-4);
+ assert_eq!(parse_looks("Warm, -Cool, nope").len(), 2);
+}
+
+#[test]
+fn profile_converter_converts_and_round_trips() {
+ let img = Image::filled(2, 2, [0.8, 0.4, 0.1, 1.0]);
+ // sRGB → Rec. 2020 (relative), then back.
+ let a = run_fx(
+ "ec.utility.colorprofileconverter",
+ &[("inputProfile", Value::Enum(1)), ("outputProfile", Value::Enum(3))],
+ img.clone(),
+ 0.0,
+ EffectEnv::default(),
+ );
+ assert_ne!(a.img.data, img.data);
+ let b =
+ run_fx("ec.utility.colorprofileconverter", &[("inputProfile", Value::Enum(3)), ("outputProfile", Value::Enum(1))], a.img, 0.0, EffectEnv::default());
+ assert!((0..3).all(|k| (b.img.get(0, 0)[k] - img.get(0, 0)[k]).abs() < 1e-4));
+ // Same profile both sides: identity. Working space defaults to sRGB.
+ let c = run_fx(
+ "ec.utility.colorprofileconverter",
+ &[("inputProfile", Value::Enum(0)), ("outputProfile", Value::Enum(1))],
+ img.clone(),
+ 0.0,
+ EffectEnv::default(),
+ );
+ assert_eq!(c.img.data, img.data);
+ // Perceptual pulls out-of-gamut colours inside: saturated Rec.2020 green into sRGB.
+ let g = Image::filled(1, 1, [0.0, 1.0, 0.0, 1.0]);
+ let rel = run_fx(
+ "ec.utility.colorprofileconverter",
+ &[("inputProfile", Value::Enum(3)), ("outputProfile", Value::Enum(1))],
+ g.clone(),
+ 0.0,
+ EffectEnv::default(),
+ );
+ assert!(rel.img.get(0, 0)[0] < 0.0);
+ let per = run_fx(
+ "ec.utility.colorprofileconverter",
+ &[("inputProfile", Value::Enum(3)), ("outputProfile", Value::Enum(1)), ("intent", Value::Enum(0))],
+ g,
+ 0.0,
+ EffectEnv::default(),
+ );
+ assert!(per.img.get(0, 0).iter().all(|v| *v >= -1e-6));
+}
+
+struct RefHost(Image);
+impl EffectHost for RefHost {
+ fn layer(&self, _: u64, _: bool) -> Option {
+ None
+ }
+ fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option> {
+ None
+ }
+ fn self_at(&self, _: f64, _: usize) -> Option {
+ Some(Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 })
+ }
+}
+
+#[test]
+fn color_stabilizer_matches_the_reference_frame() {
+ let mk = |k: f32, o: f32| {
+ let mut img = Image::new(40, 40);
+ for y in 0..40 {
+ for x in 0..40 {
+ let v = (x as f32 / 40.0) * k + o;
+ img.set(x, y, [v, v * 0.9, v * 0.8, 1.0]);
+ }
+ }
+ img
+ };
+ let reference = mk(1.0, 0.0);
+ let flicker = mk(0.8, 0.1);
+ let host = RefHost(reference.clone());
+ let env = EffectEnv { host: Some(&host), ..Default::default() };
+ let pts = [("blackPoint", Value::Vec2([5.0, 20.0])), ("midPoint", Value::Vec2([20.0, 20.0])), ("whitePoint", Value::Vec2([35.0, 20.0]))];
+ let mut vals: Vec<(&str, Value)> = pts.to_vec();
+ vals.push(("stabilize", Value::Enum(1)));
+ vals.push(("sampleSize", num(1.0)));
+ let out = run_fx("ec.color.colorstabilizer", &vals, flicker.clone(), 0.0, env);
+ for x in [5i64, 20, 35] {
+ let (o, r) = (out.img.get(x, 20), reference.get(x, 20));
+ assert!((o[0] - r[0]).abs() < 0.01, "x {x}: {o:?} vs {r:?}");
+ }
+ // Deterministic, and a no-op without a host.
+ let again = run_fx("ec.color.colorstabilizer", &vals, flicker.clone(), 0.0, env);
+ assert_eq!(out.img.data, again.img.data);
+ let none = run_fx("ec.color.colorstabilizer", &vals, flicker.clone(), 0.0, EffectEnv::default());
+ assert_eq!(none.img.data, flicker.data);
+ // Brightness mode corrects an offset at the black point.
+ let lifted = mk(1.0, 0.1);
+ let mut vals2: Vec<(&str, Value)> = pts.to_vec();
+ vals2.push(("sampleSize", num(1.0)));
+ let b = run_fx("ec.color.colorstabilizer", &vals2, lifted, 0.0, env);
+ assert!((b.img.get(5, 20)[0] - reference.get(5, 20)[0]).abs() < 0.01);
+}
diff --git a/crates/effects/src/ocio_config.rs b/crates/effects/src/ocio_config.rs
index 5ea844414..af860c2fc 100644
--- a/crates/effects/src/ocio_config.rs
+++ b/crates/effects/src/ocio_config.rs
@@ -20,7 +20,7 @@
//! * `looks` (`name`, `process_space`, `transform`, `inverse_transform`) and look strings
//! (`+A, -B`, `A | B` = the first one the config has);
//! * transforms: `MatrixTransform` (`matrix` 4×4 row-major, `offset`), `FileTransform` (the LUT,
-//! CDL and matrix files [`super::ocio::parse_file`] reads; `interpolation`, `ccc_id`),
+//! CDL and matrix files `super::ocio::parse_file` reads; `interpolation`, `ccc_id`),
//! `ExponentTransform` (`value`), `ExponentWithLinearTransform` (`gamma`, `offset`, `style:
//! mirror`; the power curve with a linear toe that the Academy CLF specification calls
//! "moncurve"), `LogTransform` (`base`), `LogAffineTransform` (`base`, `logSideSlope`,
@@ -1331,401 +1331,4 @@ pub fn load_config(src: &str) -> Result, String> {
}
#[cfg(test)]
-mod tests {
- use super::*;
-
- const CONFIG: &str = r#"
-ocio_profile_version: 2
-
-name: Test Config # a comment
-search_path: "luts:other"
-roles:
- scene_linear: lin
- color_timing: "log2"
-
-displays:
- sRGB:
- - ! {name: Standard, colorspace: gamma22}
- - ! {name: Raw, colorspace: raw}
-
-colorspaces:
- - !
- name: lin
- family: ""
- description: |
- The reference.
- Linear.
- isdata: false
-
- - !
- name: gamma22
- aliases: [g22, "gamma 2.2"]
- to_scene_reference: ! {value: [2.2, 2.2, 2.2, 1]}
-
- - !
- name: half
- from_reference: ! {matrix: [0.5, 0, 0, 0,
- 0, 0.5, 0, 0,
- 0, 0, 0.5, 0,
- 0, 0, 0, 1], offset: [0.1, 0.1, 0.1, 0]}
-
- - !
- name: log2
- from_reference: !
- children:
- - ! {matrix: [2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1]}
- - ! {base: 2}
-
- - !
- name: affine
- to_reference: ! {base: 10, logSideSlope: 0.5, logSideOffset: 0.2, linSideSlope: 2, linSideOffset: 0.01, direction: inverse}
-
- - !
- name: lut
- to_reference: ! {src: double.cube, interpolation: linear}
-
- - !
- name: raw
- isdata: true
-
- - !
- name: weird
- to_reference: ! {exposure: 1}
-"#;
-
- fn close(a: [f64; 3], b: [f64; 3], tol: f64) -> bool {
- (0..3).all(|i| (a[i] - b[i]).abs() < tol)
- }
-
- fn temp_dir(name: &str) -> PathBuf {
- let dir = std::env::temp_dir().join(format!("ec-ocio-{name}-{}", std::process::id()));
- std::fs::create_dir_all(dir.join("luts")).unwrap();
- dir
- }
-
- #[test]
- fn yaml_subset() {
- let y = parse_yaml("a: 1\nb:\n - x\n - {k: [1, 2], s: 'q: r'}\nc: ! {v: 3}\nd:\n- 4\n- 5\n");
- assert_eq!(y.get("a").and_then(Yaml::str), Some("1"));
- assert_eq!(y.get("b").unwrap().seq().len(), 2);
- assert_eq!(y.get("b").unwrap().seq()[1].get("k").unwrap().nums(), vec![1.0, 2.0]);
- assert_eq!(y.get("b").unwrap().seq()[1].get("s").and_then(Yaml::str), Some("q: r"));
- assert_eq!(y.get("c").unwrap().tag(), Some("T"));
- assert_eq!(y.get("c").unwrap().get("v").and_then(Yaml::str), Some("3"));
- assert_eq!(y.get("d").unwrap().seq().len(), 2, "a sequence at the key's indent");
- }
-
- /// Hostile nesting (flow brackets and block indentation) is cut off instead of exhausting
- /// the stack.
- #[test]
- fn yaml_nesting_is_bounded() {
- let flow = format!("a: {}\nb: 1\n", "[".repeat(200_000));
- assert!(matches!(parse_yaml(&flow), Yaml::Map(_)));
- let block: String = (0..2_000).map(|i| format!("{}k{i}:\n", " ".repeat(i))).collect();
- assert!(matches!(parse_yaml(&block), Yaml::Map(_)));
- let dashes: String = (0..2_000).map(|i| format!("{}- x{i}:\n", " ".repeat(2 * i))).collect();
- let _ = parse_yaml(&dashes);
- assert!(Config::parse(&flow, Path::new(".")).is_err());
- }
-
- #[test]
- fn parses_spaces_roles_displays_and_converts() {
- let dir = temp_dir("basic");
- // A 1D LUT that doubles (0..1 → 0..2).
- std::fs::write(dir.join("luts/double.cube"), "LUT_1D_SIZE 2\nDOMAIN_MIN 0 0 0\nDOMAIN_MAX 1 1 1\n0 0 0\n2 2 2\n").unwrap();
- let c = Config::parse(CONFIG, &dir).unwrap();
- assert_eq!(c.name, "Test Config");
- assert_eq!(c.search_path, vec!["luts", "other"]);
- assert_eq!(c.space_names(), vec!["lin", "gamma22", "half", "log2", "affine", "lut", "raw", "weird"]);
- // Roles and aliases resolve.
- assert_eq!(c.space("scene_linear").unwrap().name, "lin");
- assert_eq!(c.space("G22").unwrap().name, "gamma22");
- assert_eq!(c.space("gamma 2.2").unwrap().name, "gamma22");
- assert_eq!(c.view("sRGB", "Standard").unwrap().1.colorspace, "gamma22");
- let sp = |n: &str| c.space(n).unwrap();
- // gamma22 → lin: decode with the exponent.
- let g = c.convert(sp("gamma22"), sp("lin"), [0.5, 0.25, 1.0]);
- assert!(close(g, [0.5f64.powf(2.2), 0.25f64.powf(2.2), 1.0], 1e-9), "{g:?}");
- // lin → gamma22: the inverse (only to_reference given).
- let back = c.convert(sp("lin"), sp("gamma22"), g);
- assert!(close(back, [0.5, 0.25, 1.0], 1e-9), "{back:?}");
- // The display's view is that conversion.
- assert!(close(c.display_path(sp("lin"), "sRGB", "Standard").apply(g, false), [0.5, 0.25, 1.0], 1e-9));
- // lin → half: matrix and offset; and back through the inverse matrix.
- let h = c.convert(sp("lin"), sp("half"), [0.4, 0.6, 1.0]);
- assert!(close(h, [0.3, 0.4, 0.6], 1e-9), "{h:?}");
- assert!(close(c.convert(sp("half"), sp("lin"), h), [0.4, 0.6, 1.0], 1e-9));
- // lin → log2: a group (×2 then log2): 0.5 → 0; 2 → 2.
- let l = c.convert(sp("lin"), sp("log2"), [0.5, 2.0, 4.0]);
- assert!(close(l, [0.0, 2.0, 3.0], 1e-9), "{l:?}");
- assert!(close(c.convert(sp("log2"), sp("lin"), l), [0.5, 2.0, 4.0], 1e-9));
- // LogAffine (inverse direction as to_reference) round-trips.
- let a = c.convert(sp("lin"), sp("affine"), [0.18, 0.5, 1.0]);
- let expect = [0.18f64, 0.5, 1.0].map(|v| 0.5 * (2.0 * v + 0.01).log10() + 0.2);
- assert!(close(a, expect, 1e-9), "{a:?} vs {expect:?}");
- assert!(close(c.convert(sp("affine"), sp("lin"), a), [0.18, 0.5, 1.0], 1e-9));
- // FileTransform found on the search path.
- let f = c.convert(sp("lut"), sp("lin"), [0.25, 0.5, 0.0]);
- assert!(close(f, [0.5, 1.0, 0.0], 1e-6), "{f:?}");
- // Data spaces pass through; unsupported transforms are reported.
- assert_eq!(c.convert(sp("raw"), sp("gamma22"), [0.3, 0.3, 0.3]), [0.3, 0.3, 0.3]);
- assert_eq!(c.unsupported(), vec!["ExposureContrastTransform".to_string()]);
- assert_eq!(c.path(sp("lin"), sp("weird")).unsupported_list(), vec!["ExposureContrastTransform".to_string()]);
- assert!(c.path(sp("lin"), sp("half")).unsupported_list().is_empty());
- // Loading from a file path (cached), and errors.
- std::fs::write(dir.join("config.ocio"), CONFIG).unwrap();
- let loaded = load_config(&dir.join("config.ocio").to_string_lossy()).unwrap();
- assert_eq!(loaded.spaces.len(), 8);
- assert!(load_config("/no/such/config.ocio").is_err());
- assert!(Config::parse("just: text\n", &dir).is_err());
- }
-
- /// The OCIO Color Space and Display Transform effects with Configuration ▸ Custom.
- #[test]
- fn effects_use_a_custom_config() {
- use effectcraft_keyframe::Value;
- let cfg = "ocio_profile_version: 1\nroles:\n default: lin\ndisplays:\n Monitor:\n - ! {name: Video, colorspace: g2}\ncolorspaces:\n - !\n name: lin\n - !\n name: g2\n to_reference: ! {value: [2, 2, 2, 1]}\n";
- let img = crate::Image::filled(2, 2, [0.5, 0.25, 1.0, 1.0]);
- let fx = |id: &str, extra: &[(&str, Value)]| {
- let mut v = vec![("config", Value::Enum(1)), ("configFile", Value::Str(cfg.into()))];
- v.extend(extra.iter().cloned());
- crate::run_fx(id, &v, img.clone(), 0.0, crate::EffectEnv::default()).img.data[0]
- };
- let o = fx("ec.color.ociocolorspace", &[("sourceName", Value::Str("g2".into())), ("destinationName", Value::Str("default".into()))]);
- assert!((o[0] - 0.25).abs() < 1e-6 && (o[1] - 0.0625).abs() < 1e-6 && (o[2] - 1.0).abs() < 1e-6, "{o:?}");
- // Inverse direction.
- let o = fx(
- "ec.color.ociocolorspace",
- &[("sourceName", Value::Str("g2".into())), ("destinationName", Value::Str("lin".into())), ("direction", Value::Enum(1))],
- );
- assert!((o[0] - 0.5f32.sqrt()).abs() < 1e-6, "{o:?}");
- // Display ▸ view → its colour space.
- let o = fx(
- "ec.color.ociodisplay",
- &[("sourceName", Value::Str("lin".into())), ("displayName", Value::Str("Monitor".into())), ("viewName", Value::Str("Video".into()))],
- );
- assert!((o[0] - 0.5f32.sqrt()).abs() < 1e-6, "{o:?}");
- // An unreadable config leaves pixels alone.
- let o = crate::run_fx(
- "ec.color.ociocolorspace",
- &[("config", Value::Enum(1)), ("configFile", Value::Str("/missing.ocio".into()))],
- img.clone(),
- 0.0,
- crate::EffectEnv::default(),
- );
- assert_eq!(o.img.data, img.data);
- }
-
- /// A config laid out like Blender 4.x / 5.x's (written for this test): the reference space is
- /// CIE XYZ with the E white, the D65 spaces adapt through a `.spimtx` matrix, sRGB is a
- /// ColorSpaceTransform plus an ExponentWithLinearTransform, the display-referred spaces meet
- /// the scene through the default view transform, and a log space uses an
- /// AllocationTransform.
- fn blender_like(dir: &Path) -> Config {
- use effectcraft_color::space::{invert, rgb_to_xyz};
- let e_to_d65 = crate::ocio::bradford([1.0 / 3.0, 1.0 / 3.0], D65);
- let rows = |m: [[f64; 3]; 3], sep: &str, end: &str| m.iter().map(|r| format!("{}{sep}{}{sep}{}{end}", r[0], r[1], r[2])).collect::>();
- std::fs::write(dir.join("luts/e_to_d65.spimtx"), rows(e_to_d65, " ", " 0\n").concat()).unwrap();
- let xyz_to_709 = rows(invert(&rgb_to_xyz(REC709, D65)), ", ", ", 0").join(", ");
- let text = format!(
- r#"ocio_profile_version: 2.4
-search_path: luts
-roles:
- reference: Linear CIE-XYZ E
- scene_linear: Linear Rec.709
- cie_xyz_d65_interchange: XYZ D65 Display
-default_view_transform: Standard
-view_transforms:
- - !
- name: Standard
- from_scene_reference: ! {{src: e_to_d65.spimtx, interpolation: linear}}
-displays:
- sRGB:
- - ! {{name: Standard, colorspace: sRGB}}
- - ! {{name: Display, view_transform: Standard, display_colorspace: sRGB Display}}
- - ! {{name: Log, colorspace: Log Encoding}}
- - ! {{name: Log Brighter, colorspace: Log Encoding, looks: +Brighter}}
- - ! {{name: Log Darker, colorspace: Log Encoding, looks: "-Brighter, Missing"}}
- - ! {{name: Raw, colorspace: Non-Color}}
-display_colorspaces:
- - !
- name: XYZ D65 Display
- isdata: false
- - !
- name: sRGB Display
- from_display_reference: !