From 42266291d5ea40092e47c5f4e3ba1405fa4a92d8 Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Fri, 2 Oct 2026 01:26:34 -0400 Subject: [PATCH] Fidelity, GPU fallbacks, interactive performance; print spool-file fix PSD oracle 111 -> 113 (tent effect blurs, bevel height/shading, glow range, spread rounding, text gamma, gradient span, Lab blending, colour burn/dodge edges), channel restrictions (brst), bevel contour/texture, chisel techniques. Vector masks, pass-through clips, artboards, pattern fills and bevel textures render on the GPU (parity <=1/255). PNG export 7x, PSD save 4x, .pcraft save 3.6x faster; CPU effects refresh 11x; deadlock in the effect-map blur fixed. interactive_bench example. Print: unique spool file per call (concurrent prints of same-named documents overwrote each other). Workspace: 2,040 tests pass, clippy clean, layers + wasm OK, parity 600/625. Co-Authored-By: Claude Opus 5.5 --- crates/algo/src/blur.rs | 62 +++++- crates/codecs/src/codecs/png.rs | 197 ++++++++++++++++++ crates/codecs/src/image.rs | 32 ++- crates/compose/src/bounds.rs | 71 +++++++ crates/compose/src/effects.rs | 202 +++++++++++++++---- crates/compose/src/lib.rs | 86 ++++++-- crates/compose/src/pattern.rs | 5 + crates/compose/src/psblend.rs | 31 +++ crates/compose/src/tests.rs | 30 ++- crates/engine/src/color_cmds.rs | 30 ++- crates/engine/src/commands.rs | 6 +- crates/engine/src/inspect.rs | 4 + crates/engine/src/layer_style.rs | 26 ++- crates/engine/src/prefs.rs | 1 + crates/engine/src/print_cmds.rs | 5 +- crates/engine/src/tests.rs | 13 ++ crates/format/src/manifest.rs | 8 +- crates/format/src/store.rs | 30 ++- crates/gpu/src/bounds.rs | 99 +-------- crates/gpu/src/compose.wgsl | 70 ++++++- crates/gpu/src/fx.rs | 47 ++++- crates/gpu/src/lib.rs | 14 +- crates/gpu/src/plan.rs | 34 +++- crates/gpu/tests/parity.rs | 50 ++++- crates/io/examples/oracle_diff.rs | 7 +- crates/io/src/blocks.rs | 11 +- crates/io/src/flat.rs | 40 +++- crates/io/src/pixels.rs | 28 +++ crates/io/src/psd_export.rs | 35 ++-- crates/ui-egui/examples/interactive_bench.rs | 6 + docs/development.md | 2 +- docs/roadmap.md | 11 +- 32 files changed, 1071 insertions(+), 222 deletions(-) create mode 100644 crates/compose/src/bounds.rs diff --git a/crates/algo/src/blur.rs b/crates/algo/src/blur.rs index 06fca14825..b53ce40223 100644 --- a/crates/algo/src/blur.rs +++ b/crates/algo/src/blur.rs @@ -98,13 +98,41 @@ fn box_rows(buf: &mut [f32], w: usize, n: usize, r: usize) { } let norm = 1.0 / (2 * r + 1) as f32; let blur_row = |row: &mut [f32]| { - let src = row.to_vec(); - let at = |x: isize, c: usize| src[(x.clamp(0, w as isize - 1) as usize) * n + c]; - for c in 0..n { - let mut acc: f32 = (-(r as isize)..=r as isize).map(|x| at(x, c)).sum(); - for x in 0..w { - row[x * n + c] = acc * norm; - acc += at(x as isize + r as isize + 1, c) - at(x as isize - r as isize, c); + // The row with clamped edges materialised (r + 1 pixels each side), so the running sum + // reads without bounds clamping, all channels per step. + let pad = r + 1; + let mut src = Vec::with_capacity((w + 2 * pad) * n); + for _ in 0..pad { + src.extend_from_slice(&row[..n]); + } + src.extend_from_slice(row); + for _ in 0..pad { + src.extend_from_slice(&row[(w - 1) * n..w * n]); + } + let mut acc = [0.0f32; 8]; + let acc = &mut acc[..n.min(8)]; + if n > 8 { + // Unusual channel counts: per channel. + for c in 0..n { + let mut a: f32 = (0..=2 * r).map(|i| src[(pad - r + i) * n + c]).sum(); + for x in 0..w { + row[x * n + c] = a * norm; + a += src[(x + pad + r + 1) * n + c] - src[(x + pad - r) * n + c]; + } + } + return; + } + for i in 0..=2 * r { + let o = (pad - r + i) * n; + for c in 0..n { + acc[c] += src[o + c]; + } + } + for x in 0..w { + let (add, sub) = ((x + pad + r + 1) * n, (x + pad - r) * n); + for c in 0..n { + row[x * n + c] = acc[c] * norm; + acc[c] += src[add + c] - src[sub + c]; } } }; @@ -119,17 +147,29 @@ fn box_rows(buf: &mut [f32], w: usize, n: usize, r: usize) { fn transpose(buf: &[f32], w: usize, h: usize, n: usize) -> Vec { let mut out = vec![0.0f32; buf.len()]; + if w == 0 || h == 0 { + return out; + } const B: usize = 32; // cache-friendly blocks - for by in (0..h).step_by(B) { - for bx in (0..w).step_by(B) { + // Bands of B output rows (= input columns) are independent: transpose them in parallel. + let band = |(i, chunk): (usize, &mut [f32])| { + let bx = i * B; + for by in (0..h).step_by(B) { for y in by..(by + B).min(h) { for x in bx..(bx + B).min(w) { - let (s, d) = ((y * w + x) * n, (x * h + y) * n); - out[d..d + n].copy_from_slice(&buf[s..s + n]); + let (s, d) = ((y * w + x) * n, ((x - bx) * h + y) * n); + chunk[d..d + n].copy_from_slice(&buf[s..s + n]); } } } + }; + #[cfg(not(target_arch = "wasm32"))] + { + use rayon::prelude::*; + out.par_chunks_mut(B * h * n).enumerate().for_each(band); } + #[cfg(target_arch = "wasm32")] + out.chunks_mut(B * h * n).enumerate().for_each(band); out } diff --git a/crates/codecs/src/codecs/png.rs b/crates/codecs/src/codecs/png.rs index 0f8cd1e344..310dd03914 100644 --- a/crates/codecs/src/codecs/png.rs +++ b/crates/codecs/src/codecs/png.rs @@ -200,6 +200,10 @@ pub(crate) fn encode(src: &Image, plan: Plan, opts: &EncodeOptions) -> Result Option> { + if cfg!(target_arch = "wasm32") || data.len() < PARALLEL_MIN_BYTES || level == PngCompression::None || w == 0 || h == 0 { + return None; + } + let threads = std::thread::available_parallelism().map_or(1, |n| n.get()).clamp(1, 32); + if threads < 2 { + return None; + } + let stride = w * bpp; + let band_rows = h.div_ceil(threads * 4).max(1); + let bands: Vec<(usize, usize)> = (0..h).step_by(band_rows).map(|y| (y, (y + band_rows).min(h))).collect(); + let lvl = match level { + PngCompression::Fast => flate2::Compression::fast(), + PngCompression::Best => flate2::Compression::best(), + _ => flate2::Compression::default(), + }; + let next = std::sync::atomic::AtomicUsize::new(0); + type Band = (usize, Vec, u32, usize); + let mut parts: Vec = std::thread::scope(|sc| { + let workers: Vec<_> = (0..threads.min(bands.len())) + .map(|_| { + sc.spawn(|| { + let mut out: Vec = Vec::new(); + loop { + let i = next.fetch_add(1, std::sync::atomic::Ordering::Relaxed); + let Some(&(y0, y1)) = bands.get(i) else { break }; + let mut filtered = Vec::with_capacity((y1 - y0) * (stride + 1)); + let mut scratch = vec![0u8; stride]; + for y in y0..y1 { + let row = &data[y * stride..(y + 1) * stride]; + let prev = (y > 0).then(|| &data[(y - 1) * stride..y * stride]); + filter_row(row, prev, bpp, &mut scratch, &mut filtered); + } + let adler = adler32(1, &filtered); + let mut c = flate2::Compress::new(lvl, false); + let mut z = Vec::with_capacity(filtered.len() / 2 + 64); + let last = y1 == h; + let flush = if last { flate2::FlushCompress::Finish } else { flate2::FlushCompress::Sync }; + loop { + let consumed = c.total_in() as usize; + if z.capacity() - z.len() < 64 * 1024 { + z.reserve(z.capacity().max(64 * 1024)); + } + match c.compress_vec(&filtered[consumed..], &mut z, flush) { + Ok(flate2::Status::StreamEnd) => break, + Ok(_) if !last && c.total_in() as usize == filtered.len() && z.capacity() > z.len() => break, + Ok(_) => {} + Err(_) => return Vec::new(), + } + } + out.push((i, z, adler, filtered.len())); + } + out + }) + }) + .collect(); + workers.into_iter().flat_map(|w| w.join().unwrap_or_default()).collect() + }); + if parts.len() != bands.len() { + return None; + } + parts.sort_by_key(|p| p.0); + let mut out = Vec::with_capacity(parts.iter().map(|p| p.1.len()).sum::() + 6); + // zlib header: deflate, 32 K window; FLEVEL only advertises the effort. + out.extend_from_slice(match level { + PngCompression::Fast => &[0x78, 0x01], + PngCompression::Best => &[0x78, 0xDA], + _ => &[0x78, 0x9C], + }); + let mut adler = 1u32; + for (_, z, a, len) in &parts { + out.extend_from_slice(z); + adler = adler32_combine(adler, *a, *len); + } + out.extend_from_slice(&adler.to_be_bytes()); + Some(out) +} + +/// One scanline with the adaptive filter choice, appended to `out` (type byte + data). +fn filter_row(row: &[u8], prev: Option<&[u8]>, bpp: usize, scratch: &mut [u8], out: &mut Vec) { + let n = row.len(); + let up = |i: usize| prev.map_or(0, |p| p[i]); + let left = |i: usize| if i >= bpp { row[i - bpp] } else { 0 }; + let ul = |i: usize| if i >= bpp { prev.map_or(0, |p| p[i - bpp]) } else { 0 }; + let paeth = |a: u8, b: u8, c: u8| { + let p = i16::from(a) + i16::from(b) - i16::from(c); + let (pa, pb, pc) = ((p - i16::from(a)).abs(), (p - i16::from(b)).abs(), (p - i16::from(c)).abs()); + if pa <= pb && pa <= pc { a } else if pb <= pc { b } else { c } + }; + let cost = |v: &[u8]| v.iter().map(|&b| u64::from((b as i8).unsigned_abs())).sum::(); + let mut best = (cost(row), 0u8); + for kind in 1u8..=4 { + for i in 0..n { + let x = row[i]; + scratch[i] = match kind { + 1 => x.wrapping_sub(left(i)), + 2 => x.wrapping_sub(up(i)), + 3 => x.wrapping_sub(((u16::from(left(i)) + u16::from(up(i))) / 2) as u8), + _ => x.wrapping_sub(paeth(left(i), up(i), ul(i))), + }; + } + let c = cost(&scratch[..n]); + if c < best.0 { + best = (c, kind); + } + } + out.push(best.1); + if best.1 == 0 { + out.extend_from_slice(row); + return; + } + for i in 0..n { + let x = row[i]; + scratch[i] = match best.1 { + 1 => x.wrapping_sub(left(i)), + 2 => x.wrapping_sub(up(i)), + 3 => x.wrapping_sub(((u16::from(left(i)) + u16::from(up(i))) / 2) as u8), + _ => x.wrapping_sub(paeth(left(i), up(i), ul(i))), + }; + } + out.extend_from_slice(&scratch[..n]); +} + +const ADLER_MOD: u32 = 65_521; + +fn adler32(start: u32, data: &[u8]) -> u32 { + let (mut a, mut b) = (start & 0xffff, start >> 16); + for chunk in data.chunks(5552) { + for &x in chunk { + a += u32::from(x); + b += a; + } + a %= ADLER_MOD; + b %= ADLER_MOD; + } + (b << 16) | a +} + +/// Adler-32 of A ‖ B from adler(A), adler(B) and |B| (zlib's `adler32_combine`). +fn adler32_combine(a1: u32, a2: u32, len2: usize) -> u32 { + let rem = (len2 % ADLER_MOD as usize) as u64; + let m = u64::from(ADLER_MOD); + let (s1a, s2a) = (u64::from(a1 & 0xffff), u64::from(a1 >> 16)); + let (s1b, s2b) = (u64::from(a2 & 0xffff), u64::from(a2 >> 16)); + let s1 = (s1a + s1b + m - 1) % m; + let s2 = (s2a + s2b + (rem * s1a) % m + m - rem) % m; + ((s2 as u32) << 16) | s1 as u32 +} + /// Writes an 8-bit palette PNG (PNG-8): `indices` row-major, `palette` RGB entries (≤ 256), /// optional fully transparent entry (`tRNS`). Used for Indexed Color documents. pub fn encode_indexed(width: u32, height: u32, indices: &[u8], palette: &[[u8; 3]], transparent: Option) -> Result, CodecError> { @@ -302,3 +465,37 @@ mod indexed_tests { assert!(encode_indexed(3, 3, &idx, &pal, None).is_err()); } } + +#[cfg(test)] +mod parallel_tests { + use super::*; + + #[test] + fn adler_combine_matches_one_pass() { + let a: Vec = (0..100_000u32).map(|i| (i * 7 + i / 13) as u8).collect(); + let b: Vec = (0..70_001u32).map(|i| (i * 31) as u8).collect(); + let whole: Vec = a.iter().chain(&b).copied().collect(); + assert_eq!(adler32_combine(adler32(1, &a), adler32(1, &b), b.len()), adler32(1, &whole)); + } + + #[test] + fn large_images_roundtrip_through_the_parallel_encoder() { + for (layout, sample, ch, bytes) in [(ChannelLayout::Rgb, SampleType::U8, 3usize, 1usize), (ChannelLayout::Rgba, SampleType::U16, 4, 2)] { + let (w, h) = (1531u32, 977u32); + let n = w as usize * h as usize * ch * bytes; + let px: Vec = (0..n).map(|i| ((i / 3) as u32).wrapping_mul(2_654_435_761).rotate_left(i as u32 % 7) as u8 / 3 + (i % 97) as u8).collect(); + let img = Image::from_raw(w, h, layout, sample, px.clone()).unwrap(); + assert!(n >= PARALLEL_MIN_BYTES || sample == SampleType::U8); + for level in [PngCompression::Fast, PngCompression::Default] { + let opts = EncodeOptions { png_compression: level, ..Default::default() }; + let bytes = crate::encode(&img, Format::Png, &opts).unwrap(); + let back = decode(&bytes, &Limits::default()).unwrap(); + assert_eq!(back.dimensions(), (w, h)); + assert_eq!(back.convert(layout, sample).data(), img.data(), "{layout:?} {sample:?} {level:?}"); + // The oracle decoder agrees. + let o = image::load_from_memory_with_format(&bytes, image::ImageFormat::Png).unwrap(); + assert_eq!((o.width(), o.height()), (w, h)); + } + } + } +} diff --git a/crates/codecs/src/image.rs b/crates/codecs/src/image.rs index 451d54e823..09a59a9cc9 100644 --- a/crates/codecs/src/image.rs +++ b/crates/codecs/src/image.rs @@ -385,7 +385,23 @@ impl Image { if layout == self.layout && sample == self.sample { return self.clone(); } - let data = if layout == self.layout { + let data = if sample == self.sample && !self.layout.has_alpha() && layout == self.layout.with_alpha() { + // Fast path (opening any opaque file): copy the samples, append an opaque alpha. + let bps = sample.bytes(); + let src = self.layout.channels() * bps; + let one: Vec = match sample { + SampleType::U8 => vec![u8::MAX], + SampleType::U16 => u16::MAX.to_ne_bytes().to_vec(), + SampleType::F16 => f16::ONE.to_bits().to_ne_bytes().to_vec(), + SampleType::F32 => 1.0f32.to_ne_bytes().to_vec(), + }; + let mut out = Vec::with_capacity(self.data.len() / src * (src + bps)); + for px in self.data.chunks_exact(src) { + out.extend_from_slice(px); + out.extend_from_slice(&one); + } + out + } else if layout == self.layout { quantize(&self.to_normalized(), sample) } else { let src = self.to_normalized(); @@ -550,6 +566,20 @@ pub(crate) fn convert_layout(src: &[f32], from: ChannelLayout, to: ChannelLayout #[cfg(test)] mod tests { + #[test] + fn adding_alpha_fast_path_matches_the_general_conversion() { + for sample in SampleType::ALL { + for layout in [ChannelLayout::Gray, ChannelLayout::Rgb, ChannelLayout::Cmyk] { + let n = 7 * 3 * layout.channels(); + let vals: Vec = (0..n).map(|i| (i as f32 * 0.137) % 1.0).collect(); + let img = super::Image::from_normalized(7, 3, layout, sample, &vals).unwrap(); + let fast = img.convert(layout.with_alpha(), sample); + let slow = super::quantize(&super::convert_layout(&img.to_normalized(), layout, layout.with_alpha()), sample); + assert_eq!(fast.data(), &slow[..], "{layout:?} {sample:?}"); + } + } + } + use super::*; #[test] diff --git a/crates/compose/src/bounds.rs b/crates/compose/src/bounds.rs new file mode 100644 index 0000000000..c3beb01fb0 --- /dev/null +++ b/crates/compose/src/bounds.rs @@ -0,0 +1,71 @@ +//! `Surface::content_bounds` with the per-tile scan cached by copy-on-write tile identity, so +//! layer bounds cost a hash lookup per tile instead of a pixel scan per render tile (the CPU +//! compositor asks for an effect layer's bounds in every tile; the GPU planner every frame). + +use std::collections::HashMap; +use std::sync::{Arc, Mutex, Weak}; + +use photocraft_geom::{Rect, TILE_SIZE}; +use photocraft_raster::{Surface, Tile}; + +struct Entry { + tile: Weak, + /// Content bounds inside the tile (tile-local), for one default pixel. + default: Box<[u8]>, + bounds: Option<(u16, u16, u16, u16)>, +} + +fn cache() -> &'static Mutex> { + static C: std::sync::OnceLock>> = std::sync::OnceLock::new(); + C.get_or_init(Default::default) +} + +/// Pixels of `t` that differ from `dp` (tile-local half-open bounds). +fn scan(t: &Tile, dp: &[u8]) -> Option<(u16, u16, u16, u16)> { + let bpp = dp.len(); + let ts = TILE_SIZE as usize; + let (mut x0, mut y0, mut x1, mut y1) = (usize::MAX, usize::MAX, 0usize, 0usize); + for (y, row) in t.bytes().chunks_exact(ts * bpp).enumerate() { + let Some(first) = row.chunks_exact(bpp).position(|px| px != dp) else { continue }; + let last = ts - 1 - row.chunks_exact(bpp).rev().position(|px| px != dp).unwrap_or(0); + x0 = x0.min(first); + x1 = x1.max(last + 1); + y0 = y0.min(y); + y1 = y + 1; + } + (x0 != usize::MAX).then_some((x0 as u16, y0 as u16, x1 as u16, y1 as u16)) +} + +/// `Surface::content_bounds`, cached per tile. +pub fn content_bounds(s: &Surface) -> Rect { + if s.tile_count() == 0 { + return Rect::EMPTY; + } + let fmt = s.format(); + let mut dp = vec![0u8; fmt.bytes_per_pixel()]; + photocraft_raster::encode_pixel(&fmt, &s.default_pixel(), &mut dp); + let mut c = cache().lock().unwrap_or_else(|e| e.into_inner()); + if c.len() > 1 << 16 { + c.retain(|_, e| e.tile.strong_count() > 0); + } + let mut out = Rect::EMPTY; + for (coord, t) in s.tiles() { + let key = Arc::as_ptr(t) as usize; + let hit = c.get(&key).filter(|e| e.tile.upgrade().is_some_and(|u| Arc::ptr_eq(&u, t)) && *e.default == *dp).map(|e| e.bounds); + let b = match hit { + Some(b) => b, + None => { + let b = scan(t, &dp); + c.insert(key, Entry { tile: Arc::downgrade(t), default: dp.clone().into_boxed_slice(), bounds: b }); + b + } + }; + if let Some((x0, y0, x1, y1)) = b { + let o = coord.rect(); + let r = Rect::new(o.x0 + x0 as i32, o.y0 + y0 as i32, o.x0 + x1 as i32, o.y0 + y1 as i32); + out = if out.is_empty() { r } else { out.union(&r) }; + } + } + out +} + diff --git a/crates/compose/src/effects.rs b/crates/compose/src/effects.rs index f7294549d9..9380dfb012 100644 --- a/crates/compose/src/effects.rs +++ b/crates/compose/src/effects.rs @@ -335,7 +335,9 @@ fn dilate(s: &Map, r: f32) -> Map { let d = dist_outside(s); let mut out = s.clone(); for (o, d) in out.v.iter_mut().zip(d) { - *o = o.max((r + 0.5 - d).clamp(0.0, 1.0)); + // Partly covered pixels (distance sentinel < 0) grow by `r` from their own coverage, so a + // 2 % spread doesn't make every anti-aliased edge pixel opaque (ag-psd drop shadow). + *o = if d < 0.0 { (*o + r).min(1.0) } else { o.max((r + 0.5 - d).clamp(0.0, 1.0)) }; } out } @@ -422,9 +424,14 @@ pub fn gradient_t(style: GradientStyle, angle: f32, scale: f32, reverse: bool, o // norm (a unit gradient scaled to the bounds); fitted on psd-tools // gradient-styles.psd (cached Photoshop renderings of every style). let len = ((c * w).powi(2) + (s * h).powi(2)).sqrt().max(1.0) * scale.max(1e-3); + // Linear / Reflected span the chord of the bounds through their centre along the angle: + // min(w / |cos|, h / |sin|). A 45° gradient on a 29 px square runs 41 px (psd-tools + // shape-fx2), an 87° one on a 600 × 60 text line 60 px (layer_effects); axis-aligned angles + // span the width / height. + let chord = (w / c.abs().max(1e-6)).min(h / s.abs().max(1e-6)).max(1.0) * scale.max(1e-3); let mut t = match style { - GradientStyle::Linear => along / len + 0.5, - GradientStyle::Reflected => (along / (len / 2.0)).abs(), + GradientStyle::Linear => along / chord + 0.5, + GradientStyle::Reflected => (along / (chord / 2.0)).abs(), GradientStyle::Radial => (dx * dx + dy * dy).sqrt() / (len / 2.0), GradientStyle::Diamond => (along.abs() + across.abs()) / (len / 2.0), // Clockwise sweep starting at the gradient angle. @@ -480,13 +487,21 @@ fn paint_color(dst: &mut Buffer, m: &Map, c: [f32; 3], blend: BlendMode, opacity paint(dst, m, |_| [c[0], c[1], c[2], 1.0], blend, opacity); } +/// Spread / choke of a soft effect: (dilation radius, blur width). The dilation is whole pixels +/// (`size × spread` rounded: a 2 % spread of a 5 px shadow doesn't grow it at all), the blur +/// keeps `size × (1 − spread)` (ag-psd effects 10.6 → 3.8 % of pixels off). +pub fn spread_split(size: f32, spread: f32) -> (f32, f32) { + ((size * spread).round(), size * (1.0 - spread)) +} + fn shadow_map(shape: &Map, s: &Shadow, light: &GlobalLight, inner: bool) -> Map { let angle = if s.use_global_light { light.angle } else { s.angle }; let (dx, dy) = offset(angle, s.distance); let src = if inner { shape.clone().map(|a| 1.0 - a) } else { shape.clone() }; let mut m = src.shifted(dx, dy, if inner { 1.0 } else { 0.0 }); - m = dilate(&m, s.size * s.spread); - blur(&mut m, s.size * (1.0 - s.spread)); + let (r, bw) = spread_split(s.size, s.spread); + m = dilate(&m, r); + blur(&mut m, bw); let mut m = apply_contour(m, &s.contour); if inner { for (v, a) in m.v.iter_mut().zip(&shape.v) { @@ -520,12 +535,13 @@ fn glow_map(shape: &Map, g: &Glow, inner: bool) -> Map { m } GlowTechnique::Softer => { - let mut m = dilate(&src, g.size * g.spread); - blur(&mut m, g.size * (1.0 - g.spread)); + let (r, bw) = spread_split(g.size, g.spread); + let mut m = dilate(&src, r); + blur(&mut m, bw); if inner && g.source == GlowSource::Center { // Brightest in the middle: coverage from the distance to the edge. - let mut e = dilate(&shape.clone().map(|a| 1.0 - a), g.size * g.spread); - blur(&mut e, g.size * (1.0 - g.spread)); + let mut e = dilate(&shape.clone().map(|a| 1.0 - a), r); + blur(&mut e, bw); m = e.map(|v| 1.0 - v); } m @@ -607,41 +623,138 @@ pub fn tent_kernel(w: f32) -> (i32, Vec) { ((n as i32 - 1) / 2, t) } -/// Separable convolution with a symmetric 1D kernel (outside reads 0). -fn convolve(m: &mut Map, r: i64, kernel: &[f32]) { - let (w, h) = (m.w as i64, m.h as i64); - let mut tmp = vec![0.0f32; m.v.len()]; - for y in 0..h { - for x in 0..w { - let mut acc = 0.0; - for (k, kv) in kernel.iter().enumerate() { - let xx = x + k as i64 - r; - if xx >= 0 && xx < w { - acc += m.v[(y * w + xx) as usize] * kv; +/// Box geometry for a (fractional) width: (`r`, end-tap weight `f`, 1 / width) — the +/// [`box_weights`] taps are `r - 1` full ones each side of the centre plus the two end taps at `f`. +fn box_geom(bw: f32) -> (i64, f64, f64) { + let half = bw.max(1.0) / 2.0; + let r = (half - 0.5).ceil().max(0.0) as i64; + let f = f64::from((half - (r as f32 - 0.5)).clamp(0.0, 1.0)); + (r, f, 1.0 / f64::from(bw.max(1.0))) +} + +/// One box pass over `src` (zero outside it) evaluated at `x0 .. x0 + dst.len()`, as a running +/// sum (O(1) per sample whatever the width). +fn box_line(src: &[f64], x0: i64, dst: &mut [f64], bw: f32) { + let n = src.len() as i64; + let (r, f, norm) = box_geom(bw); + let at = |i: i64| if i >= 0 && i < n { src[i as usize] } else { 0.0 }; + if r == 0 { + for (k, d) in dst.iter_mut().enumerate() { + *d = at(x0 + k as i64); + } + return; + } + let mut inner: f64 = (x0 - (r - 1)..=x0 + (r - 1)).map(at).sum(); + for (k, d) in dst.iter_mut().enumerate() { + let x = x0 + k as i64; + *d = (inner + f * (at(x - r) + at(x + r))) * norm; + inner += at(x + r) - at(x - r + 1); + } +} + +/// Two box passes along a line, exactly the convolution with [`tent_kernel`] (zero outside): the +/// first pass is evaluated `r` samples beyond each end so the second sees what lies there. +fn tent_line(src: &[f32], dst: &mut [f32], bw: f32) { + let (r, _, _) = box_geom(bw); + let s: Vec = src.iter().map(|v| f64::from(*v)).collect(); + let mut mid = vec![0.0f64; src.len() + 2 * r as usize]; + box_line(&s, -r, &mut mid, bw); + let mut out = vec![0.0f64; src.len()]; + // `mid[k]` holds position k - r: output position p reads index p + r. + box_line(&mid, r, &mut out, bw); + for (d, v) in dst.iter_mut().zip(out) { + *d = v as f32; + } +} + +/// Rows of a `w`-wide row-major buffer, each through `f(src_row, dst_row)`, in parallel on +/// scoped OS threads. Not rayon: maps are built inside a `OnceLock` while rayon renders tiles, +/// and a rayon worker that stole another tile here would block on that same lock (deadlock). +fn rows_par(src: &[f32], dst: &mut [f32], w: usize, f: impl Fn(&[f32], &mut [f32]) + Sync) { + if w == 0 { + return; + } + let threads = if cfg!(target_arch = "wasm32") || src.len() < 1 << 16 { 1 } else { std::thread::available_parallelism().map_or(1, |n| n.get()).clamp(1, 16) }; + if threads == 1 { + dst.chunks_mut(w).zip(src.chunks(w)).for_each(|(d, s)| f(s, d)); + return; + } + let rows = (src.len() / w).div_ceil(threads); + std::thread::scope(|sc| { + for (d, s) in dst.chunks_mut(rows * w).zip(src.chunks(rows * w)) { + let f = &f; + sc.spawn(move || d.chunks_mut(w).zip(s.chunks(w)).for_each(|(d, s)| f(s, d))); + } + }); +} + +fn transpose_map(v: &[f32], w: usize, h: usize) -> Vec { + let mut out = vec![0.0f32; v.len()]; + const B: usize = 32; + for by in (0..h).step_by(B) { + for bx in (0..w).step_by(B) { + for y in by..(by + B).min(h) { + for x in bx..(bx + B).min(w) { + out[x * h + y] = v[y * w + x]; } } - tmp[(y * w + x) as usize] = acc; } } - for y in 0..h { - for x in 0..w { - let mut acc = 0.0; - for (k, kv) in kernel.iter().enumerate() { - let yy = y + k as i64 - r; - if yy >= 0 && yy < h { - acc += tmp[(yy * w + x) as usize] * kv; + out +} + +/// Two box passes of width `w` along each axis (the tent [`tent_kernel`] describes, which the GPU +/// convolves directly). +fn tent(m: &mut Map, w: f32) { + if tent_kernel(w).0 == 0 || m.v.is_empty() { + return; + } + tent_fast(m, w); +} + +/// [`tent`] as a direct convolution with [`tent_kernel`] (the GPU's way; tests compare). +#[cfg(test)] +fn tent_direct(m: &mut Map, w: f32) { + { + let (r, k) = tent_kernel(w); + let (mw, mh) = (m.w as i64, m.h as i64); + let mut tmp = vec![0.0f32; m.v.len()]; + for y in 0..mh { + for x in 0..mw { + let mut acc = 0.0; + for (i, kv) in k.iter().enumerate() { + let xx = x + i as i64 - r as i64; + if xx >= 0 && xx < mw { + acc += m.v[(y * mw + xx) as usize] * kv; + } } + tmp[(y * mw + x) as usize] = acc; + } + } + for y in 0..mh { + for x in 0..mw { + let mut acc = 0.0; + for (i, kv) in k.iter().enumerate() { + let yy = y + i as i64 - r as i64; + if yy >= 0 && yy < mh { + acc += tmp[(yy * mw + x) as usize] * kv; + } + } + m.v[(y * mw + x) as usize] = acc; } - m.v[(y * w + x) as usize] = acc; } } } -fn tent(m: &mut Map, w: f32) { - let (r, k) = tent_kernel(w); - if r > 0 { - convolve(m, i64::from(r), &k); - } +fn tent_fast(m: &mut Map, w: f32) { + let (mw, mh) = (m.w, m.h); + let twice = |s: &[f32], d: &mut [f32]| tent_line(s, d, w); + let mut a = vec![0.0f32; m.v.len()]; + rows_par(&m.v, &mut a, mw, twice); + let t = transpose_map(&a, mw, mh); + let mut b = vec![0.0f32; t.len()]; + rows_par(&t, &mut b, mh, twice); + m.v = transpose_map(&b, mh, mw); } /// Where a bevel's maps paint: inside the shape (with the layer), outside it (onto the @@ -653,6 +766,10 @@ pub enum BevelPaint { Both, } +/// Height below which an outer bevel pixel counts as off the bevel (beyond the blur's reach): +/// above float noise of the running-sum blur (~3e-7), far below anything that shades. +pub const BEVEL_H_EPS: f32 = 1e-5; + /// Bevel geometry shared by the CPU maps and the GPU programs. #[derive(Clone, Copy, Debug, PartialEq)] pub struct BevelGeom { @@ -778,7 +895,7 @@ fn bevel_maps(shape: &Map, b: &Bevel, light: &GlobalLight, tex: &TextureCtx) -> let n = [-gx, -gy, 1.0]; let len = (n[0] * n[0] + n[1] * n[1] + 1.0).sqrt(); let shade = (n[0] * light_v[0] + n[1] * light_v[1] + n[2] * light_v[2]) / len; - let region = if outer { f32::from(shape.v[i] < 1.0 - INSIDE_EPS && hmap.v[i] > 0.0) } else { shape.v[i] }; + let region = if outer { f32::from(shape.v[i] < 1.0 - INSIDE_EPS && hmap.v[i] > BEVEL_H_EPS) } else { shape.v[i] }; let k = shade - se; if k > 0.0 { hi.v[i] = (k / (1.0 - se).max(1e-3)).clamp(0.0, 1.0) * region; @@ -1232,6 +1349,21 @@ mod tests { assert!(near.iter().all(|&n| n == 0)); } + #[test] + fn running_sum_tent_matches_the_kernel() { + let (w, h) = (37usize, 23usize); + let src: Vec = (0..w * h).map(|i| ((i * 7919) % 101) as f32 / 100.0).collect(); + for width in [1.0f32, 2.0, 3.5, 5.0, 8.25, 41.0] { + let mut m = Map { w, h, v: src.clone() }; + tent(&mut m, width); + let mut want = Map { w, h, v: src.clone() }; + tent_direct(&mut want, width); + for (a, b) in m.v.iter().zip(&want.v) { + assert!((a - b).abs() < 1e-5, "width {width}: {a} vs {b}"); + } + } + } + #[test] fn tent_kernel_is_two_boxes() { let (r, k) = tent_kernel(5.0); diff --git a/crates/compose/src/lib.rs b/crates/compose/src/lib.rs index c6cc4f1c86..5129aefbea 100644 --- a/crates/compose/src/lib.rs +++ b/crates/compose/src/lib.rs @@ -14,6 +14,7 @@ #![forbid(unsafe_code)] pub mod adjust; +pub mod bounds; pub mod effects; pub mod masks; pub mod multichannel; @@ -79,10 +80,14 @@ pub fn render(doc: &Document, rect: Rect) -> Buffer { /// [`render`] with an explicit tile size (tests check tile independence). pub fn render_tiled(doc: &Document, rect: Rect, tile: i32) -> Buffer { - let cx = Ctx { canvas: doc.bounds(), transfer: adjust::Transfer::for_mode(doc.mode), light: doc.global_light, patterns: &doc.patterns, mode: doc.mode }; + let cx = Ctx { canvas: doc.bounds(), transfer: adjust::Transfer::for_mode(doc.mode), light: doc.global_light, patterns: &doc.patterns, mode: doc.mode, depth: doc.depth }; + // Lab documents mix Normal blending in CIELAB, as Photoshop does (psblend::LAB_MIX). + let lab = doc.mode == photocraft_color::ColorMode::Lab; if rect.width() as i32 <= tile && rect.height() as i32 <= tile { let mut buf = multichannel::backdrop(doc, rect); + psblend::LAB_MIX.with(|l| l.set(lab)); composite_stack(&doc.layers, &mut buf, &cx); + psblend::LAB_MIX.with(|l| l.set(false)); return buf; } let mut tiles = Vec::new(); @@ -97,7 +102,9 @@ pub fn render_tiled(doc: &Document, rect: Rect, tile: i32) -> Buffer { } let run = |t: &Rect| { let mut b = multichannel::backdrop(doc, *t); + psblend::LAB_MIX.with(|l| l.set(lab)); composite_stack(&doc.layers, &mut b, &cx); + psblend::LAB_MIX.with(|l| l.set(false)); b }; #[cfg(not(target_arch = "wasm32"))] @@ -127,7 +134,7 @@ pub fn flatten(doc: &Document) -> Buffer { /// Render an arbitrary subset: a single layer (e.g. for thumbnails), isolated. pub fn render_layer(layer: &Layer, rect: Rect) -> Buffer { let mut buf = Buffer::transparent(rect); - composite_stack(std::slice::from_ref(layer), &mut buf, &Ctx { canvas: rect, transfer: adjust::Transfer::Srgb, light: photocraft_doc::GlobalLight::default(), patterns: &[], mode: photocraft_color::ColorMode::Rgb }); + composite_stack(std::slice::from_ref(layer), &mut buf, &Ctx { canvas: rect, transfer: adjust::Transfer::Srgb, light: photocraft_doc::GlobalLight::default(), patterns: &[], mode: photocraft_color::ColorMode::Rgb, depth: photocraft_color::SampleType::F32 }); buf } @@ -182,6 +189,7 @@ struct Ctx<'a> { patterns: &'a [Pattern], /// The document's colour mode (channel restrictions name its channels). mode: photocraft_color::ColorMode, + depth: photocraft_color::SampleType, } fn composite_stack(layers: &[Layer], backdrop: &mut Buffer, cx: &Ctx) { @@ -196,11 +204,36 @@ fn composite_stack(layers: &[Layer], backdrop: &mut Buffer, cx: &Ctx) { let clipped = &layers[i + 1..j]; if base.visible { composite_layer(base, clipped, backdrop, cx); + if let (LayerContent::Adjustment(_), Some(q)) = (&base.content, adjustment_quantum(cx.depth)) { + quantize(backdrop, q); + } } i = j.max(i + 1); } } +/// Steps per unit of an integer document's samples: Photoshop applies adjustment layers to +/// buffers of the document's depth (8-bit: 255 levels, 16-bit: 32768), so their result is +/// rounded there; a steep curve then amplifies the rounding of its input exactly as in +/// Photoshop (psd-tools adjustment_nested_composition_4: 9.6 → 5.1 % of pixels off; +/// exposure_grayscale passes). Blends stay in float (quantising them too made other files +/// worse). +pub fn adjustment_quantum(depth: photocraft_color::SampleType) -> Option { + match depth { + photocraft_color::SampleType::U8 => Some(255.0), + photocraft_color::SampleType::U16 => Some(32768.0), + photocraft_color::SampleType::F32 => None, + } +} + +fn quantize(b: &mut Buffer, q: f32) { + for p in &mut b.px { + for v in p.iter_mut() { + *v = (*v * q + 0.5).floor() / q; + } + } +} + /// Deterministic hash for Dissolve (document-coordinate based, so it is stable under tiling). #[inline] fn dissolve_noise(x: i32, y: i32) -> f32 { @@ -212,8 +245,8 @@ fn dissolve_noise(x: i32, y: i32) -> f32 { } /// Bounds of a layer's own pixels (union over group children; the canvas -/// for fill layers). -fn layer_bounds(layer: &Layer, canvas: Rect) -> Rect { +/// for fill layers; an artboard's board). +pub fn layer_bounds(layer: &Layer, canvas: Rect) -> Rect { match &layer.content { LayerContent::Group(g) if g.artboard.is_some() => g.artboard.as_ref().map_or(Rect::EMPTY, |a| a.rect), LayerContent::Group(g) => g.children.iter().filter(|c| c.visible).fold(Rect::EMPTY, |acc, c| { @@ -221,10 +254,21 @@ fn layer_bounds(layer: &Layer, canvas: Rect) -> Rect { if b.is_empty() { acc } else if acc.is_empty() { b } else { acc.union(&b) } }), LayerContent::Fill(_) => canvas, - _ => layer.surface().map_or(Rect::EMPTY, Surface::content_bounds), + _ => layer.surface().map_or(Rect::EMPTY, bounds::content_bounds), } } +/// The frame layer-effect gradients and linked patterns are laid out in, when it isn't the +/// layer's pixel bounds: a shape layer's path bounds (rounded out to whole pixels). Its rendered +/// pixels can extend past the path (transparent anti-aliasing margin), which Photoshop ignores: +/// psd-tools shape-fx2's 45° overlay spans the 29 px path, not the 32 px of pixels. +pub fn paint_bounds(layer: &Layer) -> Option { + let LayerContent::Shape(sh) = &layer.content else { return None }; + let (x0, y0, x1, y1) = sh.path.control_bounds()?; + let r = Rect::new(x0.floor() as i32, y0.floor() as i32, x1.ceil() as i32, y1.ceil() as i32); + (!r.is_empty()).then_some(r) +} + /// The layer's effective mask over `rect` (row-major), read once per tile: the pixel mask /// times the rasterized vector mask. fn mask_vals(layer: &Layer, rect: Rect) -> Option> { @@ -276,7 +320,7 @@ fn render_content(layer: &Layer, rect: Rect, cx: &Ctx) -> Option { /// The alpha of `layer`'s own content over `rect` (masks applied, row-major): the shape its /// effect maps are built from (for the GPU compositor). Zero for adjustment layers. pub fn layer_shape(doc: &Document, layer: &Layer, rect: Rect) -> Vec { - let cx = Ctx { canvas: doc.bounds(), transfer: adjust::Transfer::for_mode(doc.mode), light: doc.global_light, patterns: &doc.patterns, mode: doc.mode }; + let cx = Ctx { canvas: doc.bounds(), transfer: adjust::Transfer::for_mode(doc.mode), light: doc.global_light, patterns: &doc.patterns, mode: doc.mode, depth: doc.depth }; render_content(layer, rect, &cx).map(|b| b.px.iter().map(|p| p[3]).collect()).unwrap_or_else(|| vec![0.0; rect.width() as usize * rect.height() as usize]) } @@ -295,7 +339,7 @@ pub fn fill_frame(layer: &Layer, canvas: Rect) -> Rect { && m.enabled && m.surface.default_pixel().first().is_some_and(|v| *v <= 0.0) { - let b = m.surface.content_bounds().intersect(&canvas); + let b = bounds::content_bounds(&m.surface).intersect(&canvas); if !b.is_empty() { frame = b; } @@ -370,7 +414,10 @@ fn sample_stops(stops: &[(f32, photocraft_color::Color)], t: f32) -> [f32; 4] { /// vanish with it. fn empty_in(layer: &Layer, rect: Rect) -> bool { if effects::has_effects(layer) { - return false; + // Effects reach at most `margin` beyond the layer's pixels (when it is transparent + // outside them): render tiles away from a small text layer skip it entirely. + let canvas = Rect::new(i32::MIN / 4, i32::MIN / 4, i32::MAX / 4, i32::MAX / 4); + return transparent_outside(layer) && layer_bounds(layer, canvas).inflate(effects::margin(layer)).intersect(&rect).is_empty(); } match &layer.content { LayerContent::Raster(_) | LayerContent::Text(_) | LayerContent::Shape(_) | LayerContent::Smart(_) => match layer.surface() { @@ -411,6 +458,18 @@ fn restore_channels(out: &mut Buffer, before: &Buffer, w: [f32; 3]) { } } +/// Whether the layer's content is transparent outside its bounds (every surface it draws from +/// has a transparent default pixel), so its effects can't change pixels beyond its bounds grown +/// by their reach. +pub fn transparent_outside(layer: &Layer) -> bool { + match &layer.content { + LayerContent::Group(g) => g.children.iter().filter(|c| c.visible).all(transparent_outside), + // Fill layers cover the canvas (their bounds); adjustments draw nothing of their own. + LayerContent::Fill(_) | LayerContent::Adjustment(_) => true, + _ => layer.surface().is_none_or(|s| s.format().alpha && s.default_pixel().last().is_some_and(|a| *a <= 0.0)), + } +} + /// Composite `layer` (plus its clipping group) onto `backdrop`, honouring its channel restrictions. fn composite_layer(layer: &Layer, clipped: &[Layer], backdrop: &mut Buffer, cx: &Ctx) { match channel_weights(layer, cx.mode) { @@ -552,7 +611,7 @@ fn composite_layer_plain(layer: &Layer, clipped: &[Layer], backdrop: &mut Buffer composite_atop(c, &mut content, cx); } let maps = effect_maps(layer, cx); - effects::composite_with_effects(layer, &content, backdrop, &maps, layer_bounds(layer, cx.canvas), cx.patterns); + effects::composite_with_effects(layer, &content, backdrop, &maps, paint_bounds(layer).unwrap_or_else(|| layer_bounds(layer, cx.canvas)), cx.patterns); return; } if let Some((mut content, stroke)) = shape_parts(layer, clipped, rect, cx) { @@ -572,9 +631,10 @@ fn composite_layer_plain(layer: &Layer, clipped: &[Layer], backdrop: &mut Buffer blend_into_g(backdrop, &content, layer.blend, opacity, text_gamma(layer)); } -/// The coverage-mixing gamma of a layer: [`psblend::TEXT_GAMMA`] for type layers, else 1. +/// The coverage-mixing gamma of a layer: the text blending gamma +/// ([`psblend::set_text_gamma`], Photoshop's default 1.45) for type layers, else 1. pub fn text_gamma(layer: &Layer) -> f32 { - if matches!(layer.content, LayerContent::Text(_)) { psblend::TEXT_GAMMA } else { 1.0 } + if matches!(layer.content, LayerContent::Text(_)) { psblend::text_gamma() } else { 1.0 } } /// A stroked shape layer with visible clipped layers: Photoshop draws the shape's vector stroke @@ -743,7 +803,7 @@ fn effect_maps(layer: &Layer, cx: &Ctx) -> std::sync::Arc { } fn texture_ctx<'a>(layer: &Layer, region: Rect, cx: &Ctx<'a>) -> effects::TextureCtx<'a> { - let sb = layer_bounds(layer, cx.canvas); + let sb = paint_bounds(layer).unwrap_or_else(|| layer_bounds(layer, cx.canvas)); effects::TextureCtx { rect: region, patterns: cx.patterns, anchor: layer.effects.reference.unwrap_or((f64::from(sb.x0), f64::from(sb.y0))) } } @@ -783,7 +843,7 @@ fn composite_atop_any(layer: &Layer, base: &mut Buffer, cx: &Ctx) { let Some(content) = render_content(layer, big, cx) else { return }; let mut opaque = Buffer { rect, px: base.px.iter().map(|p| [p[0], p[1], p[2], 1.0]).collect() }; let maps = effect_maps(layer, cx); - effects::composite_with_effects(layer, &content, &mut opaque, &maps, layer_bounds(layer, cx.canvas), cx.patterns); + effects::composite_with_effects(layer, &content, &mut opaque, &maps, paint_bounds(layer).unwrap_or_else(|| layer_bounds(layer, cx.canvas)), cx.patterns); for (p, o) in base.px.iter_mut().zip(&opaque.px) { if p[3] > 0.0 { *p = [o[0], o[1], o[2], p[3]]; diff --git a/crates/compose/src/pattern.rs b/crates/compose/src/pattern.rs index 07a90a1d45..f352985c7d 100644 --- a/crates/compose/src/pattern.rs +++ b/crates/compose/src/pattern.rs @@ -97,6 +97,11 @@ impl Placement { Placement { origin, cs: (a.cos(), a.sin()), inv_scale } } + /// (origin, inverse rotation (cos, sin), inverse scale), for GPU shaders. + pub fn parts(&self) -> ((f64, f64), (f64, f64), f64) { + (self.origin, self.cs, self.inv_scale) + } + /// Tile coordinates of the document point `(x, y)`. #[inline] pub fn map(&self, x: f64, y: f64) -> (f64, f64) { diff --git a/crates/compose/src/psblend.rs b/crates/compose/src/psblend.rs index d762428b8a..50c20d92ca 100644 --- a/crates/compose/src/psblend.rs +++ b/crates/compose/src/psblend.rs @@ -71,6 +71,13 @@ fn hard_mix_ps(cb: f32, cs: f32) -> f32 { if vivid_light_generic(cb, cs) >= 0.5 - 1e-6 { 1.0 } else { 0.0 } } +thread_local! { + /// Set while rendering a Lab document: Normal blending mixes backdrop and source in CIELAB + /// (Photoshop composites Lab documents in Lab; an anti-aliased edge between two colours + /// differs by up to 14 / 255 from an sRGB mix: psd-tools stroke-color-descriptors-lab). + pub static LAB_MIX: std::cell::Cell = const { std::cell::Cell::new(false) }; +} + /// `B(Cb, Cs)` with Photoshop's variants. pub fn blend_rgb(mode: BlendMode, cb: [f32; 3], cs: [f32; 3]) -> [f32; 3] { match mode { @@ -91,6 +98,15 @@ pub fn composite(mode: BlendMode, backdrop: [f32; 4], source: [f32; 4], opacity: return backdrop; } let ao = as_ + ab * (1.0 - as_); + if mode == BlendMode::Normal && LAB_MIX.with(|l| l.get()) && ab > 0.0 && ao > 0.0 { + let lb = photocraft_color::convert::srgb_to_lab([backdrop[0], backdrop[1], backdrop[2]]); + let ls = photocraft_color::convert::srgb_to_lab([source[0], source[1], source[2]]); + let kb = ab * (1.0 - as_) / ao; + let k = as_ / ao; + let m: [f32; 3] = std::array::from_fn(|i| lb[i] * kb + ls[i] * k); + let r = photocraft_color::convert::lab_to_srgb(m); + return [r[0], r[1], r[2], ao]; + } if mode == BlendMode::Normal { // Fast path: B(Cb, Cs) = Cs. if ao <= 0.0 { @@ -126,6 +142,21 @@ pub fn composite(mode: BlendMode, backdrop: [f32; 4], source: [f32; 4], opacity: /// a linear mix gives 40). pub const TEXT_GAMMA: f32 = 1.45; +static TEXT_GAMMA_SETTING: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0x3fb9_999a); // 1.45f32 + +/// Sets Color Settings › "Blend Text Colors Using Gamma" (1 = off). It is an application +/// setting, not stored in documents: files saved with it off (ag-psd float-color) mix type +/// linearly. Values are clamped to Photoshop's 1.00–2.20. +pub fn set_text_gamma(gamma: f32) { + let g = if gamma.is_finite() { gamma.clamp(1.0, 2.2) } else { TEXT_GAMMA }; + TEXT_GAMMA_SETTING.store(g.to_bits(), std::sync::atomic::Ordering::Relaxed); +} + +/// The current text blending gamma (see [`set_text_gamma`]; 1 = off). +pub fn text_gamma() -> f32 { + f32::from_bits(TEXT_GAMMA_SETTING.load(std::sync::atomic::Ordering::Relaxed)) +} + /// [`composite`] with the coverage mix done in a `gamma` space (`gamma == 1` is [`composite`]). pub fn composite_gamma(mode: BlendMode, backdrop: [f32; 4], source: [f32; 4], opacity: f32, gamma: f32) -> [f32; 4] { if gamma == 1.0 { diff --git a/crates/compose/src/tests.rs b/crates/compose/src/tests.rs index 5dc415b6ac..e1b535e79c 100644 --- a/crates/compose/src/tests.rs +++ b/crates/compose/src/tests.rs @@ -644,7 +644,7 @@ fn effect_maps_are_cached_and_invalidated_by_pixel_changes() { let mut l = solid_layer("fx", Rect::new(16, 16, 48, 48), [1.0, 0.0, 0.0, 1.0]); l.effects.items.push(photocraft_doc::Effect::default_drop_shadow()); doc.layers.push(l); - let cx = Ctx { canvas: doc.bounds(), transfer: adjust::Transfer::Srgb, light: doc.global_light, patterns: &doc.patterns, mode: doc.mode }; + let cx = Ctx { canvas: doc.bounds(), transfer: adjust::Transfer::Srgb, light: doc.global_light, patterns: &doc.patterns, mode: doc.mode, depth: doc.depth }; let a = effect_maps(&doc.layers[1], &cx); let b = effect_maps(&doc.layers[1], &cx); assert!(std::sync::Arc::ptr_eq(&a, &b), "second request hits the cache"); @@ -776,3 +776,31 @@ fn channel_restrictions_keep_the_backdrop() { assert_eq!(channel_weights(&d.layers[1], ColorMode::Cmyk), None); assert_eq!(channel_weights(&d.layers[1], ColorMode::Rgb), Some([1.0, 1.0, 0.0])); } + +#[test] +fn effect_maps_built_inside_parallel_tiles_do_not_deadlock() { + // A map large enough for the blur to go multi-threaded, built while rayon renders tiles that + // all wait on the same map (a rayon-parallel blur deadlocked here). + let mut d = doc_white(900, 700); + let mut l = solid_layer("fx", Rect::new(100, 100, 800, 600), [0.2, 0.4, 0.9, 1.0]); + l.effects.items = vec![photocraft_doc::Effect::default_drop_shadow()]; + if let photocraft_doc::Effect::DropShadow(s) = &mut l.effects.items[0] { + s.size = 30.0; + } + d.layers.push(l); + let out = render(&d, d.bounds()); + assert_eq!(out.px.len(), 900 * 700); +} + +#[test] +fn adjustment_results_are_rounded_to_the_document_depth() { + for (depth, q) in [(SampleType::U8, Some(255.0f32)), (SampleType::U16, Some(32768.0)), (SampleType::F32, None)] { + let mut d = Document::with_background("q", Size::new(4, 4), ColorMode::Rgb, depth, Color::rgb(0.3, 0.6, 0.9)); + d.layers.push(Layer::new("lv", LayerContent::Adjustment(Adjustment::Exposure { exposure: 0.37, offset: 0.0, gamma: 1.0 }))); + let p = px(&d, 1, 1); + match q { + Some(q) => assert!(p.iter().all(|v| ((v * q).round() - v * q).abs() < 1e-3), "{depth:?} {p:?}"), + None => assert!(p[..3].iter().any(|v| ((v * 255.0).round() - v * 255.0).abs() > 1e-3), "{p:?}"), + } + } +} diff --git a/crates/engine/src/color_cmds.rs b/crates/engine/src/color_cmds.rs index 464ac26e16..87fd627094 100644 --- a/crates/engine/src/color_cmds.rs +++ b/crates/engine/src/color_cmds.rs @@ -120,6 +120,9 @@ pub struct ColorSettings { pub intent: String, pub bpc: bool, pub dither: bool, + /// Advanced › "Blend Text Colors Using Gamma" (1 = off; Photoshop's default 1.45): type + /// layers mix anti-aliased edges in this gamma (`photocraft_compose::psblend::set_text_gamma`). + pub blend_text_gamma: f32, } impl Default for ColorSettings { @@ -137,6 +140,7 @@ impl Default for ColorSettings { intent: Intent::RelativeColorimetric.id().into(), bpc: true, dither: true, + blend_text_gamma: photocraft_compose::psblend::TEXT_GAMMA, } } } @@ -781,8 +785,18 @@ fn color_settings(s: &mut Session, p: &Value) -> Result { if let Some(v) = str_of("intent") { next.intent = Intent::parse(&v).map(|i| i.id().to_string()).unwrap_or(v); } + match p.get("blendTextGamma") { + Some(Value::Bool(false)) => next.blend_text_gamma = 1.0, + Some(Value::Bool(true)) => next.blend_text_gamma = photocraft_compose::psblend::TEXT_GAMMA, + Some(v) => { + let g = v.as_f64().filter(|g| (1.0..=2.2).contains(g)).ok_or_else(|| EngineError::BadParams { cmd: cmd.into(), msg: "`blendTextGamma` must be 1.0..2.2 or a bool".into() })?; + next.blend_text_gamma = g as f32; + } + None => {} + } validate_settings(&next).map_err(|msg| EngineError::BadParams { cmd: cmd.into(), msg })?; if next != s.color.settings { + photocraft_compose::psblend::set_text_gamma(next.blend_text_gamma); s.color.settings = next; // Persisted with the preferences. s.prefs.edit(|_| ()); @@ -855,7 +869,7 @@ pub fn specs() -> Vec { "edit.colorSettings", "Color Settings…", ["Edit"], - r##"{"workingRgb":"srgb|display-p3|adobe-rgb-compat|prophoto-compat|linear-srgb|rec2020","workingCmyk":"coated-cmyk","workingGray":"sgray|gray-gamma-2.2","policyRgb":"preserve|convert|off","policyCmyk":"preserve|convert|off","policyGray":"preserve|convert|off","askOnMismatch":bool=true,"askOnPaste":bool=true,"askOnMissing":bool=false,"intent":"relative|perceptual|saturation|absolute","bpc":bool=true,"dither":bool=true,"reset":bool=false} (working spaces also accept .icc paths)"##, + r##"{"workingRgb":"srgb|display-p3|adobe-rgb-compat|prophoto-compat|linear-srgb|rec2020","workingCmyk":"coated-cmyk","workingGray":"sgray|gray-gamma-2.2","policyRgb":"preserve|convert|off","policyCmyk":"preserve|convert|off","policyGray":"preserve|convert|off","askOnMismatch":bool=true,"askOnPaste":bool=true,"askOnMissing":bool=false,"intent":"relative|perceptual|saturation|absolute","blendTextGamma":1.0..2.2|bool=1.45,"bpc":bool=true,"dither":bool=true,"reset":bool=false} (working spaces also accept .icc paths)"##, always, color_settings, true, @@ -1097,6 +1111,20 @@ mod settings_tests { assert_eq!(t.color.settings, s.color.settings); } + #[test] + fn blend_text_gamma_setting() { + let mut s = Session::new(); + assert!((s.color.settings.blend_text_gamma - 1.45).abs() < 1e-6); + assert!(s.execute("edit.colorSettings", json!({"blendTextGamma": 3.0})).is_err()); + // The compositor's (application-wide) gamma follows; restored to the default at once. + s.execute("edit.colorSettings", json!({"blendTextGamma": 1.45})).unwrap(); + assert!((photocraft_compose::psblend::text_gamma() - 1.45).abs() < 1e-6); + let r = s.execute("edit.colorSettings", json!({"blendTextGamma": false})).unwrap(); + assert_eq!(r["settings"]["blendTextGamma"], 1.0); + s.execute("edit.colorSettings", json!({"blendTextGamma": true})).unwrap(); + assert!((s.color.settings.blend_text_gamma - 1.45).abs() < 1e-6); + } + #[test] fn open_policies() { let mut s = Session::new(); diff --git a/crates/engine/src/commands.rs b/crates/engine/src/commands.rs index 6177428490..584fe6efee 100644 --- a/crates/engine/src/commands.rs +++ b/crates/engine/src/commands.rs @@ -461,7 +461,7 @@ fn build() -> Vec { Ok(Value::Null) }), cmd!("layer.select", "Select Layer", [], None, r##"{"layer":id,"mode":"replace|toggle|range|add"="replace"} (toggle = ⌘-click, range = ⇧-click)"##, has_doc, crate::layer_multi_cmds::select), - cmd!("layer.setProps", "Layer Properties", [], None, r##"{"layer":id?,"name":str?,"visible":bool?,"opacity":0..1?,"fill":0..1?,"blend":"Multiply|…"?,"clipped":bool?,"locked":bool?,"locks":{"transparency","pixels","position","artboard","all":bool}?}"##, has_layer, |s, p| { + cmd!("layer.setProps", "Layer Properties", [], None, r##"{"layer":id?,"name":str?,"visible":bool?,"opacity":0..1?,"fill":0..1?,"blend":"Multiply|…"?,"clipped":bool?,"locked":bool?,"locks":{"transparency","pixels","position","artboard","all":bool}?,"channels":[bool,…]? (Advanced Blending: which colour channels blend, R G B / C M Y K / L a b)}"##, has_layer, |s, p| { let id = layer_param(s, p)?; let label = if p.get("visible").is_some() && p.as_object().is_some_and(|o| o.len() <= 2) { "Layer Visibility" } else { "Layer Properties" }; s.edit(label, |doc, _| { @@ -487,6 +487,10 @@ fn build() -> Vec { if let Some(v) = p.get("locked").and_then(Value::as_bool) { l.locks.all = v; } + if let Some(Value::Array(ch)) = p.get("channels") { + // Blending Options › Advanced Blending › Channels: unchecked = left out. + l.excluded_channels = ch.iter().take(32).enumerate().filter(|(_, v)| v.as_bool() == Some(false)).fold(0, |m, (i, _)| m | 1 << i); + } if let Some(Value::Object(m)) = p.get("locks") { for (k, v) in m { let v = v.as_bool().unwrap_or(false); diff --git a/crates/engine/src/inspect.rs b/crates/engine/src/inspect.rs index 77f477eda8..43b8c4c38f 100644 --- a/crates/engine/src/inspect.rs +++ b/crates/engine/src/inspect.rs @@ -95,6 +95,10 @@ fn layer_sel(l: &Layer, selected: &[photocraft_doc::LayerId]) -> Value { } _ => {} } + // Advanced Blending › Channels (only when some channel is left out). + if l.excluded_channels != 0 { + v["channels"] = json!((0..4).map(|i| l.excluded_channels & (1 << i) == 0).collect::>()); + } // Layer styles, so agents can verify what they applied (full settings via the style commands). if !l.effects.items.is_empty() { v["effects"] = json!({ diff --git a/crates/engine/src/layer_style.rs b/crates/engine/src/layer_style.rs index 4696276b31..c3f30590cb 100644 --- a/crates/engine/src/layer_style.rs +++ b/crates/engine/src/layer_style.rs @@ -149,8 +149,16 @@ pub fn effect_from_params(kind: &str, p: &Value) -> Option { highlight_color: Color::WHITE, shadow: FxCommon::new(BlendMode::Multiply, 0.75), shadow_color: Color::BLACK, - contour: None, - texture: None, + contour: b(p, "contour", false).then(|| photocraft_doc::BevelContour { contour: Contour::Linear, range: (f(p, "contourRange", 50.0) / 100.0).clamp(0.01, 1.0), anti_alias: false }), + texture: p.get("texture").and_then(Value::as_str).filter(|t| !t.is_empty()).map(|t| photocraft_doc::BevelTexture { + name: t.to_string(), + id: t.to_string(), + scale: (f(p, "textureScale", 100.0) / 100.0).clamp(0.01, 10.0), + depth: (f(p, "textureDepth", 100.0) / 100.0).clamp(-10.0, 10.0), + invert: b(p, "textureInvert", false), + link: b(p, "textureLink", true), + phase: (0.0, 0.0), + }), }), _ => return None, }) @@ -215,7 +223,7 @@ pub fn specs() -> Vec { style_cmd!("colorOverlay", "Color Overlay…", r##"{"color":"#rrggbb","opacity":0..100=100,"blend":str,"add":bool}"##), style_cmd!("gradientOverlay", "Gradient Overlay…", r##"{"from":"#rrggbb","to":"#rrggbb","style":"linear|radial|angle|reflected|diamond","angle":deg=90,"scale":10..150=100,"reverse":bool,"opacity":0..100,"blend":str,"add":bool}"##), style_cmd!("patternOverlay", "Pattern Overlay…", r##"{"pattern":id|name?=first library pattern,"opacity":0..100=100,"blend":str,"scale":1..1000=100,"angle":deg=0,"link":bool=true,"phaseX":px,"phaseY":px,"add":bool}"##), - style_cmd!("bevelEmboss", "Bevel & Emboss…", r##"{"style":"inner|outer|emboss|pillow|stroke","technique":"smooth|chiselHard|chiselSoft","depth":1..1000=100,"direction":"up|down","size":px=5,"soften":px,"angle":deg,"altitude":deg,"add":bool}"##), + style_cmd!("bevelEmboss", "Bevel & Emboss…", r##"{"style":"inner|outer|emboss|pillow|stroke","technique":"smooth|chiselHard|chiselSoft","contour":bool,"contourRange":1..100=50,"texture":pattern id|name?,"textureScale":1..1000=100,"textureDepth":-1000..1000=100,"textureInvert":bool,"textureLink":bool=true,"depth":1..1000=100,"direction":"up|down","size":px=5,"soften":px,"angle":deg,"altitude":deg,"add":bool}"##), style_cmd!("satin", "Satin…", r##"{"color":"#rrggbb","opacity":0..100=50,"blend":str,"angle":deg,"distance":px,"size":px,"invert":bool,"add":bool}"##), CommandSpec { id: "layer.layerStyle.clear", @@ -258,6 +266,18 @@ mod tests { d.doc.layer(d.active_layer.unwrap()).unwrap().effects.items.clone() } + #[test] + fn bevel_command_sets_technique_contour_and_texture() { + let mut s = session(); + s.execute("layer.layerStyle.bevelEmboss", json!({"style": "pillow", "technique": "chiselHard", "contour": true, "contourRange": 70, "texture": "Bubbles", "textureDepth": -200, "textureInvert": true})).unwrap(); + let fx = effects(&s); + let Effect::BevelEmboss(b) = &fx[0] else { panic!("{fx:?}") }; + assert_eq!((b.style, b.technique), (photocraft_doc::BevelStyle::PillowEmboss, BevelTechnique::ChiselHard)); + assert!((b.contour.as_ref().unwrap().range - 0.7).abs() < 1e-6); + let t = b.texture.as_ref().unwrap(); + assert_eq!((t.name.as_str(), t.depth, t.invert), ("Bubbles", -2.0, true)); + } + #[test] fn every_style_command_adds_its_effect() { for kind in ["dropShadow", "innerShadow", "outerGlow", "innerGlow", "stroke", "colorOverlay", "gradientOverlay", "bevelEmboss", "satin"] { diff --git a/crates/engine/src/prefs.rs b/crates/engine/src/prefs.rs index aa59e272c9..e1bf108549 100644 --- a/crates/engine/src/prefs.rs +++ b/crates/engine/src/prefs.rs @@ -1015,6 +1015,7 @@ impl Session { let prefs: Preferences = serde_json::from_value(v).map_err(|e| format!("preferences: {e}"))?; if let Some(c) = color { self.color.settings = serde_json::from_value(c).unwrap_or_default(); + photocraft_compose::psblend::set_text_gamma(self.color.settings.blend_text_gamma); } self.prefs.edit(|p| *p = prefs); if let Some(v) = presets { diff --git a/crates/engine/src/print_cmds.rs b/crates/engine/src/print_cmds.rs index 32d43e0a78..2f0b731f21 100644 --- a/crates/engine/src/print_cmds.rs +++ b/crates/engine/src/print_cmds.rs @@ -298,8 +298,11 @@ fn do_print(s: &mut Session, p: &Value, cmd: &str) -> Result { let pdf_path = match &output { Some(o) => o.clone(), None => { + // Unique per call: concurrent prints of same-named documents must not share a spool file. + static SEQ: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0); + let n = SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed); let tmp = std::env::temp_dir().to_string_lossy().into_owned(); - join(&tmp, &format!("{}-print-{}.pdf", crate::file_cmds::sanitize(&stem(&doc.name)), std::process::id())) + join(&tmp, &format!("{}-print-{}-{n}.pdf", crate::file_cmds::sanitize(&stem(&doc.name)), std::process::id())) } }; write_file(&pdf_path, &pdf)?; diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index dfa25cd277..52ae2ab7ec 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -482,3 +482,16 @@ fn duplicating_the_background_unlocks_the_copy() { assert_eq!(copy.locks, photocraft_doc::Locks::default()); assert!(st.doc.layers[0].locks.transparency); } + +#[test] +fn advanced_blending_channels() { + let mut s = session_with_doc(); + let r = s.execute("layer.new.layer", json!({})).unwrap(); + let id = r["layer"].as_u64().unwrap(); + s.execute("layer.setProps", json!({"channels": [true, true, false]})).unwrap(); + assert_eq!(s.active().unwrap().doc.layer(LayerId(id)).unwrap().excluded_channels, 0b100); + let ins = crate::inspect::layer(s.active().unwrap().doc.layer(LayerId(id)).unwrap()); + assert_eq!(ins["channels"], json!([true, true, false, true])); + s.execute("edit.undo", json!({})).unwrap(); + assert_eq!(s.active().unwrap().doc.layer(LayerId(id)).unwrap().excluded_channels, 0); +} diff --git a/crates/format/src/manifest.rs b/crates/format/src/manifest.rs index c2d3b07606..37e360a315 100644 --- a/crates/format/src/manifest.rs +++ b/crates/format/src/manifest.rs @@ -301,6 +301,10 @@ pub struct ChannelM { pub indicates: photocraft_doc::ColorIndicates, } +fn is_zero_u32(v: &u32) -> bool { + *v == 0 +} + fn default_channel_color() -> Color { photocraft_doc::AlphaChannel::DEFAULT_COLOR } @@ -337,7 +341,3 @@ mod channel_tests { assert_eq!(c.indicates, photocraft_doc::ColorIndicates::MaskedAreas); } } - -fn is_zero_u32(v: &u32) -> bool { - *v == 0 -} diff --git a/crates/format/src/store.rs b/crates/format/src/store.rs index 4b08d53094..39e599d17b 100644 --- a/crates/format/src/store.rs +++ b/crates/format/src/store.rs @@ -321,6 +321,31 @@ impl Object { } } +/// Compresses `objects` on scoped worker threads (sequentially on wasm). +fn par_compress<'a>(objects: &[(&'a String, &'a Object)]) -> Vec<(&'a String, Arc>)> { + let threads = if cfg!(target_arch = "wasm32") { 1 } else { std::thread::available_parallelism().map_or(1, |n| n.get()).clamp(1, 32) }; + if threads < 2 || objects.len() < 2 { + return objects.iter().map(|(p, o)| (*p, Arc::new(o.compressed()))).collect(); + } + let next = std::sync::atomic::AtomicUsize::new(0); + std::thread::scope(|sc| { + let hs: Vec<_> = (0..threads.min(objects.len())) + .map(|_| { + sc.spawn(|| { + let mut out = Vec::new(); + loop { + let i = next.fetch_add(1, std::sync::atomic::Ordering::Relaxed); + let Some((p, o)) = objects.get(i) else { break }; + out.push((*p, Arc::new(o.compressed()))); + } + out + }) + }) + .collect(); + hs.into_iter().flat_map(|h| h.join().expect("compress worker")).collect() + }) +} + impl PcraftWriter { pub fn new() -> Self { Self::default() @@ -379,6 +404,9 @@ impl PcraftWriter { z.add(name, data)?; } let mut next = HashMap::with_capacity(p.objects.len()); + // New objects are compressed on all cores first (zstd dominates a full save). + let todo: Vec<(&String, &Object)> = p.objects.iter().filter(|(path, _)| !self.compressed.contains_key(*path)).collect(); + let mut fresh: HashMap<&String, Arc>> = par_compress(&todo).into_iter().collect(); for (path, obj) in &p.objects { let data = match self.compressed.get(path) { Some(d) => { @@ -392,7 +420,7 @@ impl PcraftWriter { Object::Tile(..) => stats.tiles_written += 1, Object::Blob(_) => stats.blobs_written += 1, } - Arc::new(obj.compressed()) + fresh.remove(path).unwrap_or_else(|| Arc::new(obj.compressed())) } }; z.add(path, &data)?; diff --git a/crates/gpu/src/bounds.rs b/crates/gpu/src/bounds.rs index 6ad39c717b..bde68bdd46 100644 --- a/crates/gpu/src/bounds.rs +++ b/crates/gpu/src/bounds.rs @@ -2,91 +2,16 @@ //! content scan cached by copy-on-write tile identity, so an effect layer's region costs a hash //! lookup per tile instead of a pixel scan per frame. -use std::collections::HashMap; -use std::sync::{Arc, Mutex, Weak}; +use photocraft_doc::Layer; +use photocraft_geom::Rect; +#[cfg(test)] +use photocraft_raster::Surface; -use photocraft_doc::{Layer, LayerContent}; -use photocraft_geom::{Rect, TILE_SIZE}; -use photocraft_raster::{Surface, Tile}; +pub use photocraft_compose::bounds::content_bounds; -struct Entry { - tile: Weak, - /// Content bounds inside the tile (tile-local), for one default pixel. - default: Box<[u8]>, - bounds: Option<(u16, u16, u16, u16)>, -} - -fn cache() -> &'static Mutex> { - static C: std::sync::OnceLock>> = std::sync::OnceLock::new(); - C.get_or_init(Default::default) -} - -/// Pixels of `t` that differ from `dp` (tile-local half-open bounds). -fn scan(t: &Tile, dp: &[u8]) -> Option<(u16, u16, u16, u16)> { - let bpp = dp.len(); - let ts = TILE_SIZE as usize; - let (mut x0, mut y0, mut x1, mut y1) = (usize::MAX, usize::MAX, 0usize, 0usize); - for (y, row) in t.bytes().chunks_exact(ts * bpp).enumerate() { - let Some(first) = row.chunks_exact(bpp).position(|px| px != dp) else { continue }; - let last = ts - 1 - row.chunks_exact(bpp).rev().position(|px| px != dp).unwrap_or(0); - x0 = x0.min(first); - x1 = x1.max(last + 1); - y0 = y0.min(y); - y1 = y + 1; - } - (x0 != usize::MAX).then_some((x0 as u16, y0 as u16, x1 as u16, y1 as u16)) -} - -/// `Surface::content_bounds`, cached per tile. -pub fn content_bounds(s: &Surface) -> Rect { - if s.tile_count() == 0 { - return Rect::EMPTY; - } - let fmt = s.format(); - let mut dp = vec![0u8; fmt.bytes_per_pixel()]; - photocraft_raster::encode_pixel(&fmt, &s.default_pixel(), &mut dp); - let mut c = cache().lock().unwrap_or_else(|e| e.into_inner()); - if c.len() > 1 << 16 { - c.retain(|_, e| e.tile.strong_count() > 0); - } - let mut out = Rect::EMPTY; - for (coord, t) in s.tiles() { - let key = Arc::as_ptr(t) as usize; - let hit = c.get(&key).filter(|e| e.tile.upgrade().is_some_and(|u| Arc::ptr_eq(&u, t)) && *e.default == *dp).map(|e| e.bounds); - let b = match hit { - Some(b) => b, - None => { - let b = scan(t, &dp); - c.insert(key, Entry { tile: Arc::downgrade(t), default: dp.clone().into_boxed_slice(), bounds: b }); - b - } - }; - if let Some((x0, y0, x1, y1)) = b { - let o = coord.rect(); - let r = Rect::new(o.x0 + x0 as i32, o.y0 + y0 as i32, o.x0 + x1 as i32, o.y0 + y1 as i32); - out = if out.is_empty() { r } else { out.union(&r) }; - } - } - out -} - -/// Bounds of a layer's own pixels (union over visible group children; the canvas for fill -/// layers): `photocraft_compose::layer_bounds`. +/// Bounds of a layer's own pixels: `photocraft_compose::layer_bounds`. pub fn layer_bounds(layer: &Layer, canvas: Rect) -> Rect { - match &layer.content { - LayerContent::Group(g) => g.children.iter().filter(|c| c.visible).fold(Rect::EMPTY, |acc, c| { - let b = layer_bounds(c, canvas); - if b.is_empty() { - acc - } else if acc.is_empty() { - b - } else { - acc.union(&b) - } - }), - LayerContent::Fill(_) => canvas, - _ => layer.surface().map_or(Rect::EMPTY, content_bounds), - } + photocraft_compose::layer_bounds(layer, canvas) } /// The region a layer's effect maps cover: its bounds grown by the effect reach, within the @@ -96,15 +21,9 @@ pub fn effect_region(layer: &Layer, canvas: Rect) -> Rect { layer_bounds(layer, canvas).inflate(m).intersect(&canvas.inflate(m)) } -/// Whether the layer's content is transparent outside its bounds (every surface it draws from -/// has a transparent default pixel), so its effects can't change pixels outside the effect region. +/// `photocraft_compose::transparent_outside`. pub fn transparent_outside(layer: &Layer) -> bool { - match &layer.content { - LayerContent::Group(g) => g.children.iter().filter(|c| c.visible).all(transparent_outside), - // Fill layers cover the canvas; their region contains it. - LayerContent::Fill(_) | LayerContent::Adjustment(_) => true, - _ => layer.surface().is_none_or(|s| s.format().alpha && s.default_pixel().last().is_some_and(|a| *a <= 0.0)), - } + photocraft_compose::transparent_outside(layer) } #[cfg(test)] diff --git a/crates/gpu/src/compose.wgsl b/crates/gpu/src/compose.wgsl index a0731620f6..d7691c4352 100644 --- a/crates/gpu/src/compose.wgsl +++ b/crates/gpu/src/compose.wgsl @@ -45,9 +45,10 @@ const F_REL: u32 = 512u; // effect paint: coverage relative to the layer const F_STROKE_OUT: u32 = 1024u; // effect paint: outside stroke band const F_FIRST: u32 = 2048u; // outside strokes: nothing accumulated yet const F_CHANNELS: u32 = 4096u; // lerp: per-channel weights in p0 (channel restrictions) +const F_LAB: u32 = 65536u; // Lab document: Normal mixes in CIELAB +const F_QUANT: u32 = 32768u; // lerp: A rounded to p0.x steps (adjustment results, integer docs) const F_ADD_DIFF: u32 = 16384u; // lerp: A + (B - C) premultiplied (clips on pass-through groups) -const F_TEXT_GAMMA: u32 = 8192u; // blend / atop / fx merge: type layer, mix coverage at gamma 1.45 -const TEXT_GAMMA: f32 = 1.45; +const F_TEXT_GAMMA: u32 = 8192u; // blend / atop / fx merge: type layer, mix coverage at gamma p4.w @group(0) @binding(0) var chunk: Chunk; @group(0) @binding(1) var op: Op; @@ -226,6 +227,12 @@ fn composite(mode: i32, b: vec4, s: vec4, opacity: f32) -> vec4 { let ab = b.a; let as_ = s.a * opacity; if (as_ <= 0.0) { return b; } + if ((op.flags & F_LAB) != 0u && mode == M_NORMAL && ab > 0.0) { + // psblend::composite on Lab documents: Normal mixes in CIELAB. + let ao = as_ + ab * (1.0 - as_); + let m = srgb_to_lab(b.rgb) * (ab * (1.0 - as_) / ao) + srgb_to_lab(s.rgb) * (as_ / ao); + return vec4(lab_to_srgb(m), ao); + } let bl = blend_rgb(mode, b.rgb, s.rgb); let ao = as_ + ab * (1.0 - as_); if (ao <= 0.0) { return vec4(0.0); } @@ -242,11 +249,42 @@ fn composite_g(mode: i32, b: vec4, s: vec4, opacity: f32, gamma_on: bo let bl = blend_rgb(mode, b.rgb, s.rgb); let ao = as_ + ab * (1.0 - as_); if (ao <= 0.0) { return vec4(0.0); } - let g = TEXT_GAMMA; + let g = op.p4.w; // psblend::text_gamma let pw = (1.0 - as_) * ab * pow(max(b.rgb, vec3(0.0)), vec3(g)) + (1.0 - ab) * as_ * pow(max(s.rgb, vec3(0.0)), vec3(g)) + as_ * ab * pow(max(bl, vec3(0.0)), vec3(g)); return vec4(pow(pw / ao, vec3(1.0 / g)), ao); } +// photocraft_color::convert::{srgb_to_lab, lab_to_srgb} (D50, Bradford to sRGB). +const D50: vec3 = vec3(0.96422, 1.0, 0.82521); +fn lab_f(t: f32) -> f32 { + if (t > 0.008856452) { return pow(t, 1.0 / 3.0); } // (6/29)^3 + return t / 0.12841855 + 0.13793103; // 3 (6/29)^2, 4/29 +} +fn lab_finv(t: f32) -> f32 { + if (t > 0.20689656) { return t * t * t; } // 6/29 + return 0.12841855 * (t - 0.13793103); +} +fn srgb_to_lab(c: vec3) -> vec3 { + let lin = vec3(srgb_to_linear(c.r), srgb_to_linear(c.g), srgb_to_linear(c.b)); + let x = (0.436074 * lin.r + 0.385064 * lin.g + 0.143080 * lin.b) / D50.x; + let y = (0.222504 * lin.r + 0.716878 * lin.g + 0.060618 * lin.b) / D50.y; + let z = (0.013932 * lin.r + 0.097104 * lin.g + 0.714173 * lin.b) / D50.z; + let fx = lab_f(x); + let fy = lab_f(y); + let fz = lab_f(z); + return vec3(116.0 * fy - 16.0, 500.0 * (fx - fy), 200.0 * (fy - fz)); +} +fn lab_to_srgb(lab: vec3) -> vec3 { + let fy = (lab.x + 16.0) / 116.0; + let fx = fy + lab.y / 500.0; + let fz = fy - lab.z / 200.0; + let xyz = vec3(lab_finv(fx) * D50.x, lab_finv(fy) * D50.y, lab_finv(fz) * D50.z); + let r = 3.133856 * xyz.x - 1.616867 * xyz.y - 0.490615 * xyz.z; + let g = -0.978768 * xyz.x + 1.916142 * xyz.y + 0.033454 * xyz.z; + let b = 0.071945 * xyz.x - 0.228991 * xyz.y + 1.405243 * xyz.z; + return vec3(linear_to_srgb(clamp(r, 0.0, 1.0)), linear_to_srgb(clamp(g, 0.0, 1.0)), linear_to_srgb(clamp(b, 0.0, 1.0))); +} + fn dissolve_noise(d: vec2) -> f32 { var h = (bitcast(d.x) * 0x8da6b343u) ^ (bitcast(d.y) * 0xd8163841u) ^ 0x9e3779b9u; h = h ^ (h >> 15u); @@ -513,13 +551,15 @@ fn gradient_t(d: vec2) -> f32 { let along = dx * c - dy * s; let across = dx * s + dy * c; let len = max(sqrt((c * w) * (c * w) + (s * h) * (s * h)), 1.0) * max(op.p0.y, 1e-3); + // effects::gradient_t: Linear / Reflected span the bounds' chord along the angle. + let chord = max(min(w / max(abs(c), 1e-6), h / max(abs(s), 1e-6)), 1.0) * max(op.p0.y, 1e-3); var t: f32; switch i32(op.p0.w) { case 1: { t = sqrt(dx * dx + dy * dy) / (len / 2.0); } // Radial case 2: { t = rem_euclid((a - atan2(-dy, dx)) / 6.28318530718, 1.0); } // Angle - case 3: { t = abs(along / (len / 2.0)); } // Reflected + case 3: { t = abs(along / (chord / 2.0)); } // Reflected case 4: { t = (abs(along) + abs(across)) / (len / 2.0); } // Diamond - default: { t = along / len + 0.5; } // Linear + default: { t = along / chord + 0.5; } // Linear } t = clamp(t, 0.0, 1.0); if (op.p0.z > 0.5) { t = 1.0 - t; } @@ -613,6 +653,9 @@ fn fs_lerp(in: VOut) -> @location(0) vec4 { let p = local(in.pos); let a = textureLoad(tex_a, p, 0); let b = textureLoad(tex_b, p, 0); + if ((op.flags & F_QUANT) != 0u) { + return floor(a * op.p0.x + 0.5) / op.p0.x; + } if ((op.flags & F_CHANNELS) != 0u) { return a + (b - a) * op.p0; } @@ -827,12 +870,14 @@ fn fs_mshift(in: VOut) -> @location(0) vec4 { return mout(v); } -// effects::dilate: max(A, clamp(r + 0.5 - dist_outside)), B = distances, p0.x = r. +// effects::dilate: inside (distance < 0) min(A + r, 1), else max(A, clamp(r + 0.5 - dist_outside)); +// B = distances, p0.x = r. @fragment fn fs_mdilate(in: VOut) -> @location(0) vec4 { let p = local(in.pos); let a = textureLoad(tex_a, p, 0).r; let d = textureLoad(tex_b, p, 0).r; + if (d < 0.0) { return mout(min(a + op.p0.x, 1.0)); } return mout(max(a, clamp(op.p0.x + 0.5 - d, 0.0, 1.0))); } @@ -922,7 +967,7 @@ fn fs_mbevelshade(in: VOut) -> @location(0) vec4 { var region = s; if (op.p1.y > 0.5) { // Outside parts paint at full strength wherever the shape isn't opaque (edge pixels too). - region = select(0.0, 1.0, s < 1.0 - INSIDE_EPS && textureLoad(tex_a, p, 0).r > 0.0); + region = select(0.0, 1.0, s < 1.0 - INSIDE_EPS && textureLoad(tex_a, p, 0).r > 1e-5); // effects::BEVEL_H_EPS } let k = shade - se; var v = 0.0; @@ -935,6 +980,17 @@ fn fs_mbevelshade(in: VOut) -> @location(0) vec4 { return mout(v); } +// Bevel texture (`effects::bevel_height`): A + k × luminance of the pattern (× its alpha; 1 − +// that when inverted); p0 = (k, invert), placement in p3 / p4 as for pattern paints. +@fragment +fn fs_mbeveltex(in: VOut) -> @location(0) vec4 { + let p = local(in.pos); + let c = pattern_sample(doc_px(p)); + var l = (0.299 * c.r + 0.587 * c.g + 0.114 * c.b) * c.a; + if (op.p0.y > 0.5) { l = 1.0 - l; } + return mout(textureLoad(tex_a, p, 0).r + op.p0.x * l); +} + // Stroke band from a distance map: clamp(width + 0.5 - d), p0.x = width. @fragment fn fs_mstroke(in: VOut) -> @location(0) vec4 { diff --git a/crates/gpu/src/fx.rs b/crates/gpu/src/fx.rs index 578f71a131..d0993e4d70 100644 --- a/crates/gpu/src/fx.rs +++ b/crates/gpu/src/fx.rs @@ -25,7 +25,7 @@ use std::sync::Arc; use photocraft_compose::effects::FieldKind; use photocraft_compose::effects::BevelPaint; -use photocraft_doc::{BevelTechnique, Contour, Effect, GlobalLight, GlowSource, GlowTechnique, Layer, LayerContent}; +use photocraft_doc::{BevelTechnique, Contour, Pattern, Effect, GlobalLight, GlowSource, GlowTechnique, Layer, LayerContent}; use photocraft_geom::{Rect, TileCoord}; use photocraft_raster::{Surface, Tile}; @@ -53,6 +53,11 @@ pub(crate) struct Stage { pub lut: Option>>, pub p0: [f32; 4], pub p1: [f32; 4], + /// Pattern placement (`p3`: origin, rotation) and `p4` (inverse scale, tile size) for stages + /// that sample `pattern` (bevel texture). + pub p3: [f32; 4], + pub p4: [f32; 4], + pub pattern: Option, /// How far (px) the stage reads from its inputs around the output pixel. pub radius: i32, /// Final map index this stage writes (else a temporary). @@ -164,7 +169,7 @@ struct B { } fn stage(kernel: Kernel, a: Option, b: Option, p0: [f32; 4], radius: i32) -> Stage { - Stage { kernel, a, b, s: None, lut: None, p0, p1: [0.0; 4], radius, out: None } + Stage { kernel, a, b, s: None, lut: None, p0, p1: [0.0; 4], p3: [0.0; 4], p4: [0.0; 4], pattern: None, radius, out: None } } impl B { @@ -250,8 +255,15 @@ fn offset(angle: f32, distance: f32) -> (f32, f32) { ((-a.cos() * distance).round(), (a.sin() * distance).round()) } -/// The map program of one enabled effect (`build_maps`). +/// The map program of one enabled effect (`build_maps`), without pattern sources. +#[cfg(test)] pub(crate) fn program(e: &Effect, light: &GlobalLight, vector_shape: bool) -> MapProgram { + program_with(e, light, vector_shape, &[], (0.0, 0.0)) +} + +/// The map program of one enabled effect (`build_maps`); bevel textures tile `patterns` from +/// `anchor` (`effects::TextureCtx`). +pub(crate) fn program_with(e: &Effect, light: &GlobalLight, vector_shape: bool, patterns: &[Pattern], anchor: (f64, f64)) -> MapProgram { let mut b = B { stages: Vec::new(), fields: Vec::new() }; let maps = match e { Effect::DropShadow(s) | Effect::InnerShadow(s) => { @@ -260,7 +272,7 @@ pub(crate) fn program(e: &Effect, light: &GlobalLight, vector_shape: bool) -> Ma let angle = if s.use_global_light { light.angle } else { s.angle }; let (dx, dy) = offset(angle, s.distance); let src = b.shift(In::Shape, dx, dy, if inner { 1.0 } else { 0.0 }, inner); - let r = s.size * s.spread; + let (r, bw) = photocraft_compose::effects::spread_split(s.size, s.spread); let mut m = src; if r > 0.0 { // dist_outside of the shifted map is the shifted field (integer offsets; shifted-in @@ -269,7 +281,7 @@ pub(crate) fn program(e: &Effect, light: &GlobalLight, vector_shape: bool) -> Ma let d = if dx == 0.0 && dy == 0.0 { f } else { b.push(stage(Kernel::MShift, Some(f), None, [dx, dy, if inner { -0.5 } else { 1e10 }, 0.0], dx.abs().max(dy.abs()) as i32)) }; m = b.dilate(src, d, r); } - let m = b.blur(m, s.size * (1.0 - s.spread)); + let m = b.blur(m, bw); b.finish(m, None, false, &s.contour, inner, 0); 1 } @@ -289,13 +301,13 @@ pub(crate) fn program(e: &Effect, light: &GlobalLight, vector_shape: bool) -> Ma GlowTechnique::Softer => { // Inner glows (edge, and centre as 1 - the edge result) spread 1 - alpha. let src = if inner { b.shift(In::Shape, 0.0, 0.0, 0.0, true) } else { In::Shape }; - let r = g.size * g.spread; + let (r, bw) = photocraft_compose::effects::spread_split(g.size, g.spread); let mut m = src; if r > 0.0 { let d = b.field(if inner { FieldKind::OutsideInverse } else { FieldKind::Outside }, r); m = b.dilate(src, d, r); } - let m = b.blur(m, g.size * (1.0 - g.spread)); + let m = b.blur(m, bw); b.finish_lut(m, None, center, photocraft_compose::effects::glow_lut(g), inner, 0); } } @@ -336,6 +348,19 @@ pub(crate) fn program(e: &Effect, light: &GlobalLight, vector_shape: bool) -> Ma st.lut = Some(Arc::new(lut)); h = b.push(st); } + if let Some(t) = &bv.texture + && let Some(pat) = photocraft_doc::pattern::find(patterns, &t.id, &t.name).filter(|p| !p.is_empty()) + { + // Texture element (`effects::bevel_height`): luminance × depth / unit added. + let unit = if bv.depth.abs() > 1e-6 { (g.depth / bv.depth).abs().max(1e-3) } else { g.width.max(1.0) }; + let pl = photocraft_compose::pattern::Placement::anchored(anchor, t.link, t.phase, t.scale, 0.0); + let (origin, cs, inv) = pl.parts(); + let mut st = stage(Kernel::MBevelTex, Some(h), None, [t.depth / unit, f32::from(u8::from(t.invert)), 0.0, 0.0], 0); + st.p3 = [origin.0 as f32, origin.1 as f32, cs.0 as f32, cs.1 as f32]; + st.p4 = [inv as f32, pat.width as f32, pat.height as f32, 0.0]; + st.pattern = Some(pat.clone()); + h = b.push(st); + } if bv.soften >= 1.0 { h = b.conv(h, photocraft_compose::effects::tent_kernel(bv.soften)); } @@ -384,9 +409,15 @@ pub(crate) fn program(e: &Effect, light: &GlobalLight, vector_shape: bool) -> Ma let mut h = std::collections::hash_map::DefaultHasher::new(); for s in &b.stages { (format!("{:?}", s.kernel), s.a, s.b, s.s, s.radius, s.out).hash(&mut h); - for v in s.p0.iter().chain(&s.p1) { + for v in s.p0.iter().chain(&s.p1).chain(&s.p3).chain(&s.p4) { v.to_bits().hash(&mut h); } + if let Some(p) = &s.pattern { + (&p.id, &p.name, p.width, p.height).hash(&mut h); + for (c, t) in p.surface.tiles() { + (c.tx, c.ty, Arc::as_ptr(t) as usize).hash(&mut h); + } + } if let Some(l) = &s.lut { for v in l.iter() { v.to_bits().hash(&mut h); diff --git a/crates/gpu/src/lib.rs b/crates/gpu/src/lib.rs index 6abdfc503a..a4ac02f62a 100644 --- a/crates/gpu/src/lib.rs +++ b/crates/gpu/src/lib.rs @@ -20,8 +20,8 @@ //! Vector masks (rasterised once per mask state into a combined mask texture), layers clipped to //! pass-through groups, stroked shapes with clipped layers (fill and stroke split once per shape //! state), pattern fills and artboards are planned like everything else. What remains -//! (Multichannel documents, bevels with a texture, documents or effect regions larger than the -//! device's texture limit) returns [`Unsupported`]; callers fall back to the CPU compositor. +//! (Multichannel documents, documents or effect regions larger than the device's texture limit) +//! returns [`Unsupported`]; callers fall back to the CPU compositor. #![forbid(unsafe_code)] pub mod bounds; @@ -397,7 +397,7 @@ impl Compositor { return Err(Unsupported(format!("effect region of `{}` larger than the GPU texture limit ({})", f.layer.name, self.max_dim))); } for e in f.layer.effects.items.iter().filter(|e| e.enabled()) { - for s in fx::program(e, &doc.global_light, false).stages { + for s in fx::program_with(e, &doc.global_light, false, &doc.patterns, (0.0, 0.0)).stages { if s.lut.as_ref().is_some_and(|l| l.len() > 4096) { return Err(Unsupported(format!("effect blur on `{}` too wide for the GPU path", f.layer.name))); } @@ -804,7 +804,8 @@ impl Compositor { // Programs, and the distance fields they read (max reach per field). let vector_shape = matches!(layer.content, LayerContent::Shape(_)); - let progs: Vec = layer.effects.items.iter().filter(|e| e.enabled()).map(|e| fx::program(e, &doc.global_light, vector_shape)).collect(); + let anchor = layer.effects.reference.unwrap_or((f64::from(f.bounds.x0), f64::from(f.bounds.y0))); + let progs: Vec = layer.effects.items.iter().filter(|e| e.enabled()).map(|e| fx::program_with(e, &doc.global_light, vector_shape, &doc.patterns, anchor)).collect(); let mut want: HashMap = HashMap::new(); for (k, r) in progs.iter().flat_map(|p| p.fields.iter()) { let w = want.entry(*k).or_insert(0); @@ -859,6 +860,7 @@ impl Compositor { /// Record the passes of `prog` (maps of item `item` of `layer`) recomputing damage `d`. #[allow(clippy::too_many_arguments)] fn run_program(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, encoder: &mut wgpu::CommandEncoder, layer: LayerId, item: usize, prog: &fx::MapProgram, d: Rect, stats: &mut Stats) { + let pattern_views: Vec> = prog.stages.iter().map(|s| s.pattern.as_ref().map(|p| self.pattern_view(device, queue, p))).collect(); let e = &self.fx[&layer]; let region = e.region; let shape = e.shape.view.clone(); @@ -895,6 +897,8 @@ impl Compositor { let mut p = plan::Pass::new(s.kernel, 0); p.params[0] = s.p0; p.params[1] = s.p1; + p.params[3] = s.p3; + p.extra = s.p4; draws.push(MapDraw { kernel: s.kernel, format, @@ -902,7 +906,7 @@ impl Compositor { scissor: [(w.x0 - region.x0) as u32, (w.y0 - region.y0) as u32, w.width(), w.height()], space: [region.x0, region.y0, region.width() as i32, region.height() as i32], op: op_words(&p, None, None, None), - views: [view_of(s.a), view_of(s.b), view_of(s.s), None, None, None, None, None], + views: [view_of(s.a), view_of(s.b), view_of(s.s), None, None, None, None, pattern_views[i].clone()], lut: s.lut.clone(), }); } diff --git a/crates/gpu/src/plan.rs b/crates/gpu/src/plan.rs index e026706792..d5bae07467 100644 --- a/crates/gpu/src/plan.rs +++ b/crates/gpu/src/plan.rs @@ -60,6 +60,7 @@ pub enum Kernel { MBevelH, MBevelShade, MStroke, + MBevelTex, } impl Kernel { @@ -87,6 +88,7 @@ impl Kernel { Kernel::MBevelH => "fs_mbevelh", Kernel::MBevelShade => "fs_mbevelshade", Kernel::MStroke => "fs_mstroke", + Kernel::MBevelTex => "fs_mbeveltex", }) } @@ -102,11 +104,12 @@ impl Kernel { | Kernel::MBevelH | Kernel::MBevelShade | Kernel::MStroke + | Kernel::MBevelTex ) } /// Every kernel with a pipeline. - pub const DRAWN: [Kernel; 20] = [ + pub const DRAWN: [Kernel; 21] = [ Kernel::Content, Kernel::Mask, Kernel::Blend, @@ -127,6 +130,7 @@ impl Kernel { Kernel::MBevelH, Kernel::MBevelShade, Kernel::MStroke, + Kernel::MBevelTex, ]; } @@ -283,11 +287,13 @@ pub struct DocCtx<'a> { pub patterns: &'a [Pattern], /// Colour mode (channel restrictions name its channels). pub mode: photocraft_color::ColorMode, + /// Sample depth (adjustment results are rounded to it). + pub depth: photocraft_color::SampleType, } impl<'a> DocCtx<'a> { pub fn of(doc: &'a Document) -> Self { - DocCtx { canvas: doc.bounds(), transfer: Transfer::for_mode(doc.mode), light: doc.global_light, patterns: &doc.patterns, mode: doc.mode } + DocCtx { canvas: doc.bounds(), transfer: Transfer::for_mode(doc.mode), light: doc.global_light, patterns: &doc.patterns, mode: doc.mode, depth: doc.depth } } } @@ -335,11 +341,16 @@ pub const F_STROKE_OUT: u32 = 1024; pub const F_FIRST: u32 = 2048; /// `Lerp` per channel: weights in `p0` (channel restrictions), no opacity or mask. pub const F_CHANNELS: u32 = 4096; +/// Lab document: Normal blending mixes in CIELAB (`psblend::LAB_MIX`). +pub const F_LAB: u32 = 65536; +/// `Lerp`: A rounded to `p0.x` steps per unit (adjustment results on integer documents). +pub const F_QUANT: u32 = 32768; /// `Lerp` as A + (B − C) premultiplied (layers clipped to pass-through groups). pub const F_ADD_DIFF: u32 = 16384; /// Blend / Atop / FxMerge of a type layer: coverage mixed at `psblend::TEXT_GAMMA`. pub const F_TEXT_GAMMA: u32 = 8192; +/// `F_TEXT_GAMMA` for type layers while text gamma blending is on; the gamma goes in `p4.w`. fn gamma_flag(layer: &Layer) -> u32 { if photocraft_compose::text_gamma(layer) != 1.0 { F_TEXT_GAMMA } else { 0 } } @@ -383,6 +394,9 @@ impl<'a> Planner<'a> { fn emit(&mut self, mut pass: Pass<'a>) -> Slot { let dst = self.alloc(); pass.dst = dst; + if self.cx.mode == photocraft_color::ColorMode::Lab { + pass.flags |= F_LAB; + } let (a, b, c, d) = (pass.a, pass.b, pass.c, pass.d); self.passes.push(pass); for s in [a, b, c, d].into_iter().flatten() { @@ -406,6 +420,14 @@ impl<'a> Planner<'a> { let clipped = &layers[i + 1..j]; if base.visible { backdrop = self.layer(base, clipped, backdrop)?; + if let (LayerContent::Adjustment(_), Some(q)) = (&base.content, photocraft_compose::adjustment_quantum(self.cx.depth)) { + // compose: adjustment results are rounded to the document's depth. + let mut p = Pass::new(Kernel::Lerp, 0); + p.a = Some(backdrop); + p.flags = F_QUANT; + p.params[0] = [q, 0.0, 0.0, 0.0]; + backdrop = self.emit(p); + } } i = j.max(i + 1); } @@ -601,6 +623,7 @@ impl<'a> Planner<'a> { p.mode = layer.blend; p.opacity = opacity; p.flags = gamma_flag(layer); + p.extra[3] = photocraft_compose::text_gamma(layer); Ok(self.emit(p)) } @@ -738,6 +761,7 @@ impl<'a> Planner<'a> { p.mode = layer.blend; p.opacity = opacity; p.flags = gamma_flag(layer); + p.extra[3] = photocraft_compose::text_gamma(layer); Ok(self.emit(p)) } @@ -756,12 +780,9 @@ impl<'a> Planner<'a> { /// (atop = true: effects over the base treated as opaque, keeping the base's alpha). /// Consumes `backdrop`. fn effects(&mut self, layer: &'a Layer, clipped: &[&'a Layer], backdrop: Slot, atop: bool) -> Result { - if layer.effects.items.iter().any(|e| matches!(e, Effect::BevelEmboss(b) if b.enabled && b.texture.is_some())) { - return Err(Unsupported(format!("bevel texture on `{}` (rendered on the CPU)", layer.name))); - } let canvas = self.cx.canvas; let region = bounds::effect_region(layer, canvas); - let sb = bounds::layer_bounds(layer, canvas); + let sb = photocraft_compose::paint_bounds(layer).unwrap_or_else(|| bounds::layer_bounds(layer, canvas)); let clip = if bounds::transparent_outside(layer) { region } else { canvas }; let mut content = self.content(layer)?; if !matches!(layer.content, LayerContent::Group(_)) @@ -925,6 +946,7 @@ impl<'a> Planner<'a> { p.mode = if layer.blend == BlendMode::PassThrough { BlendMode::Normal } else { layer.blend }; p.opacity = layer.opacity; p.flags = if atop { F_ATOP } else { 0 } | gamma_flag(layer); + p.extra[3] = photocraft_compose::text_gamma(layer); p.clip = Some(clip); let merged = self.emit(p); self.release(content); diff --git a/crates/gpu/tests/parity.rs b/crates/gpu/tests/parity.rs index 897781edbe..750d0e0b8d 100644 --- a/crates/gpu/tests/parity.rs +++ b/crates/gpu/tests/parity.rs @@ -159,6 +159,14 @@ fn lookup(n: usize, tetrahedral: bool, dither: bool) -> Adjustment { #[test] fn adjustment_layers() { let Some(mut g) = gpu() else { return }; + // 16-bit and float documents (adjustment results round to 1/32768 resp. not at all). + for depth in [SampleType::U16, SampleType::F32] { + let mut d = Document::new("t", Size::new(40, 30), ColorMode::Rgb, depth); + let fmt = d.pixel_format(); + d.layers.push(noise_layer("bg", fmt, Rect::from_xywh(0, 0, 40, 30), 71, 0.5)); + d.layers.push(Layer::new("ex", LayerContent::Adjustment(Adjustment::Exposure { exposure: 0.4, offset: 0.01, gamma: 1.1 }))); + check(&mut g, &d, &format!("adjustment {depth:?}")); + } for adj in adjustments() { for (mode, opacity, masked) in [(BlendMode::Normal, 1.0, false), (BlendMode::Multiply, 0.7, true)] { let mut d = base_doc(48, 40); @@ -464,6 +472,10 @@ fn effect_cases() -> Vec<(&'static str, Vec)> { ("bevel pillow chisel hard", vec![Effect::BevelEmboss(Bevel { technique: BevelTechnique::ChiselHard, ..bevel(BevelStyle::PillowEmboss, false, 7.0, 0.0) })]), ("bevel emboss smooth wide", vec![Effect::BevelEmboss(bevel(BevelStyle::Emboss, true, 21.0, 0.0))]), ("bevel stroke emboss", vec![Effect::BevelEmboss(bevel(BevelStyle::StrokeEmboss, true, 6.0, 0.0))]), + ("bevel texture", vec![Effect::BevelEmboss(Bevel { + texture: Some(photocraft_doc::BevelTexture { name: "checker".into(), id: String::new(), scale: 1.4, depth: -1.5, invert: true, link: true, phase: (2.0, 1.0) }), + ..bevel(BevelStyle::InnerBevel, true, 7.0, 1.0) + })]), ("bevel contour", vec![Effect::BevelEmboss(Bevel { contour: Some(photocraft_doc::BevelContour { contour: contour(), range: 0.6, anti_alias: false }), ..bevel(BevelStyle::Emboss, true, 9.0, 1.0) })]), ("bevel contour own light", vec![Effect::BevelEmboss(bevel_contour)]), ("satin", vec![Effect::Satin(satin)]), @@ -775,6 +787,12 @@ fn type_layers_blend_with_text_gamma() { c.blend = mode; d.layers.push(c); check(&mut g, &d, &format!("text {mode:?}")); + // Another gamma (Color Settings), and off. + for gamma in [1.8, 1.0] { + photocraft_compose::psblend::set_text_gamma(gamma); + check(&mut g, &d, &format!("text {mode:?} gamma {gamma}")); + } + photocraft_compose::psblend::set_text_gamma(photocraft_compose::psblend::TEXT_GAMMA); } // With effects (the merge of the layer onto its exterior effects). let mut d = fx_doc(96, 80, SampleType::U8); @@ -870,7 +888,7 @@ fn artboards() { let mut ab = Layer::group("Artboard", vec![child, fx]); ab.blend = blend; if let LayerContent::Group(gr) = &mut ab.content { - gr.artboard = Some(Artboard { rect: Rect::new(12, 6, 60, 40), background: bg.clone(), preset: String::new() }); + gr.artboard = Some(Artboard { rect: Rect::new(12, 6, 60, 40), background: bg, preset: String::new() }); } d.layers.push(ab); // A second, partly off-canvas board. @@ -913,3 +931,33 @@ fn pattern_fill_layers() { } } + +#[test] +fn lab_documents_mix_in_lab() { + let Some(mut g) = gpu() else { return }; + for depth in [SampleType::U8, SampleType::U16] { + let mut d = Document::new("lab", Size::new(48, 40), ColorMode::Lab, depth); + let fmt = d.pixel_format(); + d.layers.push(noise_layer("bg", fmt, Rect::new(0, 0, 48, 40), 81, 0.7)); + let mut top = noise_layer("top", fmt, Rect::new(4, 4, 44, 36), 82, 0.0); + top.opacity = 0.8; + d.layers.push(top); + let mut m = noise_layer("mul", fmt, Rect::new(10, 2, 30, 38), 83, 0.3); + m.blend = BlendMode::Multiply; + d.layers.push(m); + let mut fx = blob("fx", fmt, 24.0, 20.0, 12.0, [0.7, 0.3, 0.2]); + fx.effects.items = vec![Effect::DropShadow(shadow(BlendMode::Normal, 0.6, 120.0, 4.0, 5.0, 0.0))]; + d.layers.push(fx); + fx_check(&mut g, &d, &format!("lab {depth:?}")); + } + // The mix really is in Lab: a half-transparent edge differs from an sRGB mix. + let mut d = Document::new("lab", Size::new(2, 1), ColorMode::Lab, SampleType::U8); + let fmt = d.pixel_format(); + let mut a = Layer::raster("a", fmt); + a.surface_mut().unwrap().fill_rect(Rect::new(0, 0, 2, 1), &photocraft_raster::from_rgba(&fmt, [0.0, 0.0, 1.0, 1.0])); + let mut b = Layer::raster("b", fmt); + b.surface_mut().unwrap().fill_rect(Rect::new(0, 0, 2, 1), &photocraft_raster::from_rgba(&fmt, [1.0, 1.0, 0.0, 0.5])); + d.layers = vec![a, b]; + let p = photocraft_compose::flatten(&d).px[0]; + assert!((p[0] - 0.5).abs() > 0.05 || (p[2] - 0.5).abs() > 0.05, "{p:?}"); +} diff --git a/crates/io/examples/oracle_diff.rs b/crates/io/examples/oracle_diff.rs index 961d3650ce..479f8db45d 100644 --- a/crates/io/examples/oracle_diff.rs +++ b/crates/io/examples/oracle_diff.rs @@ -287,7 +287,8 @@ fn corpus_summary(root: &std::path::Path) { collect(root, &mut files); files.sort(); const TOL: f32 = 2.0 / 255.0; - let row = |p: &std::path::PathBuf| -> (String, Option<(f32, f32)>) { + type Row = (String, Option<(f32, f32)>); + let row = |p: &std::path::PathBuf| -> Row { let name = p.strip_prefix(root).unwrap_or(p).display().to_string(); let Ok(bytes) = std::fs::read(p) else { return (name, None) }; let Ok(file) = photocraft_psd::PsdFile::from_bytes(&bytes) else { return (name, None) }; @@ -310,7 +311,7 @@ fn corpus_summary(root: &std::path::Path) { }; // Files in parallel (a few threads; flatten itself is tile-parallel). let next = std::sync::atomic::AtomicUsize::new(0); - let mut rows: Vec<(usize, (String, Option<(f32, f32)>))> = std::thread::scope(|sc| { + let mut rows: Vec<(usize, Row)> = std::thread::scope(|sc| { let hs: Vec<_> = (0..4) .map(|_| { sc.spawn(|| { @@ -327,7 +328,7 @@ fn corpus_summary(root: &std::path::Path) { hs.into_iter().flat_map(|h| h.join().unwrap()).collect() }); rows.sort_by_key(|r| r.0); - let rows: Vec<(String, Option<(f32, f32)>)> = rows.into_iter().map(|r| r.1).collect(); + let rows: Vec = rows.into_iter().map(|r| r.1).collect(); let (mut pass, mut diff, mut skip) = (0, 0, 0); for (name, r) in &rows { match r { diff --git a/crates/io/src/blocks.rs b/crates/io/src/blocks.rs index 724aeb33ac..9d790d24fa 100644 --- a/crates/io/src/blocks.rs +++ b/crates/io/src/blocks.rs @@ -81,7 +81,9 @@ pub fn color_from_desc(d: &Descriptor) -> Option { let id = d.class_id.as_bytes(); let g = |k: &str| num(d.get(k)).map(|v| v as f32); Some(match id { - b"RGBC" => Color::rgb(g("Rd ")? / 255.0, g("Grn ")? / 255.0, g("Bl ").or_else(|| g("Bl "))? / 255.0), + // Newer Photoshop writes 0..1 floats (`RGBC` with redFloat / greenFloat / blueFloat). + b"RGBC" if d.get("redFloat").is_some() => Color::rgb(g("redFloat")?, g("greenFloat")?, g("blueFloat")?), + b"RGBC" => Color::rgb(g("Rd ")? / 255.0, g("Grn ")? / 255.0, g("Bl ")? / 255.0), b"CMYC" => Color { mode: ColorMode::Cmyk, c: [g("Cyn ")? / 100.0, g("Mgnt")? / 100.0, g("Ylw ")? / 100.0, g("Blck")? / 100.0], @@ -510,6 +512,13 @@ mod tests { mod more_tests { use super::*; + #[test] + fn float_rgb_colors_parse() { + let d = Descriptor::new("RGBC").with("redFloat", Value::Double(1.0)).with("greenFloat", Value::Double(0.5)).with("blueFloat", Value::Double(0.25)); + let c = color_from_desc(&d).unwrap(); + assert_eq!(c.to_rgb(), [1.0, 0.5, 0.25]); + } + #[test] fn smart_transform_from_sold() { let pts = [10.0, 20.0, 110.0, 20.0, 110.0, 70.0, 10.0, 70.0].map(Value::Double).to_vec(); diff --git a/crates/io/src/flat.rs b/crates/io/src/flat.rs index af781e1ae8..93ca736f7f 100644 --- a/crates/io/src/flat.rs +++ b/crates/io/src/flat.rs @@ -120,18 +120,38 @@ pub fn document_to_image(doc: &Document, warnings: &mut Vec) -> Result out.push((v.clamp(0.0, 1.0) * 255.0).round() as u8), + CSample::U16 => out.extend_from_slice(&((v.clamp(0.0, 1.0) * 65535.0).round() as u16).to_ne_bytes()), + CSample::F16 | CSample::F32 => out.extend_from_slice(&v.to_ne_bytes()), + } + }; + for p in &buf.px[range] { + if gray { + put(photocraft_color::convert::rgb_to_gray([p[0], p[1], p[2]])); + } else { + put(p[0]); + put(p[1]); + put(p[2]); + } + if !opaque { + put(p[3]); + } } + out + }); + let mut data = Vec::with_capacity(parts.iter().map(Vec::len).sum()); + for part in parts { + data.extend_from_slice(&part); } - Image::from_normalized(w, h, layout, csample(fmt.sample), &data)? + Image::from_raw(w, h, layout, cs, data)? }; let meta = codecs::Metadata { exif: doc.metadata.exif.as_ref().map(|e| e.to_vec()), diff --git a/crates/io/src/pixels.rs b/crates/io/src/pixels.rs index d8c5aa080e..408802f789 100644 --- a/crates/io/src/pixels.rs +++ b/crates/io/src/pixels.rs @@ -69,6 +69,13 @@ pub fn interleave(planes: &[Option<&[u8]>], fill: &[Vec], n: usize, s: Sampl pub fn deinterleave(bytes: &[u8], ch: usize, s: SampleType, invert: &[bool]) -> Vec> { let bps = s.bytes(); let n = bytes.len() / (ch * bps).max(1); + if s == SampleType::U8 { + // Fast path: one plane per thread, no per-sample copies. + return par_map((0..ch).collect(), |c| { + let it = bytes.iter().skip(c).step_by(ch).take(n); + if invert[c] { it.map(|v| 255 - v).collect() } else { it.copied().collect() } + }); + } let mut planes = vec![Vec::with_capacity(n * bps); ch]; let mut tmp = [0u8; 4]; for i in 0..n { @@ -136,6 +143,26 @@ pub fn unmatte(m: f32, a: f32, white: f32) -> f32 { if a <= 0.0 { white } else { ((m - white * (1.0 - a)) / a).clamp(0.0, 1.0) } } +/// `items.map(f)` on scoped threads (one per item; callers pass a handful of channels or +/// bands), in order; sequential on wasm or for a single item. +pub fn par_map(items: Vec, f: impl Fn(T) -> R + Sync) -> Vec { + if cfg!(target_arch = "wasm32") || items.len() < 2 { + return items.into_iter().map(f).collect(); + } + std::thread::scope(|sc| { + let f = &f; + let hs: Vec<_> = items.into_iter().map(|t| sc.spawn(move || f(t))).collect(); + hs.into_iter().map(|h| h.join().expect("worker panicked")).collect() + }) +} + +/// `0..n` split into about one band per core. +pub fn bands(n: usize) -> Vec> { + let k = if cfg!(target_arch = "wasm32") { 1 } else { std::thread::available_parallelism().map_or(1, |v| v.get()).clamp(1, 32) }; + let step = n.div_ceil(k).max(1); + (0..n).step_by(step).map(|a| a..(a + step).min(n)).collect() +} + #[cfg(test)] mod tests { use super::*; @@ -177,3 +204,4 @@ mod tests { assert_eq!(decode_be(&f, 0, SampleType::F32), 2.5); } } + diff --git a/crates/io/src/psd_export.rs b/crates/io/src/psd_export.rs index 4c36d2219a..f80dce6dc1 100644 --- a/crates/io/src/psd_export.rs +++ b/crates/io/src/psd_export.rs @@ -95,10 +95,9 @@ impl Ex { invert.push(false); let planes = deinterleave(&bytes, self.cc + 1, self.fmt.sample, &invert); let (w, h) = (r.width() as usize, r.height() as usize); - let mut ch = vec![self.encode(-1, &planes[self.cc], w, h)]; - for (c, plane) in planes.iter().take(self.cc).enumerate() { - ch.push(self.encode(c as i16, plane, w, h)); - } + // Alpha (-1) first, then the colour channels; each compressed on its own thread. + let order: Vec<(i16, &Vec)> = std::iter::once((-1, &planes[self.cc])).chain(planes.iter().take(self.cc).enumerate().map(|(c, p)| (c as i16, p))).collect(); + let ch = crate::pixels::par_map(order, |(id, plane)| self.encode(id, plane, w, h)); (to_psd_rect(r), ch) } @@ -559,15 +558,27 @@ pub fn document_to_psd_with(doc: &Document, opts: &PsdExportOptions) -> (PsdFile let comp = photocraft_compose::flatten(doc); let n = comp.px.len(); let has_alpha = comp.px.iter().any(|p| q255(p[3]) < 255 || (sample == SampleType::F32 && p[3] < 1.0)); - let mut color_planes: Vec> = vec![Vec::with_capacity(n * sample.bytes()); cc + 1]; let white = photocraft_raster::from_rgba(&fmt, [1.0, 1.0, 1.0, 1.0]); - for p in &comp.px { - let v = photocraft_raster::from_rgba(&fmt, *p); - for c in 0..=cc { - // Matte against white like Photoshop (see `pixels::matte`). - let m = if c < cc && has_alpha { crate::pixels::matte(v[c], v[cc], white[c]) } else { v[c] }; - let x = if ex.cmyk && c < cc { 1.0 - m } else { m }; - encode_be(x, sample, &mut color_planes[c]); + let cmyk = ex.cmyk; + // Converted and encoded in bands on all cores, then joined per plane. + let parts = crate::pixels::par_map(crate::pixels::bands(n), |range| { + let mut planes: Vec> = vec![Vec::with_capacity(range.len() * sample.bytes()); cc + 1]; + let mut v = [0.0f32; 5]; + for p in &comp.px[range] { + photocraft_raster::from_rgba_into(&fmt, *p, &mut v); + for c in 0..=cc { + // Matte against white like Photoshop (see `pixels::matte`). + let m = if c < cc && has_alpha { crate::pixels::matte(v[c], v[cc], white[c]) } else { v[c] }; + let x = if cmyk && c < cc { 1.0 - m } else { m }; + encode_be(x, sample, &mut planes[c]); + } + } + planes + }); + let mut color_planes: Vec> = vec![Vec::with_capacity(n * sample.bytes()); cc + 1]; + for part in parts { + for (dst, src) in color_planes.iter_mut().zip(part) { + dst.extend_from_slice(&src); } } let mut planes = Vec::new(); diff --git a/crates/ui-egui/examples/interactive_bench.rs b/crates/ui-egui/examples/interactive_bench.rs index 9dcc0c41ce..e4ffac60dc 100644 --- a/crates/ui-egui/examples/interactive_bench.rs +++ b/crates/ui-egui/examples/interactive_bench.rs @@ -268,6 +268,12 @@ fn main() { s2.open_document(d, None); ms(t) + b.refresh(&s2, true) }); + b.time("flatten (CPU compositor, 3 layers)", |_| { + let d = doc(&s); + let t = Instant::now(); + std::hint::black_box(photocraft_compose::flatten(&d)); + ms(t) + }); b.time("export PNG (flatten + encode)", |_| { let d = doc(&s); let t = Instant::now(); diff --git a/docs/development.md b/docs/development.md index 136f995b12..72769dd74b 100644 --- a/docs/development.md +++ b/docs/development.md @@ -169,7 +169,7 @@ the live command registry (`menus::is_live`) and rewrites [`docs/parity.md`](par ## Performance notes - The canvas is presented by a custom WGSL shader (`ui-egui/src/gpu_canvas.rs`): mip-mapped/nearest sampling, procedural checkerboard, pixel grid, tiling. Brush strokes upload only their damage rect. -- **The canvas composites on the GPU** (`photocraft-gpu`, driven from `gpu_canvas.rs`), layer effects included. What the planner can't express returns `Unsupported` and the canvas falls back to the CPU compositor (`photocraft-compose`, also the reference for export and tests): vector masks, layers clipped to pass-through groups, stroked shapes with clipped layers, pattern fills without Photoshop's cached pixels, artboards, and documents or effect regions over the texture limit. `ui.inspect` → `perf.timings.gpuFallback` names the reason (`null` on the GPU path). +- **The canvas composites on the GPU** (`photocraft-gpu`, driven from `gpu_canvas.rs`), layer effects included. What the planner can't express returns `Unsupported` and the canvas falls back to the CPU compositor (`photocraft-compose`, also the reference for export and tests): Multichannel documents, and documents or effect regions over the texture limit. Pieces the GPU can't derive itself are rasterised once on the CPU and cached (`compose::masks` for vector masks, `compose::shape_split` for stroked shapes with clipped layers, effect distance fields). Timings of the interactive paths: `cargo run --release -p photocraft-ui-egui --example interactive_bench`; effects: `--example fx_bench` (`--compare files…` for GPU vs CPU). Rendering fidelity: `cargo run --release -p photocraft-io --example oracle_diff -- corpus/psd` (the whole PSD oracle table in seconds). `ui.inspect` → `perf.timings.gpuFallback` names the reason (`null` on the GPU path). - **Layer effects on the GPU** (`gpu/src/fx.rs`, kernels in `gpu/src/compose.wgsl`). Every enabled effect becomes a *map program* over the layer's effect region (shift, dilate, Gaussian blur, glow ramp, bevel height and shading, contour, stroke band), mirroring `compose::effects` step by step; the chunked composite then paints through the maps, clipped to that region, and copies the result back into the backdrop in place, so a small text layer costs only its own pixels. The layer's shape (`compose::layer_shape`) and its distance fields (`compose::effects::distance_field`: a sequential transform whose tie-breaking a parallel GPU pass can't reproduce bit for bit) come from compose on the CPU, computed in parallel bands. Everything is cached per layer state: an unrelated edit, or an effect's colour or opacity, rebuilds nothing; a brush dab recomputes the touched 256² tiles grown by the effect reach; changing one effect's geometry rebuilds that effect only. Cache budget `gpu::FX_BUDGET` (1.5 GB, least recently drawn layers evicted first). `PHOTOCRAFT_FX_TRACE=1` prints the CPU time of each rebuild. - The canvas grows a stroke's damage rect by the effect reach of the layers around it (`canvas::effect_reach`), so effects beyond the dab refresh too (on both paths). - **Numbers** (7360 × 4912, 8 text layers + one painted layer with drop shadow + stroke + bevel, Hue/Saturation on top; M4 Pro; `cargo run --release -p photocraft-ui-egui --example fx_bench`), CPU fallback → GPU: full refresh with warm effect maps 5.7 s → 47 ms; Hue/Saturation tweak above the effects 4.7 s → 31 ms; brush dab on a plain layer 32 → 1.7 ms; brush dab on the effect layer (its maps rebuilt around the dab) 659 → 3.7 ms; first refresh (all maps built) 6.4 s → 0.39 s. With the CPU ~14× oversubscribed by parallel builds (min of 7 runs): 8.1 s → 0.33 s, 9.9 s → 0.28 s, 28 → 2.2 ms, 1.7 s → 89 ms; moving a text layer 7 px 336 → 13 ms. `fx_bench --compare corpus/psd/…/*.psd` reports the GPU vs CPU difference on real files (30 of the 31 corpus files with effects render on the GPU, worst 0.12/255). diff --git a/docs/roadmap.md b/docs/roadmap.md index bcca47709a..83df9519b5 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -13,7 +13,7 @@ composite oracle and the test count. | M2 PSD v1 | ✅ | photocraft-psd: 134/135 real files byte-exact round trip | | M3 Viewer app | ✅ | egui shell (Pro / Studio / Classic themes), 13+ codecs, native and web (trunk) builds | | M4 Native format + engine | ✅ | 500+ commands, `.pcraft` (incremental, autosave, crash recovery), CLI, persistent preferences | -| M5 GPU compositor | 🟡 | wgpu compositor drives the canvas, layer effects included (≤1/255 vs CPU); vector masks, uncached pattern fills, artboards and a few clip cases fall back to the CPU | +| M5 GPU compositor | 🟡 | wgpu compositor drives the canvas, layer effects, vector masks, artboards, pattern fills and every clip case included (≤1/255 vs CPU); Multichannel documents fall back to the CPU | | M6 Paint + select | 🟡 | brush engine, all selection tools, multi-layer selection, snapping + smart guides, free transform + warp; native tablet backends pending | | M7 Adjust + filters | 🟡 | 16 adjustment layers + destructive-only adjustments, 70+ filters incl. Blur Gallery, Actions record/replay, Fade | | M8 PSD v2 | 🟡 | adjustments (incl. Selective Color, Color Lookup), fills, effects, patterns, text, shapes, smart objects, alpha channels; oracle 111/170 | @@ -36,11 +36,10 @@ Landed on 2026-10-01: Next: 1. **First signed release**: push to `release`, verify notarization and the installers, and fix CI (`docs/releasing.md`). Windows code-signing material still needs to be obtained. -2. **Fidelity**: the PSD oracle (111/170). Bevel/emboss, satin, inner glow; modern - Brightness/Contrast and grayscale Levels curves; channel restrictions (`brst`); Lab-space - blending; Photoshop smart filters in `SoLd`. Also the GPU/CPU Color Burn edge case (51/255 at - backdrop 1, source 0). -3. **Remaining GPU fallbacks**: vector masks, layers clipped to pass-through groups, artboards. +2. **Fidelity**: the PSD oracle (113/170). Modern Brightness/Contrast and grayscale Levels + curves; chisel-soft / stroke-emboss bevel shapes; Photoshop's 8-bit blend rounding; non-Normal + modes in Lab documents; Photoshop smart filters in `SoLd`. +3. **GPU**: only Multichannel documents and regions over the texture limit fall back to the CPU. 4. **Vanishing Point, Camera Raw / Lens Correction, Face-Aware Liquify** (needs a landmark model). 5. **Panels**: Patterns, Styles, Glyphs, Character/Paragraph Styles, Timeline; Custom Shape tool. 6. Print, Photomerge, Merge to HDR, video layers.