mirror of
https://github.com/storytold/effectcraft.git
synced 2026-11-20 09:05:51 +00:00
The octave test asserts both values stay within OCTAVE_SCALE_MAX (it passed with the bound removed). The comment names Perspective Offset as what multiplies the offset by the depth, and says why an octave at the bound has no detail.
843 lines
39 KiB
Rust
843 lines
39 KiB
Rust
//! Fractal Noise and Turbulent Noise: one fractal value-noise engine with the parameter tree of
|
||
//! the two effects (Fractal Type, Noise Type, Overflow, the Transform / Sub Settings / Evolution
|
||
//! Options twirl-downs, Opacity and Blending Mode).
|
||
//!
|
||
//! Each "noise layer" (octave) is 3D value noise (x, y, evolution) on an integer lattice. The
|
||
//! Noise Type picks the interpolation between lattice values (Block = nearest, Linear,
|
||
//! Soft Linear = quadratic B-spline, Spline = Catmull-Rom). Successive layers are scaled by Sub
|
||
//! Scaling, weighted by Sub Influence, rotated by Sub Rotation and shifted by Sub Offset, and the
|
||
//! Fractal Type shapes each layer (turbulent types fold the signed noise; dynamic types warp the
|
||
//! domain; Max keeps the strongest layer; Strings keeps thin lines). Contrast / Brightness /
|
||
//! Overflow then map the sum to the output range. Cycle Evolution loops the evolution by
|
||
//! cross-fading two evolution offsets one cycle apart; Turbulent Noise's Turbulence Factor makes
|
||
//! finer layers evolve and drift faster than coarse ones.
|
||
|
||
use effectcraft_color::{BlendMode, blend_pixel};
|
||
use effectcraft_keyframe::Value;
|
||
use effectcraft_project::ParamUi;
|
||
use rayon::prelude::*;
|
||
|
||
use crate::generate::lattice;
|
||
use crate::{Buf, EffectCtx, EffectSpec, ParamSpec, num, p, popup, slider};
|
||
|
||
/// Fractal Type options (shared by both effects).
|
||
pub const FRACTAL_TYPES: [&str; 9] =
|
||
["Basic", "Turbulent Smooth", "Turbulent Basic", "Turbulent Sharp", "Dynamic", "Dynamic Twist", "Dynamic Progressive", "Max", "Strings"];
|
||
/// Noise Type options: interpolation between lattice values.
|
||
pub const NOISE_TYPES: [&str; 4] = ["Block", "Linear", "Soft Linear", "Spline"];
|
||
/// Overflow options.
|
||
pub const OVERFLOWS: [&str; 4] = ["Clip", "Soft Clamp", "Wrap Back", "Allow HDR Results"];
|
||
/// Blending Mode options: None renders the noise alone, the rest composite it over the layer.
|
||
pub const BLEND_MODES: [&str; 24] = [
|
||
"None",
|
||
"Normal",
|
||
"Add",
|
||
"Multiply",
|
||
"Screen",
|
||
"Overlay",
|
||
"Soft Light",
|
||
"Hard Light",
|
||
"Color Dodge",
|
||
"Color Burn",
|
||
"Darken",
|
||
"Lighten",
|
||
"Difference",
|
||
"Exclusion",
|
||
"Hue",
|
||
"Saturation",
|
||
"Color",
|
||
"Luminosity",
|
||
"Stencil Alpha",
|
||
"Stencil Luma",
|
||
"Silhouette Alpha",
|
||
"Silhouette Luma",
|
||
"Alpha Add",
|
||
"Luminescent Premul",
|
||
];
|
||
/// Index of "None" / "Normal" in [`BLEND_MODES`].
|
||
pub const BLEND_NONE: u32 = 0;
|
||
pub const BLEND_NORMAL: u32 = 1;
|
||
/// Index of "Soft Linear" in [`NOISE_TYPES`] (the default, and the GPU path's interpolation).
|
||
pub const NOISE_SOFT_LINEAR: u32 = 2;
|
||
|
||
/// Lattice cell of Fractal / Turbulent Noise in pixels per percent of Scale: After Effects 2026
|
||
/// draws Block noise at Scale 100 in 66.67 px cells (and Soft Linear noise has the matching
|
||
/// correlation length), not 100 px.
|
||
pub const NOISE_CELL: f64 = 2.0 / 3.0;
|
||
|
||
/// Sub Scaling (percent, After Effects' valid 10..10000) as the size ratio of each octave to the
|
||
/// one before it. Above 1 each octave is larger than the last.
|
||
pub fn sub_scaling_ratio(percent: f64) -> f64 {
|
||
(percent / 100.0).clamp(0.1, 100.0)
|
||
}
|
||
|
||
/// Bound on an octave's frequency and on its Perspective Offset depth (and their inverses).
|
||
/// Unbounded, at Sub Scaling 10000 and Complexity 20 they would reach 100^±19, and Perspective
|
||
/// Offset multiplying the offset by the depth (and by Turbulence Factor's drift) overflowed to
|
||
/// infinity (NaN noise, #3486). Sub Scaling 10..100 never reaches the bound (10^19 at most). Both
|
||
/// stay each other's inverse inside it, so an octave's offset in lattice cells is unchanged; at a
|
||
/// frequency of 1e-20 an octave spans under 1e-12 cells of any layer, so it has no detail either way.
|
||
pub const OCTAVE_SCALE_MAX: f32 = 1e20;
|
||
|
||
/// Bound on an octave's scaled Offset Turbulence in pixels, so a huge offset times the depth stays
|
||
/// finite. Times a frequency of at least 1 / [`OCTAVE_SCALE_MAX`], over cells of at most about
|
||
/// 6700 px (Scale 10000 %), it is still over 10^12 lattice cells, past where the lattice index
|
||
/// saturates (2^31), so the output is the same.
|
||
const OCTAVE_OFFSET_MAX: f32 = 1e36;
|
||
|
||
/// The next octave's (frequency, depth) from this one's, for a Sub Scaling ratio `s`.
|
||
#[inline]
|
||
fn next_octave(f: f32, depth: f32, s: f32) -> (f32, f32) {
|
||
let lo = 1.0 / OCTAVE_SCALE_MAX;
|
||
((f / s).clamp(lo, OCTAVE_SCALE_MAX), (depth * s).clamp(lo, OCTAVE_SCALE_MAX))
|
||
}
|
||
|
||
fn spec(id: &'static str, name: &'static str, params: Vec<ParamSpec>, render: crate::RenderFn) -> EffectSpec {
|
||
EffectSpec { id, name, category: "Noise & Grain", params, render, gpu: false, float: true }
|
||
}
|
||
|
||
fn params(turbulent: bool) -> Vec<ParamSpec> {
|
||
let pct = || slider(0.0, 100.0, 0.0, 100.0, 1);
|
||
let scale = || slider(1.0, 10000.0, 20.0, 600.0, 1);
|
||
let mut v = vec![
|
||
p("fractalType", "Fractal Type", Value::Enum(if turbulent { 1 } else { 0 }), popup(&FRACTAL_TYPES)),
|
||
p("noiseType", "Noise Type", Value::Enum(NOISE_SOFT_LINEAR), popup(&NOISE_TYPES)),
|
||
p("invert", "Invert", Value::Bool(false), ParamUi::Checkbox),
|
||
p("contrast", "Contrast", num(100.0), slider(0.0, 10000.0, 0.0, 400.0, 1)),
|
||
p("brightness", "Brightness", num(0.0), slider(-10000.0, 10000.0, -200.0, 200.0, 1)),
|
||
p("overflow", "Overflow", Value::Enum(if turbulent { 0 } else { 3 }), popup(&OVERFLOWS)),
|
||
p("transform/rotation", "Rotation", num(0.0), ParamUi::Angle),
|
||
p("transform/uniformScaling", "Uniform Scaling", Value::Bool(true), ParamUi::Checkbox),
|
||
p("transform/scale", "Scale", num(100.0), scale()),
|
||
p("transform/scaleWidth", "Scale Width", num(100.0), scale()),
|
||
p("transform/scaleHeight", "Scale Height", num(100.0), scale()),
|
||
p("transform/offset", "Offset Turbulence", Value::Vec2([0.5, 0.5]), ParamUi::Point),
|
||
p("transform/perspectiveOffset", "Perspective Offset", Value::Bool(false), ParamUi::Checkbox),
|
||
p("complexity", "Complexity", num(6.0), slider(1.0, 20.0, 1.0, 10.0, 1)),
|
||
p("subSettings/subInfluence", "Sub Influence (%)", num(70.0), slider(0.0, 100.0, 25.0, 100.0, 1)),
|
||
p("subSettings/subScaling", "Sub Scaling", num(56.0), slider(10.0, 10000.0, 25.0, 100.0, 1)),
|
||
];
|
||
if !turbulent {
|
||
v.extend([
|
||
p("subSettings/subRotation", "Sub Rotation", num(0.0), ParamUi::Angle),
|
||
p("subSettings/subOffset", "Sub Offset", Value::Vec2([0.0, 0.0]), ParamUi::Point),
|
||
p("subSettings/centerSubscale", "Center Subscale", Value::Bool(false), ParamUi::Checkbox),
|
||
]);
|
||
}
|
||
v.push(p("evolution", "Evolution", num(0.0), ParamUi::Angle));
|
||
if turbulent {
|
||
v.extend([
|
||
p("evolutionOptions/turbulenceFactor", "Turbulence Factor", num(0.5), slider(0.0, 10.0, 0.0, 2.0, 2)),
|
||
p("evolutionOptions/randomSeed", "Random Seed", num(0.0), slider(0.0, 100000.0, 0.0, 1000.0, 0)),
|
||
]);
|
||
} else {
|
||
v.extend([
|
||
p("evolutionOptions/cycleEvolution", "Cycle Evolution", Value::Bool(false), ParamUi::Checkbox),
|
||
p("evolutionOptions/cycle", "Cycle (in Revolutions)", num(1.0), slider(1.0, 1000.0, 1.0, 30.0, 0)),
|
||
p("evolutionOptions/seed", "Random Seed", num(0.0), slider(0.0, 100000.0, 0.0, 1000.0, 0)),
|
||
]);
|
||
}
|
||
v.extend([
|
||
p("opacity", "Opacity", num(100.0), pct()),
|
||
p("blendingMode", "Blending Mode", Value::Enum(BLEND_NORMAL), popup(&BLEND_MODES)),
|
||
// Not in After Effects: a mix with the untouched layer (kept for older projects).
|
||
p("blend", "Blend With Original", num(0.0), pct()),
|
||
]);
|
||
v
|
||
}
|
||
|
||
pub fn specs() -> Vec<EffectSpec> {
|
||
vec![spec("ec.noise.fractal", "Fractal Noise", params(false), fractal_noise), spec("ec.noise.turbulent", "Turbulent Noise", params(true), turbulent_noise)]
|
||
}
|
||
|
||
// ---------------------------------------------------------------- noise kernels
|
||
|
||
/// Soft Linear's gain about mid-grey. Averaging 3 × 3 lattice values leaves the B-spline 0.55² of
|
||
/// their variance, against 0.784² (181/231 per axis) for the quintic fade Soft Linear used before
|
||
/// (#259); the gain keeps the noise's contrast.
|
||
const SOFT_LINEAR_GAIN: f32 = (181.0 / 231.0) / 0.55;
|
||
|
||
#[inline]
|
||
fn catmull(p0: f32, p1: f32, p2: f32, p3: f32, t: f32) -> f32 {
|
||
0.5 * (2.0 * p1 + (p2 - p0) * t + (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3) * t * t + (3.0 * p1 - p0 - 3.0 * p2 + p3) * t * t * t)
|
||
}
|
||
|
||
/// Uniform quadratic B-spline weights of the lattice values before, at and after the nearest one,
|
||
/// for `t` = position − nearest + 0.5 in 0..1.
|
||
#[inline]
|
||
fn bspline(t: f32) -> [f32; 3] {
|
||
let s = 1.0 - t;
|
||
[0.5 * s * s, 0.5 + t * s, 0.5 * t * t]
|
||
}
|
||
|
||
/// 3D value noise in about 0..1 with the given [`NOISE_TYPES`] interpolation in x and y (the
|
||
/// evolution axis z always interpolates linearly, so evolution moves at a constant rate).
|
||
///
|
||
/// Soft Linear is linear interpolation softened by a one-cell box filter, which is the quadratic
|
||
/// B-spline: smooth like Spline from 9 lattice values instead of 16. A fade between two values
|
||
/// has zero slope across every lattice line, which the turbulent types and high contrast turned
|
||
/// into a visible grid (#259); the B-spline's slope there is half the neighbours' difference.
|
||
pub fn typed_noise(x: f32, y: f32, z: f32, seed: u32, noise_type: u32) -> f32 {
|
||
// Soft Linear's taps are centred on the nearest lattice point, the others start at the cell's.
|
||
let h = if noise_type == NOISE_SOFT_LINEAR { 0.5 } else { 0.0 };
|
||
let (x0, y0, z0) = ((x + h).floor(), (y + h).floor(), z.floor());
|
||
let (tx, ty, fz) = (x + h - x0, y + h - y0, z - z0);
|
||
let (ix, iy, iz) = (x0 as i32, y0 as i32, z0 as i32);
|
||
let l = |a: f32, b: f32, t: f32| a + (b - a) * t;
|
||
let slice = |dz: i32| -> f32 {
|
||
// Coordinates past the i32 range saturate; the neighbours wrap, as on the GPU (#3486).
|
||
let c = |dx: i32, dy: i32| lattice(ix.wrapping_add(dx), iy.wrapping_add(dy), iz.wrapping_add(dz), seed);
|
||
match noise_type {
|
||
0 => c(0, 0),
|
||
1 => l(l(c(0, 0), c(1, 0), tx), l(c(0, 1), c(1, 1), tx), ty),
|
||
NOISE_SOFT_LINEAR => {
|
||
let (wx, wy) = (bspline(tx), bspline(ty));
|
||
let row = |dy: i32| wx[0] * c(-1, dy) + wx[1] * c(0, dy) + wx[2] * c(1, dy);
|
||
wy[0] * row(-1) + wy[1] * row(0) + wy[2] * row(1)
|
||
}
|
||
_ => {
|
||
let row = |dy: i32| catmull(c(-1, dy), c(0, dy), c(1, dy), c(2, dy), tx);
|
||
catmull(row(-1), row(0), row(1), row(2), ty)
|
||
}
|
||
}
|
||
};
|
||
let n = l(slice(0), slice(1), fz);
|
||
if noise_type == NOISE_SOFT_LINEAR { 0.5 + (n - 0.5) * SOFT_LINEAR_GAIN } else { n }
|
||
}
|
||
|
||
/// Everything the per-pixel evaluation needs, resolved from the parameters.
|
||
pub(crate) struct Fractal {
|
||
pub kind: u32,
|
||
pub noise_type: u32,
|
||
pub contrast: f32,
|
||
pub brightness: f32,
|
||
pub overflow: u32,
|
||
pub invert: bool,
|
||
/// Rotation (sin, cos).
|
||
pub rot: (f32, f32),
|
||
/// Noise cell size in pixels along the rotated x / y axes.
|
||
pub size: [f32; 2],
|
||
/// Offset Turbulence in pixels, and the layer centre (for Perspective Offset).
|
||
pub origin: [f32; 2],
|
||
pub center: [f32; 2],
|
||
pub perspective: bool,
|
||
pub octaves: f32,
|
||
pub influence: f32,
|
||
/// Sub Scaling as a size ratio ([`sub_scaling_ratio`]: each octave is this much the size of the
|
||
/// one before).
|
||
pub sub_scaling: f32,
|
||
pub sub_rotation: f32,
|
||
/// Sub Offset in pixels.
|
||
pub sub_offset: [f32; 2],
|
||
pub center_subscale: bool,
|
||
/// Evolution in revolutions.
|
||
pub evolution: f32,
|
||
/// Cycle length in revolutions when Cycle Evolution is on.
|
||
pub cycle: Option<f32>,
|
||
pub turbulence: f32,
|
||
pub seed: u32,
|
||
}
|
||
|
||
#[inline]
|
||
fn shape(kind: u32, n: f32) -> f32 {
|
||
let s = n * 2.0 - 1.0;
|
||
match kind {
|
||
1 => 1.0 - s * s,
|
||
2 => 1.0 - s.abs(),
|
||
3 => (1.0 - s.abs()).powi(2),
|
||
8 => 1.0 - (s.abs() / 0.12).clamp(0.0, 1.0).powi(2),
|
||
_ => n,
|
||
}
|
||
}
|
||
|
||
impl Fractal {
|
||
pub(crate) fn from_params(ctx: &EffectCtx, b: &Buf, turbulent: bool) -> Fractal {
|
||
let pr = ctx.params;
|
||
let uniform = pr.get("transform/uniformScaling").is_none_or(Value::as_bool);
|
||
let s = pr.f("transform/scale");
|
||
let (sw, sh) = if uniform { (s, s) } else { (pr.f("transform/scaleWidth"), pr.f("transform/scaleHeight")) };
|
||
let rot = (pr.f("transform/rotation") as f32).to_radians();
|
||
let (ox, oy) = b.to_px(pr.v2("transform/offset"));
|
||
let (cx, cy) = b.to_px([ctx.layer_size[0] / 2.0, ctx.layer_size[1] / 2.0]);
|
||
let so = pr.v2("subSettings/subOffset");
|
||
let cycle = (!turbulent && pr.b("evolutionOptions/cycleEvolution")).then(|| pr.f("evolutionOptions/cycle").round().max(1.0) as f32);
|
||
let seed = if turbulent { (pr.f("evolutionOptions/randomSeed") as i64 as u32) ^ 0x7a3d } else { pr.f("evolutionOptions/seed") as u32 ^ 0x51ed };
|
||
Fractal {
|
||
kind: pr.e("fractalType"),
|
||
noise_type: pr.get("noiseType").map(Value::as_enum).unwrap_or(NOISE_SOFT_LINEAR),
|
||
contrast: pr.f("contrast") as f32 / 100.0,
|
||
brightness: pr.f("brightness") as f32 / 100.0,
|
||
overflow: pr.e("overflow"),
|
||
invert: pr.b("invert"),
|
||
rot: rot.sin_cos(),
|
||
size: [(sw * NOISE_CELL * b.scale).max(1.0) as f32, (sh * NOISE_CELL * b.scale).max(1.0) as f32],
|
||
origin: [ox as f32, oy as f32],
|
||
center: [cx as f32, cy as f32],
|
||
perspective: pr.b("transform/perspectiveOffset"),
|
||
octaves: pr.f("complexity").clamp(1.0, 20.0) as f32,
|
||
influence: (pr.f("subSettings/subInfluence") as f32 / 100.0).clamp(0.0, 1.0),
|
||
sub_scaling: sub_scaling_ratio(pr.f("subSettings/subScaling")) as f32,
|
||
sub_rotation: (pr.f("subSettings/subRotation") as f32).to_radians(),
|
||
sub_offset: [(so[0] * b.scale) as f32, (so[1] * b.scale) as f32],
|
||
center_subscale: pr.b("subSettings/centerSubscale"),
|
||
evolution: pr.f("evolution") as f32 / 360.0,
|
||
cycle,
|
||
turbulence: if turbulent { pr.f("evolutionOptions/turbulenceFactor").max(0.0) as f32 } else { 0.0 },
|
||
seed,
|
||
}
|
||
}
|
||
|
||
/// One noise layer at lattice coordinates (u, v) for octave `o` (evolution offset `z`), with
|
||
/// Cycle Evolution's loop. With turbulence, finer layers evolve faster.
|
||
#[inline]
|
||
fn layer(&self, u: f32, v: f32, o: f32, z: f32, seed: u32) -> f32 {
|
||
match self.cycle {
|
||
Some(c) => {
|
||
let t = self.evolution.rem_euclid(c);
|
||
let w = t / c;
|
||
let a = typed_noise(u, v, t + z, seed, self.noise_type);
|
||
let b = typed_noise(u, v, t - c + z, seed, self.noise_type);
|
||
a * (1.0 - w) + b * w
|
||
}
|
||
None => typed_noise(u, v, self.evolution * (1.0 + self.turbulence * o) + z, seed, self.noise_type),
|
||
}
|
||
}
|
||
|
||
/// Octave `of`'s origin in pixels, at Perspective Offset `depth`: Perspective Offset moves finer
|
||
/// (farther) layers less; turbulence makes them drift faster. The scaled offset stays within
|
||
/// ±[`OCTAVE_OFFSET_MAX`] (#3486).
|
||
#[inline]
|
||
fn octave_origin(&self, of: f32, depth: f32) -> [f32; 2] {
|
||
let k = if self.perspective { depth } else { 1.0 } * (1.0 + self.turbulence * of);
|
||
let mut org = self.origin;
|
||
if k != 1.0 {
|
||
let d = |i: usize| ((self.origin[i] - self.center[i]) * k).clamp(-OCTAVE_OFFSET_MAX, OCTAVE_OFFSET_MAX);
|
||
org = [self.center[0] + d(0), self.center[1] + d(1)];
|
||
}
|
||
if !self.center_subscale {
|
||
org = [org[0] + self.sub_offset[0] * of, org[1] + self.sub_offset[1] * of];
|
||
}
|
||
org
|
||
}
|
||
|
||
/// Raw fractal value (before contrast / overflow) at pixel centre (x, y).
|
||
pub(crate) fn raw(&self, x: f32, y: f32) -> f32 {
|
||
let n_oct = self.octaves.ceil() as usize;
|
||
let frac = self.octaves - self.octaves.floor();
|
||
let (sr, cr) = self.rot;
|
||
let (mut sum, mut norm, mut amp, mut f, mut best) = (0.0f32, 0.0f32, 1.0f32, 1.0f32, 0.0f32);
|
||
let mut depth = 1.0f32;
|
||
for o in 0..n_oct {
|
||
let w = if o + 1 == n_oct && frac > 0.0 { frac } else { 1.0 };
|
||
let of = o as f32;
|
||
let org = self.octave_origin(of, depth);
|
||
let (dx, dy) = (x - org[0], y - org[1]);
|
||
let (mut u, mut v) = ((dx * cr + dy * sr) / self.size[0], (-dx * sr + dy * cr) / self.size[1]);
|
||
if self.sub_rotation != 0.0 {
|
||
let (s, c) = (self.sub_rotation * of).sin_cos();
|
||
(u, v) = (u * c + v * s, -u * s + v * c);
|
||
}
|
||
let (mut u, mut v) = (u * f, v * f);
|
||
let z = of * 7.31;
|
||
let seed = self.seed.wrapping_add(o as u32);
|
||
if (4..=6).contains(&self.kind) {
|
||
// Dynamic: domain warp by a coarse field (Twist rotates, Progressive grows with depth).
|
||
let k = if self.kind == 6 { 0.5 + of * 0.35 } else { 1.0 };
|
||
let a = self.layer(u * 0.5, v * 0.5, of, z + 3.1, seed ^ 0x55) - 0.5;
|
||
let bb = self.layer(u * 0.5, v * 0.5, of, z + 5.7, seed ^ 0xaa) - 0.5;
|
||
if self.kind == 5 {
|
||
let (s, c) = (a * 3.0).sin_cos();
|
||
(u, v) = (u * c - v * s, u * s + v * c);
|
||
} else {
|
||
u += a * 1.5 * k;
|
||
v += bb * 1.5 * k;
|
||
}
|
||
}
|
||
let n = shape(self.kind, self.layer(u, v, of, z, seed));
|
||
if self.kind == 7 {
|
||
best = best.max(n * amp);
|
||
}
|
||
sum += n * amp * w;
|
||
norm += amp * w;
|
||
amp *= self.influence;
|
||
(f, depth) = next_octave(f, depth, self.sub_scaling);
|
||
}
|
||
if self.kind == 7 { best } else { sum / norm.max(1e-6) }
|
||
}
|
||
|
||
/// Final grey value: contrast, brightness, overflow and invert applied.
|
||
pub(crate) fn value(&self, x: f32, y: f32) -> f32 {
|
||
let v = (self.raw(x, y) - 0.5) * self.contrast + 0.5 + self.brightness;
|
||
let v = overflow(v, self.overflow);
|
||
if self.invert { 1.0 - v } else { v }
|
||
}
|
||
}
|
||
|
||
/// 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
|
||
/// pixel, in the same f32 order.
|
||
pub struct FractalGpu {
|
||
pub kind: u32,
|
||
pub noise_type: u32,
|
||
pub seed: u32,
|
||
pub invert: bool,
|
||
pub overflow: u32,
|
||
pub contrast: f32,
|
||
pub brightness: f32,
|
||
/// Rotation (sin, cos).
|
||
pub rot: (f32, f32),
|
||
pub size: [f32; 2],
|
||
/// Cycle Evolution: (t, cycle, t / cycle).
|
||
pub cycle: Option<[f32; 3]>,
|
||
pub sub_rotation: bool,
|
||
/// Σ amplitude × weight (the normaliser).
|
||
pub norm: f32,
|
||
/// Per octave: origin x, y, sub-rotation sin, cos, frequency, amplitude, weight, evolution
|
||
/// (turbulence applied), z offset, Dynamic Progressive warp factor.
|
||
pub octaves: Vec<[f32; 10]>,
|
||
/// Blending Mode (`None` = the noise alone), Opacity and Blend With Original.
|
||
pub mode: Option<BlendMode>,
|
||
pub opacity: f32,
|
||
pub blend: f32,
|
||
}
|
||
|
||
/// [`FractalGpu`] for a buffer with `offset` / `scale`.
|
||
pub fn fractal_gpu(ctx: &EffectCtx, offset: [f64; 2], scale: f64, turbulent: bool) -> FractalGpu {
|
||
let b = Buf { img: effectcraft_raster::Image::new(0, 0), offset, scale };
|
||
let fr = Fractal::from_params(ctx, &b, turbulent);
|
||
let n_oct = fr.octaves.ceil() as usize;
|
||
let frac = fr.octaves - fr.octaves.floor();
|
||
let (mut norm, mut amp, mut f, mut depth) = (0.0f32, 1.0f32, 1.0f32, 1.0f32);
|
||
let mut octaves = Vec::with_capacity(n_oct);
|
||
for o in 0..n_oct {
|
||
let w = if o + 1 == n_oct && frac > 0.0 { frac } else { 1.0 };
|
||
let of = o as f32;
|
||
let org = fr.octave_origin(of, depth);
|
||
let (s, c) = (fr.sub_rotation * of).sin_cos();
|
||
let evo = fr.evolution * (1.0 + fr.turbulence * of);
|
||
let dk = if fr.kind == 6 { 0.5 + of * 0.35 } else { 1.0 };
|
||
octaves.push([org[0], org[1], s, c, f, amp, w, evo, of * 7.31, dk]);
|
||
norm += amp * w;
|
||
amp *= fr.influence;
|
||
(f, depth) = next_octave(f, depth, fr.sub_scaling);
|
||
}
|
||
let cycle = fr.cycle.map(|c| {
|
||
let t = fr.evolution.rem_euclid(c);
|
||
[t, c, t / c]
|
||
});
|
||
FractalGpu {
|
||
kind: fr.kind,
|
||
noise_type: fr.noise_type,
|
||
seed: fr.seed,
|
||
invert: fr.invert,
|
||
overflow: fr.overflow,
|
||
contrast: fr.contrast,
|
||
brightness: fr.brightness,
|
||
rot: fr.rot,
|
||
size: fr.size,
|
||
cycle,
|
||
sub_rotation: fr.sub_rotation != 0.0,
|
||
norm,
|
||
octaves,
|
||
mode: blend_mode(ctx.params.get("blendingMode").map(Value::as_enum).unwrap_or(BLEND_NONE)),
|
||
opacity: (ctx.params.f("opacity") as f32 / 100.0).clamp(0.0, 1.0),
|
||
blend: ctx.params.f("blend") as f32 / 100.0,
|
||
}
|
||
}
|
||
|
||
/// Resolve a Blending Mode index: None → `None`, unknown → Normal.
|
||
fn blend_mode(m: u32) -> Option<BlendMode> {
|
||
match m {
|
||
BLEND_NONE => None,
|
||
m => Some(BLEND_MODES.get(m as usize).and_then(|l| BlendMode::from_name(l)).unwrap_or(BlendMode::Normal)),
|
||
}
|
||
}
|
||
|
||
/// Map a value by an [`OVERFLOWS`] option.
|
||
pub fn overflow(v: f32, mode: u32) -> f32 {
|
||
match mode {
|
||
1 => (0.5 + 0.5 * (2.0 * (v - 0.5)).tanh() / 1f32.tanh()).clamp(0.0, 1.0),
|
||
2 => {
|
||
let t = v.rem_euclid(2.0);
|
||
if t > 1.0 { 2.0 - t } else { t }
|
||
}
|
||
3 => v,
|
||
_ => v.clamp(0.0, 1.0),
|
||
}
|
||
}
|
||
|
||
/// Composite grey noise `val` over the original pixel by Blending Mode, Opacity and (ours) Blend
|
||
/// With Original. The noise stays inside the layer's alpha, so a masked solid shows it only within
|
||
/// its masks (#939).
|
||
pub(crate) fn composite(orig: [f32; 4], val: f32, opacity: f32, mode: Option<BlendMode>, blend_orig: f32) -> [f32; 4] {
|
||
let src = [val * opacity, val * opacity, val * opacity, opacity];
|
||
let out = match mode {
|
||
None => src,
|
||
Some(bm) => blend_pixel(bm, orig, src, 0.5),
|
||
};
|
||
let k = 1.0 - blend_orig;
|
||
[0, 1, 2, 3].map(|c| orig[c] * blend_orig + out[c] * orig[3] * k)
|
||
}
|
||
|
||
fn render(ctx: &EffectCtx, mut b: Buf, turbulent: bool) -> Buf {
|
||
let fr = Fractal::from_params(ctx, &b, turbulent);
|
||
let opacity = (ctx.params.f("opacity") as f32 / 100.0).clamp(0.0, 1.0);
|
||
let mode = blend_mode(ctx.params.get("blendingMode").map(Value::as_enum).unwrap_or(BLEND_NONE));
|
||
let blend = ctx.params.f("blend") as f32 / 100.0;
|
||
b.img.rows_mut().for_each(|(y, row)| {
|
||
for (x, px) in row.iter_mut().enumerate() {
|
||
let v = fr.value(x as f32 + 0.5, y as f32 + 0.5);
|
||
*px = composite(*px, v, opacity, mode, blend);
|
||
}
|
||
});
|
||
b
|
||
}
|
||
|
||
fn fractal_noise(ctx: &EffectCtx, b: Buf) -> Buf {
|
||
render(ctx, b, false)
|
||
}
|
||
|
||
fn turbulent_noise(ctx: &EffectCtx, b: Buf) -> Buf {
|
||
render(ctx, b, true)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use crate::{EffectEnv, run_fx};
|
||
use effectcraft_raster::Image;
|
||
|
||
fn run(id: &str, vals: &[(&str, Value)]) -> Image {
|
||
run_fx(id, vals, Image::filled(40, 24, [0.2, 0.4, 0.6, 1.0]), 0.0, EffectEnv::default()).img
|
||
}
|
||
|
||
/// #3486: lattice coordinates past the i32 range (an octave's frequency at Sub Scaling 10 % and
|
||
/// high Complexity) saturate, and their neighbours wrap instead of overflowing.
|
||
#[test]
|
||
fn noise_past_the_i32_range_is_finite() {
|
||
for noise_type in [0, 1, 2, 3] {
|
||
for (x, y) in [(1e30, -1e30), (f32::MAX, f32::MIN), (3e9, 2.5e9)] {
|
||
let n = typed_noise(x, y, 1e12, 7, noise_type);
|
||
assert!(n.is_finite(), "type {noise_type} at ({x}, {y}): {n}");
|
||
}
|
||
}
|
||
}
|
||
|
||
/// #3486: octave frequency and depth stay each other's inverse and finite at 20 octaves of
|
||
/// either end of Sub Scaling, and are unchanged inside the old 10..100 range.
|
||
#[test]
|
||
fn octave_scales_stay_finite_and_inverse() {
|
||
for s in [0.1f32, 0.56, 1.0, 2.0, 100.0] {
|
||
let (mut f, mut depth, (mut f0, mut d0)) = (1.0f32, 1.0f32, (1.0f32, 1.0f32));
|
||
for _ in 0..19 {
|
||
(f, depth) = next_octave(f, depth, s);
|
||
(f0, d0) = (f0 / s, d0 * s);
|
||
let lo = 1.0 / OCTAVE_SCALE_MAX;
|
||
assert!((lo..=OCTAVE_SCALE_MAX).contains(&f) && (lo..=OCTAVE_SCALE_MAX).contains(&depth), "{s}: {f} {depth}");
|
||
assert!((f * depth - 1.0).abs() < 1e-3, "{s}: {f} × {depth}");
|
||
if s <= 1.0 {
|
||
assert_eq!((f, depth), (f0, d0), "{s}");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Evolution moves the noise at a constant rate: no ease in or out within a revolution.
|
||
#[test]
|
||
fn evolution_is_linear() {
|
||
for noise_type in [0, 1, 2, 3] {
|
||
let a = typed_noise(0.3, 0.7, 0.0, 5, noise_type);
|
||
let b = typed_noise(0.3, 0.7, 1.0, 5, noise_type);
|
||
for z in [0.25, 0.5, 0.75] {
|
||
let want = a + (b - a) * z;
|
||
let got = typed_noise(0.3, 0.7, z, 5, noise_type);
|
||
assert!((got - want).abs() < 1e-4, "type {noise_type} z {z}: {got} vs {want}");
|
||
}
|
||
}
|
||
}
|
||
|
||
/// A Fractal Noise saved before the twirl-downs existed: flat ids move into their groups and
|
||
/// the new controls take values that keep the old look.
|
||
#[test]
|
||
fn old_fractal_noise_instances_upgrade() {
|
||
use effectcraft_project::build::Ids;
|
||
use effectcraft_project::{GroupKind, Property};
|
||
let spec = crate::find("ec.noise.fractal").unwrap();
|
||
let mut next = 1;
|
||
let mut ids = Ids(&mut next);
|
||
let mut g = ids.group(spec.id, "Fractal Noise");
|
||
g.kind = GroupKind::Effect { effect: spec.id.into() };
|
||
for (m, v) in [
|
||
("fractalType", Value::Enum(1)),
|
||
("invert", Value::Bool(false)),
|
||
("contrast", num(150.0)),
|
||
("brightness", num(0.0)),
|
||
("scale", num(40.0)),
|
||
("offset", Value::Vec2([5.0, 6.0])),
|
||
("rotation", num(30.0)),
|
||
("complexity", num(3.0)),
|
||
("evolution", num(0.0)),
|
||
("seed", num(9.0)),
|
||
("opacity", num(100.0)),
|
||
("blend", num(0.0)),
|
||
] {
|
||
let id = ids.alloc();
|
||
g.children.push(Property::new(id, m, m, v).into());
|
||
}
|
||
assert!(crate::migrate::upgrade_instance(spec, &mut g, &mut ids, [40.0, 24.0]));
|
||
assert_eq!(g.prop("transform/scale").unwrap().value, num(40.0));
|
||
assert_eq!(g.prop("transform/offset").unwrap().value, Value::Vec2([5.0, 6.0]));
|
||
assert_eq!(g.prop("evolutionOptions/seed").unwrap().value, num(9.0));
|
||
assert!(g.get("scale").is_none() && g.get("seed").is_none());
|
||
// Clip, half-weight half-size octaves and the noise drawn alone, as before.
|
||
assert_eq!(g.get("overflow").unwrap().value, Value::Enum(0));
|
||
assert_eq!(g.prop("subSettings/subInfluence").unwrap().value, num(50.0));
|
||
assert_eq!(g.prop("subSettings/subScaling").unwrap().value, num(50.0));
|
||
assert_eq!(g.get("blendingMode").unwrap().value, Value::Enum(BLEND_NONE));
|
||
assert_eq!(g.sub("transform").unwrap().name, "Transform");
|
||
}
|
||
|
||
#[test]
|
||
fn noise_types_differ_and_block_is_piecewise_constant() {
|
||
let a = run("ec.noise.fractal", &[("noiseType", Value::Enum(0)), ("complexity", num(1.0)), ("transform/scale", num(15.0))]);
|
||
// Block noise: neighbours inside one 10 px cell (Scale 15) share a value.
|
||
assert_eq!(a.get(4, 4), a.get(5, 5));
|
||
let others: Vec<Image> = (1..4).map(|t| run("ec.noise.fractal", &[("noiseType", Value::Enum(t)), ("transform/scale", num(10.0))])).collect();
|
||
assert_ne!(others[0], others[1]);
|
||
assert_ne!(others[1], others[2]);
|
||
}
|
||
|
||
/// After Effects 2026 (R9): Block noise at Scale 100, Complexity 1 changes value every
|
||
/// 66.67 px along a row.
|
||
#[test]
|
||
fn block_noise_cells_are_two_thirds_of_scale_as_in_after_effects() {
|
||
let img = run_fx(
|
||
"ec.noise.fractal",
|
||
&[("noiseType", Value::Enum(0)), ("complexity", num(1.0)), ("blendingMode", Value::Enum(BLEND_NONE))],
|
||
Image::filled(400, 8, [0.0, 0.0, 0.0, 1.0]),
|
||
0.0,
|
||
EffectEnv::default(),
|
||
)
|
||
.img;
|
||
let changes: Vec<i64> = (1..400).filter(|&x| img.get(x, 4) != img.get(x - 1, 4)).collect();
|
||
assert!(changes.len() >= 4, "{changes:?}");
|
||
for w in changes.windows(2) {
|
||
let d = (w[1] - w[0]) as f64;
|
||
assert!((d - 200.0 / 3.0).abs() <= 1.0, "cell width {d}: {changes:?}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn scale_width_height_apply_without_uniform_scaling() {
|
||
let base = &[("complexity", num(1.0)), ("transform/scale", num(8.0))];
|
||
let uni = run("ec.noise.fractal", &[base[0].clone(), base[1].clone(), ("transform/scaleWidth", num(50.0))]);
|
||
let plain = run("ec.noise.fractal", base);
|
||
assert_eq!(uni, plain, "Scale Width is ignored while Uniform Scaling is on");
|
||
let wide = run(
|
||
"ec.noise.fractal",
|
||
&[base[0].clone(), ("transform/uniformScaling", Value::Bool(false)), ("transform/scaleWidth", num(400.0)), ("transform/scaleHeight", num(8.0))],
|
||
);
|
||
// Stretched horizontally: horizontal neighbours are more alike than vertical ones.
|
||
let (mut dh, mut dv) = (0.0, 0.0);
|
||
for y in 0..23 {
|
||
for x in 0..39 {
|
||
dh += (wide.get(x + 1, y)[0] - wide.get(x, y)[0]).abs();
|
||
dv += (wide.get(x, y + 1)[0] - wide.get(x, y)[0]).abs();
|
||
}
|
||
}
|
||
assert!(dh < dv * 0.5, "{dh} {dv}");
|
||
}
|
||
|
||
#[test]
|
||
fn overflow_hdr_keeps_out_of_range_values() {
|
||
let hi = run("ec.noise.fractal", &[("contrast", num(400.0)), ("blendingMode", Value::Enum(BLEND_NONE))]);
|
||
assert!(hi.data.iter().any(|p| p[0] > 1.0 || p[0] < 0.0));
|
||
let clip = run("ec.noise.fractal", &[("contrast", num(400.0)), ("overflow", Value::Enum(0)), ("blendingMode", Value::Enum(BLEND_NONE))]);
|
||
assert!(clip.data.iter().all(|p| (0.0..=1.0).contains(&p[0])));
|
||
}
|
||
|
||
#[test]
|
||
fn cycle_evolution_loops() {
|
||
let at = |evo: f64| {
|
||
run("ec.noise.fractal", &[("evolution", num(evo)), ("evolutionOptions/cycleEvolution", Value::Bool(true)), ("evolutionOptions/cycle", num(2.0))])
|
||
};
|
||
assert_eq!(at(0.0), at(720.0));
|
||
assert_ne!(at(0.0), at(360.0));
|
||
}
|
||
|
||
#[test]
|
||
fn blending_modes_composite_over_the_layer() {
|
||
let none = run("ec.noise.fractal", &[("blendingMode", Value::Enum(BLEND_NONE))]);
|
||
let mul = run("ec.noise.fractal", &[("blendingMode", Value::Enum(3))]);
|
||
// Multiply keeps the layer's colour cast (blue > red), None is grey.
|
||
assert!(none.data.iter().all(|p| (p[0] - p[2]).abs() < 1e-6));
|
||
assert!(mul.data.iter().all(|p| p[2] >= p[0]));
|
||
assert!(mul.data.iter().any(|p| p[2] > p[0] + 0.01));
|
||
}
|
||
|
||
#[test]
|
||
fn noise_stays_inside_the_layer_alpha() {
|
||
// #939: a masked solid (transparent outside the mask, a soft edge) filled the whole layer.
|
||
let mut img = Image::filled(40, 24, [0.2, 0.4, 0.6, 1.0]);
|
||
for (i, p) in img.data.iter_mut().enumerate() {
|
||
let a = match i % 40 {
|
||
0..10 => 0.0,
|
||
10..20 => 0.5,
|
||
_ => 1.0,
|
||
};
|
||
*p = p.map(|c| c * a);
|
||
}
|
||
for mode in [BLEND_NONE, BLEND_NORMAL, 3] {
|
||
let out = run_fx("ec.noise.fractal", &[("blendingMode", Value::Enum(mode))], img.clone(), 0.0, EffectEnv::default()).img;
|
||
for (o, p) in img.data.iter().zip(&out.data) {
|
||
assert!((o[3] - p[3]).abs() < 1e-6, "mode {mode}: alpha {} became {}", o[3], p[3]);
|
||
assert!(p[..3].iter().all(|&c| c <= p[3] + 1e-6), "mode {mode}: premultiplied colour above alpha");
|
||
}
|
||
assert!(out.data.iter().any(|p| p[3] == 1.0 && (p[0] - 0.2).abs() > 0.01), "mode {mode}: noise drawn inside the mask");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn sub_settings_and_fractal_types_change_the_result() {
|
||
let base = run("ec.noise.fractal", &[]);
|
||
for (k, v) in [
|
||
("subSettings/subInfluence", num(20.0)),
|
||
("subSettings/subScaling", num(80.0)),
|
||
("subSettings/subRotation", num(45.0)),
|
||
("subSettings/subOffset", Value::Vec2([7.0, 3.0])),
|
||
] {
|
||
assert_ne!(run("ec.noise.fractal", &[(k, v)]), base, "{k}");
|
||
}
|
||
for t in 1..FRACTAL_TYPES.len() as u32 {
|
||
assert_ne!(run("ec.noise.fractal", &[("fractalType", Value::Enum(t))]), base, "type {t}");
|
||
}
|
||
// Turbulence factor only matters while evolving.
|
||
let t0 = run("ec.noise.turbulent", &[("evolution", num(200.0)), ("evolutionOptions/turbulenceFactor", num(0.0))]);
|
||
let t1 = run("ec.noise.turbulent", &[("evolution", num(200.0)), ("evolutionOptions/turbulenceFactor", num(2.0))]);
|
||
assert_ne!(t0, t1);
|
||
}
|
||
|
||
/// #3486: Sub Scaling takes After Effects' 10..10000 for both effects (the slider still shows
|
||
/// 25..100), and the renderer uses values above 100 instead of capping them there.
|
||
#[test]
|
||
fn sub_scaling_takes_the_after_effects_range() {
|
||
for id in ["ec.noise.fractal", "ec.noise.turbulent"] {
|
||
let ui = &crate::find(id).unwrap().params.iter().find(|p| p.id == "subSettings/subScaling").unwrap().ui;
|
||
assert!(
|
||
matches!(ui, ParamUi::Slider { min, max, slider_min, slider_max, .. }
|
||
if *min == 10.0 && *max == 10000.0 && *slider_min == 25.0 && *slider_max == 100.0),
|
||
"{id}: {ui:?}"
|
||
);
|
||
let at = |v: f64| run(id, &[("subSettings/subScaling", num(v))]);
|
||
assert_ne!(at(100.0), at(200.0), "{id}: 200 renders as 100");
|
||
assert_ne!(at(200.0), at(10000.0), "{id}: 10000 renders as 200");
|
||
}
|
||
}
|
||
|
||
/// #3486: above 100 %, each octave is larger than the last, so its scale grows as Sub
|
||
/// Scaling^octave (100^19 at Complexity 20). Perspective Offset and Turbulence Factor multiply
|
||
/// the offset by that, which overflowed to infinity and drew NaN, also for a huge offset. At
|
||
/// 10 % the lattice coordinates pass the i32 range, whose neighbour index overflowed.
|
||
#[test]
|
||
fn extreme_sub_scaling_stays_finite() {
|
||
for id in ["ec.noise.fractal", "ec.noise.turbulent"] {
|
||
for sub in [10.0, 100.0, 9999.0, 10000.0] {
|
||
for (perspective, offset) in [(false, [-3000.0, 2500.0]), (true, [-3000.0, 2500.0]), (true, [1e17, -1e17])] {
|
||
let mut vals = vec![
|
||
("subSettings/subScaling", num(sub)),
|
||
("complexity", num(20.0)),
|
||
("transform/perspectiveOffset", Value::Bool(perspective)),
|
||
("transform/offset", Value::Vec2(offset)),
|
||
("evolution", num(200.0)),
|
||
("blendingMode", Value::Enum(BLEND_NONE)),
|
||
];
|
||
if id == "ec.noise.turbulent" {
|
||
vals.push(("evolutionOptions/turbulenceFactor", num(10.0)));
|
||
}
|
||
let img = run(id, &vals);
|
||
assert!(img.data.iter().flatten().all(|c| c.is_finite()), "{id} sub {sub} perspective {perspective} offset {offset:?}: non-finite output");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Turbulent Basic Fractal Noise drawn alone at `w` × `h`.
|
||
fn turbulent_basic(w: u32, h: u32, vals: &[(&str, Value)]) -> Image {
|
||
let mut all = vec![("fractalType", Value::Enum(2)), ("blendingMode", Value::Enum(BLEND_NONE))];
|
||
all.extend_from_slice(vals);
|
||
run_fx("ec.noise.fractal", &all, Image::filled(w, h, [0.0, 0.0, 0.0, 1.0]), 0.0, EffectEnv::default()).img
|
||
}
|
||
|
||
/// (x, y, ∂/∂x, ∂/∂y) of the grey value at every inner pixel (central differences).
|
||
fn gradients(img: &Image) -> Vec<(i64, i64, f64, f64)> {
|
||
let v = |x: i64, y: i64| img.get(x, y)[0] as f64;
|
||
let (w, h) = (img.width as i64, img.height as i64);
|
||
(1..h - 1).flat_map(|y| (1..w - 1).map(move |x| (x, y, (v(x + 1, y) - v(x - 1, y)) / 2.0, (v(x, y + 1) - v(x, y - 1)) / 2.0))).collect()
|
||
}
|
||
|
||
/// #259: Soft Linear faded between two lattice values with zero slope across every lattice
|
||
/// line, which Turbulent Basic and high contrast showed as a square grid.
|
||
#[test]
|
||
fn soft_linear_has_no_lattice_creases() {
|
||
// One 16 px layer whose lattice lines run through the pixel centres x, y = 16k: the slope
|
||
// across them is about the average slope (with the fade it was 2% of it).
|
||
let one = turbulent_basic(160, 96, &[("complexity", num(1.0)), ("transform/scale", num(16.0)), ("transform/offset", Value::Vec2([0.5, 0.5]))]);
|
||
let (mut on, mut n_on, mut all, mut n_all) = (0.0, 0.0, 0.0, 0.0);
|
||
for (x, y, gx, gy) in gradients(&one) {
|
||
for (k, g) in [(x, gx), (y, gy)] {
|
||
all += g.abs();
|
||
n_all += 1.0;
|
||
if k % 16 == 0 {
|
||
on += g.abs();
|
||
n_on += 1.0;
|
||
}
|
||
}
|
||
}
|
||
let across = (on / n_on) / (all / n_all);
|
||
assert!(across > 0.5, "slope across lattice lines / average slope: {across}");
|
||
// The issue's settings at a quarter size: gradients run along the lattice axes about as
|
||
// strongly as along the diagonals (with the fade, 1.2× as strongly).
|
||
let img = turbulent_basic(480, 270, &[("contrast", num(140.0)), ("brightness", num(-35.0)), ("transform/scale", num(105.0))]);
|
||
let (mut axis, mut diag) = (0.0, 0.0);
|
||
for (_, _, gx, gy) in gradients(&img) {
|
||
let a = gy.atan2(gx).to_degrees().rem_euclid(90.0);
|
||
if !(15.0..=75.0).contains(&a) {
|
||
axis += gx.hypot(gy);
|
||
} else if (30.0..=60.0).contains(&a) {
|
||
diag += gx.hypot(gy);
|
||
}
|
||
}
|
||
assert!(axis / diag < 1.15, "gradient along the axes / along the diagonals: {}", axis / diag);
|
||
}
|
||
|
||
/// The base composite, resolving the Blending Mode by name on every call, kept only to prove
|
||
/// the hoisted lookup changes nothing.
|
||
fn old_composite(orig: [f32; 4], val: f32, opacity: f32, mode: u32, blend_orig: f32) -> [f32; 4] {
|
||
let src = [val * opacity, val * opacity, val * opacity, opacity];
|
||
let out = match mode {
|
||
BLEND_NONE => src,
|
||
m => {
|
||
let bm = BLEND_MODES.get(m as usize).and_then(|l| BlendMode::from_name(l)).unwrap_or(BlendMode::Normal);
|
||
blend_pixel(bm, orig, src, 0.5)
|
||
}
|
||
};
|
||
let k = 1.0 - blend_orig;
|
||
[0, 1, 2, 3].map(|c| orig[c] * blend_orig + out[c] * orig[3] * k)
|
||
}
|
||
|
||
#[test]
|
||
fn resolved_blend_matches_per_pixel_lookup() {
|
||
for m in (0..BLEND_MODES.len() as u32).chain([24, 999]) {
|
||
for orig in [[0.2, 0.4, 0.6, 1.0], [0.9, 0.1, 0.5, 0.5], [0.0, 0.0, 0.0, 0.0]] {
|
||
for val in [0.0, 0.3, 0.75, 1.0] {
|
||
for (op, bl) in [(1.0, 0.0), (0.6, 0.25)] {
|
||
assert_eq!(composite(orig, val, op, blend_mode(m), bl), old_composite(orig, val, op, m, bl), "mode {m}");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
assert_eq!(blend_mode(BLEND_NONE), None);
|
||
assert_eq!(blend_mode(999), Some(BlendMode::Normal));
|
||
}
|
||
}
|