From 6ebc0180da928646d683e244f147620cd8baba43 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 27 Oct 2026 23:47:06 +0000 Subject: [PATCH] Refactor gpu for strict Clippy checks --- crates/gpu/src/batch.rs | 2 +- crates/gpu/src/cells.rs | 2 +- crates/gpu/src/convert.rs | 2 +- crates/gpu/src/encode.rs | 2 +- crates/gpu/src/fx.rs | 171 ++++++++++----------- crates/gpu/src/fx_passes.rs | 2 +- crates/gpu/src/kit.rs | 2 +- crates/gpu/src/paging.rs | 2 +- crates/gpu/src/plan/lower.rs | 2 +- crates/gpu/src/plan/planner.rs | 271 +++++++++++++++++++++++++++------ crates/gpu/src/plan/types.rs | 2 +- crates/gpu/src/readback.rs | 2 +- crates/gpu/src/setup.rs | 4 +- crates/gpu/src/textures.rs | 2 +- 14 files changed, 326 insertions(+), 142 deletions(-) diff --git a/crates/gpu/src/batch.rs b/crates/gpu/src/batch.rs index 988a580cc4..700ed8361f 100644 --- a/crates/gpu/src/batch.rs +++ b/crates/gpu/src/batch.rs @@ -1,6 +1,6 @@ use super::convert::{W, words}; use super::textures::Resident; -use super::*; +use super::{DeviceHealth, F, I, Kernel, Plan, Rect, TILE_SIZE, TileCoord, U, plan, timing}; /// The uniform record of a pass. pub(crate) fn op_words(p: &plan::Pass<'_>, tex: Option<[i32; 4]>, mask: Option<[i32; 4]>, map: Option) -> Vec { diff --git a/crates/gpu/src/cells.rs b/crates/gpu/src/cells.rs index 8d8a44ec97..ab3c451bed 100644 --- a/crates/gpu/src/cells.rs +++ b/crates/gpu/src/cells.rs @@ -4,7 +4,7 @@ use super::convert::{convert_tile, convert_tiles, keep_overlap, put_tiles, words use super::kit::{Bound, FrameRes, texture_group, uniform_group}; use super::paging::cell_rect; use super::textures::{CachedPattern, Cell, ChunkOut, ResKey, Resident, ResidentRef, Stats, Tex, TexKind}; -use super::*; +use super::{Arc, Compositor, DocId, HashMap, I, Kernel, Pattern, Plan, Rect, Role, Surface, TILE_SIZE, TileCoord, plan}; impl Compositor { /// Bring the pages of `cell` that `plan` samples up to date and resolve its effect maps. diff --git a/crates/gpu/src/convert.rs b/crates/gpu/src/convert.rs index 6b0a7e6f98..9dbfc81814 100644 --- a/crates/gpu/src/convert.rs +++ b/crates/gpu/src/convert.rs @@ -1,6 +1,6 @@ use super::batch::write_tile; use super::textures::{Resident, TexKind}; -use super::*; +use super::{Arc, F, HashMap, I, PixelFormat, Rect, SampleType, Surface, TILE_SIZE, Tile, TileCoord, U, fx}; /// Distinct tiles converted per parallel batch: bounds the converted bytes held at once (64 tiles /// of a 16-bit page are 32 MiB). diff --git a/crates/gpu/src/encode.rs b/crates/gpu/src/encode.rs index 037a4cc80d..cfa4bbd723 100644 --- a/crates/gpu/src/encode.rs +++ b/crates/gpu/src/encode.rs @@ -4,7 +4,7 @@ use super::convert::lut_texture; use super::kit::FrameRes; use super::paging::{OVER_BUDGET, cell_rect, first_error, grid_rect_count, grid_rects, lru_victims, scoped_work, uniform_buffer_len}; use super::textures::{ChunkOut, FxKey, ResKey, Resident, Stats}; -use super::*; +use super::{Compositor, Document, LayerId, Plan, Rect, Surface, Unsupported, plan, timing}; impl Compositor { /// Composite `region` of `doc`. Each finished chunk is passed to `sink` while its encoder is diff --git a/crates/gpu/src/fx.rs b/crates/gpu/src/fx.rs index 34982cd2be..7d56fe7378 100644 --- a/crates/gpu/src/fx.rs +++ b/crates/gpu/src/fx.rs @@ -301,71 +301,96 @@ pub(crate) fn program(e: &Effect, light: &GlobalLight, vector_shape: bool) -> Ma program_with(e, light, vector_shape, &[], (0.0, 0.0)) } +fn shadow_program(b: &mut B, s: &photocraft_doc::Shadow, inner: bool, light: &GlobalLight) -> usize { + 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, bw) = photocraft_compose::effects::spread_split(s.size, s.spread); + let mut m = src; + if r > 0.0 { + let f = b.field(if inner { FieldKind::ChokeInside } else { FieldKind::StrokeOutside }, r); + 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, bw); + b.finish(m, None, false, &s.contour, inner, 0); + 1 +} + +fn glow_program(b: &mut B, g: &photocraft_doc::Glow, inner: bool) -> usize { + let center = inner && g.source == GlowSource::Center; + match g.technique { + GlowTechnique::Precise => { + let d = b.field(if inner { FieldKind::Inside } else { FieldKind::Outside }, g.size); + let solid = g.size * g.spread; + let soft = (g.size + 1.0 - solid).max(1e-3); + let m = b.push(stage(Kernel::MGlow, Some(d), None, [solid, soft, 0.0, 0.0], 0)); + b.finish_glow(m, photocraft_compose::effects::glow_lut(g), inner, center); + } + GlowTechnique::Softer => { + let m = softer_glow_map(b, g, inner); + b.finish_glow(m, photocraft_compose::effects::glow_lut(g), inner, center); + } + } + 1 +} + +fn softer_glow_map(b: &mut B, g: &photocraft_doc::Glow, inner: bool) -> In { + let src = if inner { b.shift(In::Shape, 0.0, 0.0, 0.0, true) } else { In::Shape }; + let (r, bw) = photocraft_compose::effects::spread_split(g.size, g.spread); + let mut map = src; + if r > 0.0 { + let distance = b.field(if inner { FieldKind::ChokeInside } else { FieldKind::StrokeOutside }, r); + map = b.dilate(src, distance, r); + } + b.blur(map, bw) +} + +fn satin_program(b: &mut B, s: &photocraft_doc::Satin) -> usize { + let (dx, dy) = offset(s.angle, photocraft_compose::effects::satin_distance(s)); + let a = b.shift(In::Shape, dx, dy, 0.0, false); + let a = b.conv(a, photocraft_compose::effects::tent_kernel(s.size)); + let c = b.shift(In::Shape, -dx, -dy, 0.0, false); + let c = b.conv(c, photocraft_compose::effects::tent_kernel(s.size)); + b.finish_lut(a, Some(c), s.invert, photocraft_compose::effects::satin_lut(&s.contour), true, 0); + 1 +} + +fn stroke_program(b: &mut B, st: &photocraft_doc::StrokeFx, vector_shape: bool) -> usize { + let (in_w, out_w) = stroke_widths(st); + if out_w > 0.0 { + let kind = match (vector_shape, photocraft_compose::effects::stroke_outside_exact(out_w)) { + (true, true) => FieldKind::StrokeOutsideVector, + (true, false) => FieldKind::StrokeOutsideVectorChamfer, + (false, true) => FieldKind::StrokeOutsideExact, + (false, false) => FieldKind::StrokeOutside, + }; + let d = b.field(kind, out_w); + let mut s = stage(Kernel::MStroke, Some(d), None, [out_w, 0.0, 0.0, 0.0], 0); + s.out = Some(0); + b.stages.push(s); + } + if in_w > 0.0 { + let d = b.field(FieldKind::StrokeInside, in_w); + let mut s = stage(Kernel::MStroke, Some(d), None, [in_w, 0.0, 0.0, 0.0], 0); + s.out = Some(1); + b.stages.push(s); + } + 2 +} + /// 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) => { - // shadow_map - let inner = matches!(e, Effect::InnerShadow(_)); - 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, 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 - // pixels are far away for a drop shadow, inside for an inner shadow). - let f = b.field(if inner { FieldKind::ChokeInside } else { FieldKind::StrokeOutside }, r); - 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, bw); - b.finish(m, None, false, &s.contour, inner, 0); - 1 - } - Effect::OuterGlow(g) | Effect::InnerGlow(g) => { - // glow_map - let inner = matches!(e, Effect::InnerGlow(_)); - let center = inner && g.source == GlowSource::Center; - match g.technique { - GlowTechnique::Precise => { - let d = b.field(if inner { FieldKind::Inside } else { FieldKind::Outside }, g.size); - let solid = g.size * g.spread; - let soft = (g.size + 1.0 - solid).max(1e-3); - let m = b.push(stage(Kernel::MGlow, Some(d), None, [solid, soft, 0.0, 0.0], 0)); - b.finish_glow(m, photocraft_compose::effects::glow_lut(g), inner, center); - } - 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, 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::ChokeInside } else { FieldKind::StrokeOutside }, r); - m = b.dilate(src, d, r); - } - let m = b.blur(m, bw); - b.finish_glow(m, photocraft_compose::effects::glow_lut(g), inner, center); - } - } - 1 - } - Effect::Satin(s) => { - // satin_map - let (dx, dy) = offset(s.angle, photocraft_compose::effects::satin_distance(s)); - let a = b.shift(In::Shape, dx, dy, 0.0, false); - let a = b.conv(a, photocraft_compose::effects::tent_kernel(s.size)); - let c = b.shift(In::Shape, -dx, -dy, 0.0, false); - let c = b.conv(c, photocraft_compose::effects::tent_kernel(s.size)); - b.finish_lut(a, Some(c), s.invert, photocraft_compose::effects::satin_lut(&s.contour), true, 0); - 1 - } + Effect::DropShadow(s) | Effect::InnerShadow(s) => shadow_program(&mut b, s, matches!(e, Effect::InnerShadow(_)), light), + Effect::OuterGlow(g) | Effect::InnerGlow(g) => glow_program(&mut b, g, matches!(e, Effect::InnerGlow(_))), + Effect::Satin(s) => satin_program(&mut b, s), Effect::BevelEmboss(bv) => { // bevel_maps: height map (tent blur of the shape, or chiselled distance ramps), then // highlight / shadow shading inside and / or outside the shape. @@ -434,31 +459,7 @@ pub(crate) fn program_with(e: &Effect, light: &GlobalLight, vector_shape: bool, } out } - Effect::Stroke(st) => { - // composite_with_effects' stroke bands (maps 0 outside, 1 inside) - let (in_w, out_w) = stroke_widths(st); - if out_w > 0.0 { - // Narrow strokes keep the fitted chamfer, wide ones the exact transform (#3646); - // the CPU picks the same field by the same width (`stroke_outside_exact`). - let kind = match (vector_shape, photocraft_compose::effects::stroke_outside_exact(out_w)) { - (true, true) => FieldKind::StrokeOutsideVector, - (true, false) => FieldKind::StrokeOutsideVectorChamfer, - (false, true) => FieldKind::StrokeOutsideExact, - (false, false) => FieldKind::StrokeOutside, - }; - let d = b.field(kind, out_w); - let mut s = stage(Kernel::MStroke, Some(d), None, [out_w, 0.0, 0.0, 0.0], 0); - s.out = Some(0); - b.stages.push(s); - } - if in_w > 0.0 { - let d = b.field(FieldKind::StrokeInside, in_w); - let mut s = stage(Kernel::MStroke, Some(d), None, [in_w, 0.0, 0.0, 0.0], 0); - s.out = Some(1); - b.stages.push(s); - } - 2 - } + Effect::Stroke(st) => stroke_program(&mut b, st, vector_shape), Effect::ColorOverlay { .. } | Effect::GradientOverlay { .. } | Effect::PatternOverlay { .. } => return MapProgram::empty(), }; let mut h = std::collections::hash_map::DefaultHasher::new(); diff --git a/crates/gpu/src/fx_passes.rs b/crates/gpu/src/fx_passes.rs index a549979f63..f3f5ce6da3 100644 --- a/crates/gpu/src/fx_passes.rs +++ b/crates/gpu/src/fx_passes.rs @@ -3,7 +3,7 @@ use super::consts::{MAP16, MAP32}; use super::kit::MapDraw; use super::paging::field_reaches; use super::textures::{FxEntry, FxKey, ProgState, Stats, Tex}; -use super::*; +use super::{Arc, Compositor, Document, FieldKind, HashMap, LayerContent, Rect, Unsupported, fx, plan}; impl Compositor { /// Build or update the effect maps of one layer over `region`: its whole effect region, or diff --git a/crates/gpu/src/kit.rs b/crates/gpu/src/kit.rs index 2de048a2e2..6ac1b76dc3 100644 --- a/crates/gpu/src/kit.rs +++ b/crates/gpu/src/kit.rs @@ -1,7 +1,7 @@ use super::consts::{CHUNK_UNIFORM, OP_UNIFORM, STRIDE}; use super::convert::{lut_texture, words}; use super::textures::{ResKey, ResidentRef}; -use super::*; +use super::{Arc, HashMap, I, Kernel, NonZeroU64, Rect}; /// Pipelines and layouts, shared by cheap clones (wgpu handles are reference counted). #[derive(Clone)] diff --git a/crates/gpu/src/paging.rs b/crates/gpu/src/paging.rs index c6d4b61563..b07f8e8db4 100644 --- a/crates/gpu/src/paging.rs +++ b/crates/gpu/src/paging.rs @@ -1,6 +1,6 @@ use super::consts::STRIDE; use super::textures::Cell; -use super::*; +use super::{DeviceHealth, FieldKind, HashMap, Rect, Unsupported, fx}; /// Document pixels of page cell `c`. pub(crate) fn cell_rect(c: Cell, page: u32) -> Rect { diff --git a/crates/gpu/src/plan/lower.rs b/crates/gpu/src/plan/lower.rs index 42dd17e099..a38cdde867 100644 --- a/crates/gpu/src/plan/lower.rs +++ b/crates/gpu/src/plan/lower.rs @@ -1,5 +1,5 @@ use super::types::Unsupported; -use super::*; +use super::{Adjustment, BlendMode, Fill, Gradient, Layer, LayerContent, Pattern, StrokePosition, ToneSpace, Transfer, adjust, lut3d_len}; /// Paint source of an effect. pub(super) enum Paint<'a> { diff --git a/crates/gpu/src/plan/planner.rs b/crates/gpu/src/plan/planner.rs index 27d7bf589a..88de5a81b4 100644 --- a/crates/gpu/src/plan/planner.rs +++ b/crates/gpu/src/plan/planner.rs @@ -2,7 +2,7 @@ use super::lower::{ Paint, adjustment_on_gpu, adjustment_program, check_gradient_stops, gradient_rows, placement, single_content_pass, stroke_widths, style_index, }; use super::types::{Checkpoint, DocCtx, FxLayer, Kernel, MapRef, MaskUse, Pass, Role, SurfaceRef, TexUse, Unsupported}; -use super::*; +use super::{Adjustment, BlendMode, Effect, Fill, FxPaint, Glow, Layer, LayerContent, LayerId, Plan, Rect, Slot, Surface, bounds, has_effects}; pub(super) struct Planner<'a> { passes: Vec>, @@ -29,6 +29,27 @@ enum Cov { One, } +struct EffectState<'a> { + layer: &'a Layer, + items: Vec<&'a Effect>, + rev: Vec<(usize, &'a Effect)>, + fx: usize, + content: Slot, + lay_src: Slot, + vstroke: Option, + backdrop: Slot, + w: Slot, + l: Slot, + clip: Rect, + sb: Rect, + anchor: (f64, f64), + outline: bool, + relative: bool, + vector_shape: bool, + atop: bool, + premerge: bool, +} + /// Shader flags for effect passes (keep in sync with compose.wgsl). Coverage `m` of a paint, with /// `a` the layer's alpha and `inside` = `a > 0.5/255`: /// knockout `m × (1 − a × k)` (k in `p4.w`); gate `inside ? m : 0`; rel `inside ? min(m / a, 1) : 0`; @@ -133,6 +154,28 @@ pub const INIT_OUTLINE: i32 = 7; /// `MapRef::item` of the layer's effect shape (`compose::layer_shape`) instead of an effect map. pub const SHAPE_MAP: usize = usize::MAX; +fn check_effect_gradients(items: &[&Effect]) -> Result<(), Unsupported> { + for effect in items { + let gradient = match effect { + Effect::GradientOverlay { gradient, .. } => Some(gradient), + Effect::Stroke(stroke) => match &stroke.paint { + FxPaint::Gradient(g) => Some(g), + _ => None, + }, + Effect::OuterGlow(glow) | Effect::InnerGlow(glow) => match &glow.paint { + FxPaint::Gradient(g) => Some(g), + _ => None, + }, + _ => None, + }; + if let Some(gradient) = gradient { + check_gradient_stops(&gradient.stops)?; + check_gradient_stops(&gradient.opacity_stops)?; + } + } + Ok(()) +} + impl<'a> Planner<'a> { pub(super) fn new(cx: DocCtx<'a>) -> Self { Planner { passes: Vec::new(), free: Vec::new(), refs: Vec::new(), cx, fx: Vec::new(), checkpoints: Vec::new(), visits: 0 } @@ -724,10 +767,11 @@ impl<'a> Planner<'a> { Ok(self.emit(p)) } - /// `composite_with_effects` (atop = false) or the clipped-layer variant of `composite_atop` - /// (atop = true: effects over the base treated as opaque, keeping the base's alpha). + /// Plans enabled layer effects in the same phase order as the CPU compositor. /// Consumes `backdrop`. fn effects(&mut self, layer: &'a Layer, clipped: &[&'a Layer], backdrop: Slot, atop: bool) -> Result { + let items: Vec<&'a Effect> = layer.effects.items.iter().filter(|e| e.enabled()).collect(); + check_effect_gradients(&items)?; let canvas = self.cx.canvas; let region = bounds::effect_region(layer, canvas); let sb = photocraft_compose::paint_bounds(layer).unwrap_or_else(|| bounds::layer_bounds(layer, canvas)); @@ -792,44 +836,67 @@ impl<'a> Planner<'a> { content = self.emit(p); } - let items: Vec<&'a Effect> = layer.effects.items.iter().filter(|e| e.enabled()).collect(); - for e in &items { - let gradient = match e { - Effect::GradientOverlay { gradient, .. } => Some(gradient), - Effect::Stroke(s) => match &s.paint { - FxPaint::Gradient(g) => Some(g), - _ => None, - }, - Effect::OuterGlow(g) | Effect::InnerGlow(g) => match &g.paint { - FxPaint::Gradient(g) => Some(g), - _ => None, - }, - _ => None, - }; - if let Some(g) = gradient { - check_gradient_stops(&g.stops)?; - check_gradient_stops(&g.opacity_stops)?; - } - } // Linked patterns tile from the effects reference point (else the layer's top-left). + let premerge = photocraft_compose::effects::premerges_layer(layer); let anchor = layer.effects.reference.unwrap_or((f64::from(sb.x0), f64::from(sb.y0))); let vector_shape = matches!(layer.content, LayerContent::Shape(_)) && !outline; - let map = |item: usize, map: usize| MapRef { fx, item, map }; - let rev: Vec<(usize, &'a Effect)> = items.iter().copied().enumerate().rev().collect(); - let init = |s: &mut Self, src: Slot, b: Option, kind: i32, opacity: f32| { - let mut p = Pass::new(Kernel::FxInit, 0); - p.a = Some(src); - p.b = b; - p.adjust_kind = kind; - p.opacity = opacity; - p.clip = Some(clip); - s.emit(p) + let rev = items.iter().copied().enumerate().rev().collect(); + let mut work = EffectState { + layer, + items, + rev, + fx, + content, + lay_src, + vstroke, + backdrop, + w: backdrop, + l: lay_src, + clip, + sb, + anchor, + outline, + relative, + vector_shape, + atop, + premerge, }; + if let Some(merged) = self.effect_exterior(&mut work) { + self.release(work.content); + return Ok(merged); + } + self.effect_layer_base(&mut work); + self.effect_paints(&mut work); + self.effect_vector_stroke(&mut work); + self.effect_inside_strokes(&mut work); + self.effect_inner_bevel(&mut work); + self.effect_alpha(&mut work); + self.effect_outside_strokes(&mut work); + self.effect_outer_bevel(&mut work); + let merged = self.effect_merge(&mut work); + self.release(work.content); + Ok(self.write_back(work.backdrop, merged, work.clip)) + } + fn effect_exterior(&mut self, work: &mut EffectState<'a>) -> Option { + let layer = work.layer; + let items = work.items.clone(); + let rev = work.rev.clone(); + let fx = work.fx; + let content = work.content; + let lay_src = work.lay_src; + let backdrop = work.backdrop; + let clip = work.clip; + let sb = work.sb; + let atop = work.atop; + let relative = work.relative; + let premerge = work.premerge; + let anchor = work.anchor; + let map = |item: usize, map: usize| MapRef { fx, item, map }; // Exterior effects over the backdrop (an opaque copy of it for clipped layers). let mut w = if atop { let b = self.retain(backdrop); - init(self, b, None, INIT_OPAQUE, 1.0) + self.fx_init(clip, b, None, INIT_OPAQUE, 1.0) } else { self.retain(backdrop) }; @@ -866,7 +933,6 @@ impl<'a> Planner<'a> { // Only exterior effects (drop shadows, outer glows): nothing is painted between the // layer's colour inside its shape and the shape's alpha, so the merge derives both from // the shape (`F_LAYER_SHAPE`) instead of two passes building the layer. - let premerge = photocraft_compose::effects::premerges_layer(layer); if !relative && !premerge && items.iter().all(|e| matches!(e, Effect::DropShadow(_) | Effect::OuterGlow(_))) { let mut p = Pass::new(Kernel::FxMerge, 0); p.a = Some(w); @@ -879,16 +945,28 @@ impl<'a> Planner<'a> { p.extra[3] = photocraft_compose::text_gamma(layer); p.clip = Some(clip); let merged = self.emit(p); - self.release(content); - return Ok(self.write_back(backdrop, merged, clip)); + let merged = self.write_back(backdrop, merged, clip); + return Some(merged); } + work.w = w; + None + } + + fn effect_layer_base(&mut self, work: &mut EffectState<'a>) { + let layer = work.layer; + let content = work.content; + let lay_src = work.lay_src; + let w = work.w; + let clip = work.clip; + let relative = work.relative; + let premerge = work.premerge; // The layer: its colour at fill opacity inside its shape; interior effects are painted // relative to the shape (coverage within it), then the shape's alpha applies. let mut l = if relative { let c = self.retain(content); - init(self, lay_src, Some(c), INIT_RELATIVE, layer.fill_opacity) + self.fx_init(clip, lay_src, Some(c), INIT_RELATIVE, layer.fill_opacity) } else { - init(self, lay_src, None, INIT_INSIDE, layer.fill_opacity) + self.fx_init(clip, lay_src, None, INIT_INSIDE, layer.fill_opacity) }; // Blend Interior Effects as Group off: the layer merges in its mode first and the // interior effects paint over the result (`effects::premerges_layer`). @@ -902,6 +980,18 @@ impl<'a> Planner<'a> { p.clip = Some(clip); l = self.emit(p); } + work.l = l; + } + + fn effect_paints(&mut self, work: &mut EffectState<'a>) { + let rev = work.rev.clone(); + let fx = work.fx; + let content = work.content; + let mut l = work.l; + let clip = work.clip; + let sb = work.sb; + let anchor = work.anchor; + let map = |item: usize, map: usize| MapRef { fx, item, map }; for &(_, e) in &rev { if let Effect::PatternOverlay { common, name, id, scale, angle, link, phase } = e && let Some(pat) = photocraft_doc::pattern::find(self.cx.patterns, id, name).filter(|p| p.is_paintable()) @@ -936,6 +1026,15 @@ impl<'a> Planner<'a> { l = self.paint(l, content, Cov::Map(map(i, 0), 0.0), &Paint::Color(s.color.to_rgb()), s.common.blend, s.common.opacity, F_REL, clip, sb); } } + work.l = l; + } + + fn effect_vector_stroke(&mut self, work: &mut EffectState<'a>) { + let layer = work.layer; + let content = work.content; + let mut l = work.l; + let vstroke = work.vstroke; + let clip = work.clip; if let Some(s) = vstroke { let mut p = Pass::new(Kernel::FxInit, 0); p.a = Some(l); @@ -946,6 +1045,19 @@ impl<'a> Planner<'a> { p.clip = Some(clip); l = self.emit(p); } + work.l = l; + } + + fn effect_inside_strokes(&mut self, work: &mut EffectState<'a>) { + let layer = work.layer; + let rev = work.rev.clone(); + let fx = work.fx; + let content = work.content; + let mut l = work.l; + let clip = work.clip; + let sb = work.sb; + let anchor = work.anchor; + let map = |item: usize, map: usize| MapRef { fx, item, map }; // Inside stroke parts are painted over the layer (bottom instance first). for &(i, e) in &rev { if let Effect::Stroke(st) = e { @@ -966,6 +1078,17 @@ impl<'a> Planner<'a> { } } } + work.l = l; + } + + fn effect_inner_bevel(&mut self, work: &mut EffectState<'a>) { + let rev = work.rev.clone(); + let fx = work.fx; + let content = work.content; + let mut l = work.l; + let clip = work.clip; + let sb = work.sb; + let map = |item: usize, map: usize| MapRef { fx, item, map }; let bevel_paint = |b: &photocraft_doc::Bevel| photocraft_compose::effects::bevel_geom(b).paint; for &(i, e) in &rev { if let Effect::BevelEmboss(b) = e @@ -985,9 +1108,32 @@ impl<'a> Planner<'a> { l = self.paint(l, content, Cov::Map(map(i, 1), 0.0), &Paint::Color(b.shadow_color.to_rgb()), b.shadow.blend, b.shadow.opacity, F_REL, clip, sb); } } + work.l = l; + } + + fn effect_alpha(&mut self, work: &mut EffectState<'a>) { + let content = work.content; + let mut l = work.l; + let clip = work.clip; // The shape's own alpha. let c = self.retain(content); - l = init(self, l, Some(c), INIT_ALPHA, 1.0); + l = self.fx_init(clip, l, Some(c), INIT_ALPHA, 1.0); + work.l = l; + } + + fn effect_outside_strokes(&mut self, work: &mut EffectState<'a>) { + let layer = work.layer; + let items = work.items.clone(); + let fx = work.fx; + let content = work.content; + let mut w = work.w; + let l = work.l; + let clip = work.clip; + let sb = work.sb; + let anchor = work.anchor; + let outline = work.outline; + let vector_shape = work.vector_shape; + let map = |item: usize, map: usize| MapRef { fx, item, map }; // Outside stroke parts lie beneath the layer and blend onto the exterior result with their // own mode; a higher stroke covers the ones below it (each takes its coverage × opacity // not yet taken above it, blended over the result as it was before the strokes). @@ -1004,7 +1150,7 @@ impl<'a> Planner<'a> { // The layer's alpha rides along the coverage: `effects::outline_share`, and for // pixel layers the stroke's share beneath a partly covering layer (fill < 100 %). let ll = self.retain(l); - cover = Some(init(self, ll, None, INIT_COVER, 1.0)); + cover = Some(self.fx_init(clip, ll, None, INIT_COVER, 1.0)); } for (n, &(i, st)) in outs.iter().enumerate() { let paint = self.fx_paint(&st.paint, anchor); @@ -1046,6 +1192,18 @@ impl<'a> Planner<'a> { p.clip = Some(clip); w = self.emit(p); } + work.w = w; + } + + fn effect_outer_bevel(&mut self, work: &mut EffectState<'a>) { + let rev = work.rev.clone(); + let bevel_paint = |b: &photocraft_doc::Bevel| photocraft_compose::effects::bevel_geom(b).paint; + let fx = work.fx; + let content = work.content; + let mut w = work.w; + let clip = work.clip; + let sb = work.sb; + let map = |item: usize, map: usize| MapRef { fx, item, map }; for &(i, e) in &rev { if let Effect::BevelEmboss(b) = e && bevel_paint(b) == photocraft_compose::effects::BevelPaint::Outer @@ -1066,13 +1224,30 @@ impl<'a> Planner<'a> { } } + work.w = w; + } + + fn effect_merge(&mut self, work: &mut EffectState<'a>) -> Slot { + let layer = work.layer; + let rev = work.rev.clone(); + let fx = work.fx; + let content = work.content; + let w = work.w; + let l = work.l; + let backdrop = work.backdrop; + let clip = work.clip; + let sb = work.sb; + let atop = work.atop; + let premerge = work.premerge; + let bevel_paint = |b: &photocraft_doc::Bevel| photocraft_compose::effects::bevel_geom(b).paint; + let map = |item: usize, map: usize| MapRef { fx, item, map }; let mode = if premerge || layer.blend == BlendMode::PassThrough { BlendMode::Normal } else { layer.blend }; let late: Vec<(usize, &'a photocraft_doc::Bevel)> = rev .iter() .filter_map(|&(i, e)| if let Effect::BevelEmboss(b) = e { Some((i, b)) } else { None }) .filter(|(_, b)| bevel_paint(b) == photocraft_compose::effects::BevelPaint::Both) .collect(); - let merged = if late.is_empty() { + if late.is_empty() { let mut p = Pass::new(Kernel::FxMerge, 0); p.a = Some(w); p.b = Some(l); @@ -1110,11 +1285,17 @@ impl<'a> Planner<'a> { p.flags = if atop { F_ATOP } else { 0 } | F_NO_LAYER; p.clip = Some(clip); self.emit(p) - }; - self.release(content); + } + } - // Write the clipped result back into the backdrop (in place when nothing else holds it). - Ok(self.write_back(backdrop, merged, clip)) + fn fx_init(&mut self, clip: Rect, src: Slot, b: Option, kind: i32, opacity: f32) -> Slot { + let mut pass = Pass::new(Kernel::FxInit, 0); + pass.a = Some(src); + pass.b = b; + pass.adjust_kind = kind; + pass.opacity = opacity; + pass.clip = Some(clip); + self.emit(pass) } fn fx_paint(&self, p: &'a FxPaint, anchor: (f64, f64)) -> Paint<'a> { diff --git a/crates/gpu/src/plan/types.rs b/crates/gpu/src/plan/types.rs index e83fac8c8c..13005dbba2 100644 --- a/crates/gpu/src/plan/types.rs +++ b/crates/gpu/src/plan/types.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{BlendMode, Document, GlobalLight, Layer, LayerId, Pattern, Rect, Slot, Surface, Transfer}; /// Pipeline (fragment entry point) of a pass. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] diff --git a/crates/gpu/src/readback.rs b/crates/gpu/src/readback.rs index 14dd73a831..9abf5f071e 100644 --- a/crates/gpu/src/readback.rs +++ b/crates/gpu/src/readback.rs @@ -1,5 +1,5 @@ use super::textures::Stats; -use super::*; +use super::{Compositor, Document, Rect, Unsupported}; /// Blocking readback of a composite (native tests and tools). #[cfg(not(target_arch = "wasm32"))] diff --git a/crates/gpu/src/setup.rs b/crates/gpu/src/setup.rs index 30d04d872e..c5b5c90384 100644 --- a/crates/gpu/src/setup.rs +++ b/crates/gpu/src/setup.rs @@ -3,7 +3,9 @@ use super::consts::{ACC_FORMAT, CHUNK, CHUNK_UNIFORM, FX_BUDGET, MAP16, MAP32, O use super::kit::{Kit, SHADER, tex_entry, uniform_entry}; use super::paging::{cell_rect, field_reaches, first_error, grid_rects}; use super::textures::{FxEntry, Resident, Tex, TexKind}; -use super::*; +use super::{ + Compositor, DeviceHealth, DocId, Document, Fault, HashMap, Kernel, LayerContent, Plan, Rect, Role, TILE_SIZE, Unsupported, fx, plan, prefix, timing, +}; impl Compositor { /// Create a compositor with the default accumulation format ([`ACC_FORMAT`]). diff --git a/crates/gpu/src/textures.rs b/crates/gpu/src/textures.rs index 1b28f61150..5b52dfefaa 100644 --- a/crates/gpu/src/textures.rs +++ b/crates/gpu/src/textures.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Arc, DocId, FieldKind, HashMap, LayerId, PixelFormat, Rect, Role, SampleType, Tile, TileCoord, fx, timing}; /// A finished chunk: straight-alpha RGBA32F pixels of `rect` (document coordinates) at the /// texture's origin.