Merge pull request #981 from storytold/feat/distort-effects

Part of gap 2: Effect › Distort (Diffuse Glow, Glass, Ocean Ripple)
2026-10-22 19:08:39 +00:00 · 2026-10-10 23:24:59 +07:00
commit e3874e89e7
@@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob

 This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands.

-_Last updated: 2026-10-10 (after placed documents (File › Place of a `.vectorcraft` file, linked), M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG windoLine truncated
+_Last updated: 2026-10-10 (after placed documents (File › Place of a `.vectorcraft` file, linked), M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG windoLine truncated

 ## Where we are

@@ -35,7 +35,7 @@ since 2026-10-01.
 |---|---|---|
 | **Breadth:** menus, tools and panels exist | ~90% | 13 menu items still stubbed; every tool implemented except Touch Type; 51 panel modules |
 | **Depth:** each feature behaves like Illustrator | ~69–75% | Strong: paint, appearance and colour (M3), Pathfinder and booleans, selection, drawing, files (M4). Weak: advanced type (~45%; inline symbols in text are beyond parity and don't raise it), brushes and symbols (in progress), raster effects (~20%) |
-| **Large missing subsystems** | 0–20% | 3D & Materials (0%), Photoshop-style raster effects and the Effect Gallery (~16 of ~56 filters), SVG Filters, CJK composition (vertical type with kinsoku, tate-chu-yoko and the font's vertical metrics; ruby, mojikumi and proportional vertical metrics open), Variables (data merge), scripting |
+| **Large missing subsystems** | 0–20% | 3D & Materials (0%), Photoshop-style raster effects and the Effect Gallery (~19 of ~56 filters), SVG Filters, CJK composition (vertical type with kinsoku, tate-chu-yoko and the font's vertical metrics; ruby, mojikumi and proportional vertical metrics open), Variables (data merge), scripting |
 | **Interaction fidelity:** modifiers, cursors, small behaviours | ~30–40% | The dedicated pass hasn't started, and there has been no side-by-side session with Illustrator yet. A power user notices this first |
 | **Look & feel** | ~75–80% | Measured against Illustrator 2026 screenshots (2026-10-02); the panels added since haven't been re-measured |
 | **File interop** | ~85% | SVG/SVGZ, PDF and PDF-compatible `.ai`, EPS, DXF, EMF/WMF, raster formats, PSD export and PSD/PSB placement (merged image), Place and Links, Package, Print, clipboard flavours. Affinity documents (Affinity 1–3) open natively as editable art, checked against 51 pinned public files (33 current `.af`), with selected saved-thumbnail comparisons and every-board native/SVG/PDF/PSD checks for current files; Affinity export is missing and effects, adjustments and brushes don't import. Affinity isn't an Illustrator feature, so this doesn't raise the parity score. The editing copy inside an Illustrator EPS or `.ai` is read for its structure: layers, groups, names, hidden objects and type, colours, gradients, transparency, images and every artboard (see Out of scope for what it doesn't read yet); DWG has no open spec |
@@ -53,15 +53,16 @@ Ordered by how much each gap blocks someone from switching. Sizes are one-agent
 1. **Interaction fidelity:** go tool by tool and panel by panel against `plan/illustrator/05-tools.md`,
   `06-panels.md` and `09-shortcuts.md`, covering modifier keys, cursors, the Properties panel per context and
   isolation mode. The Shaper’s rough-square recognition and shape orientation steps are corrected; Shaper Groups now retain editable originals for region merges/punches and separate fill/stroke edits; their construction-mode widget and gesture refinements remain. 60–90 h.
-2. **Photoshop-style raster effects and the Effect Gallery:** about 39 filters (Artistic, Brush Strokes, Distort,
-   Sketch, Stylize) and the Effect Gallery. The pixel-filter pipeline is in place
+2. **Photoshop-style raster effects and the Effect Gallery:** about 36 filters (Artistic, Brush Strokes, Sketch,
+   Stylize) and the Effect Gallery. The pixel-filter pipeline is in place
   (`vectorcraft_effects::pixel`: the object rendered offscreen, filtered in stack order with Gaussian Blur and
   Feather, cached while panning, images in PDF/SVG/Expand Appearance) with Blur › Radial Blur and Smart Blur
-   (Normal mode only), Pixelate › Color Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask,
+   (Normal mode only), Distort › Diffuse Glow, Glass (its Blocks, Canvas, Frosted and Tiny Lens surfaces made in
+   code; Load Texture is missing) and Ocean Ripple, Pixelate › Color Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask,
   Stylize › Glowing Edges, Texture › Craquelure, Grain, Mosaic Tiles, Patchwork, Stained Glass and Texturizer (its
   Brick, Burlap, Canvas and Sandstone surfaces made in code; Load Texture is missing) and Video › De-Interlace and
   NTSC Colors; each new filter is now one function, a catalogue row, menu and translations. Parallelizes
-   well across agents. 20–33 h.
+   well across agents. 19–31 h.
 3. **3D and Materials:** Extrude & Bevel, Revolve, Inflate and Rotate with lighting and materials, using a software
   renderer in its own crate (layering allows it below L6), with output in SVG/PDF as rasters or projected vectors.
   The largest single gap. 50–80 h.
@@ -228,7 +229,7 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | Strokes, brushes, width profiles | 5 | 90% | the Art brush's Overlap, auto-generated Pattern brush corners and new tile art in Pattern Brush Options (Brush Options for every brush type done), brush libraries (generated in code), pen pressure on macOS (the windowing layer reports none there), brushes driven by pen tilt, bearing and barrel rotation (6D art pens) | 8–15 |
 | Appearance, transparency, graphic styles, masks | 5 | 98% | raster effect reach in preview bounds (flattener presets apply in PDF, EPS and print) | 1–2 |
 | Live vector effects | 5 | 85% | Outline Object, Pathfinder Hard/Soft Mix and Trap, SVG Filters, the Transform effect's Transform Objects/Patterns and Scale Strokes & Effects options | 6–10 |
-| Raster effects (Effect Gallery, Document Raster Effects Settings) | 4 | 32% | ~39 Photoshop-style filters (Artistic, Brush Strokes, Distort, Sketch, Stylize), Smart Blur's Edge Only / Overlay Edge modes, Texturizer's Load Texture and the Effect Gallery; Document Raster Effects Settings, raster effects in PDF, the pixel-filter pipeline, Radial Blur, Smart Blur, Unsharp Mask, Glowing Edges, Pixelate (Color Halftone, Crystallize, Mezzotint, Pointillize), Texture (Craquelure, Grain, Mosaic Tiles, Patchwork, Stained Glass, Texturizer) and Video (De-Interlace, NTSC Colors) are done | 20–33 |
+| Raster effects (Effect Gallery, Document Raster Effects Settings) | 4 | 35% | ~36 Photoshop-style filters (Artistic, Brush Strokes, Sketch, Stylize), Smart Blur's Edge Only / Overlay Edge modes, Glass's and Texturizer's Load Texture and the Effect Gallery; Document Raster Effects Settings, raster effects in PDF, the pixel-filter pipeline, Radial Blur, Smart Blur, Unsharp Mask, Glowing Edges, Distort (Diffuse Glow, Glass, Ocean Ripple), Pixelate (Color Halftone, Crystallize, Mezzotint, Pointillize), Texture (Craquelure, Grain, Mosaic Tiles, Patchwork, Stained Glass, Texturizer) and Video (De-Interlace, NTSC Colors) are done | 19–31 |
 | 3D and Materials | 4 | 0% | Extrude & Bevel, Revolve, Inflate, Rotate, lighting, materials (software renderer) | 50–80 |
 | Type core | 9 | 80% | Middle Eastern features beyond bidi layout and Paragraph Direction (Character Direction, digit types, kashidas, the Middle Eastern composers, editable bidirectional SVG text, a split caret where directions meet); Hyphenation… and Justification… options (Every-line Composer for justified and ragged text, per object, is done; it is tuned by eye, not yet compared side by side with Illustrator; mixed type sizes in a paragraph still break single-line), Optical Margin Alignment, paragraph spacing limit for vertically justified area type, hidden characters, paragraph attributes in the Type tool's copy and paste (the characters keep their styles, the paragraphs take the destination's), mixed-value display in the Paragraph panel for a selection across differing paragraphs, Transform Again after a type-area resize (it scales the type), partial selection of type-area anchors by marquee | 14–19 |
 | Type advanced | 4 | 50% | CJK composition for vertical type (ruby, mojikumi beyond Line-end Punctuation Half Width — the other sets (and their paragraph-start bracket and indent rules), custom kinsoku sets (beyond Hard, Soft and None) and the Mojikumi Settings dialog —, proportional vertical metrics, manual tate-chu-yoko), variable font axis sliders (named instances are styles), tab leaders, spell check (open dictionary), Touch Type, Retype; vertical point/area/path type and Type Orientation have initial support (beyond parity, not scored: inline symbols in text) | 20–28 |
@@ -146,6 +146,7 @@ const SHAPE: &[&str] = &["Effect", "Convert to Shape"];
 const STYLIZE: &[&str] = &["Effect", "Stylize"];
 const WARP: &[&str] = &["Effect", "Warp"];
 const BLUR: &[&str] = &["Effect", "Blur"];
+const DISTORT: &[&str] = &["Effect", "Distort"];
 const SHARPEN: &[&str] = &["Effect", "Sharpen"];
 const PIXELATE: &[&str] = &["Effect", "Pixelate"];
 const TEXTURE: &[&str] = &["Effect", "Texture"];
@@ -295,6 +296,27 @@ pub fn effect_catalog() -> Vec<EffectInfo> {
            "{radius: pt 0.1..100 (3), threshold: levels 0.1..100 (25; only colours closer than this blur together, so edges stay sharp), quality: \"low\"|\"medium\"|\"high\" (\"medium\"; 5, 7 or 9 samples across)} (Normal mode)",
            json!({"radius": 3.0, "threshold": 25.0, "quality": "medium"}),
        ),
+        r(
+            "distort.diffuseGlow",
+            "Diffuse Glow…",
+            DISTORT,
+            "{graininess: 0..10 (6; white grain, thicker in the glow), glowAmount: 0..20 (10), clearAmount: 0..20 (15; the higher, the more of the image stays clear of glow)} renders the object as if seen through a soft diffusion filter: its highlights glow white under see-through white grain",
+            json!({"graininess": 6.0, "glowAmount": 10.0, "clearAmount": 15.0}),
+        ),
+        r(
+            "distort.glass",
+            "Glass…",
+            DISTORT,
+            "{distortion: 0..20 (5), smoothness: 1..15 (3), texture: \"blocks\"|\"canvas\"|\"frosted\"|\"tinyLens\" (\"frosted\"; surfaces made in code), scaling: % 50..200 (100), invert: bool (false; turns the surface's heights over)} makes the object look as if seen through glass",
+            json!({"distortion": 5.0, "smoothness": 3.0, "texture": "frosted", "scaling": 100.0, "invert": false}),
+        ),
+        r(
+            "distort.oceanRipple",
+            "Ocean Ripple…",
+            DISTORT,
+            "{rippleSize: 1..15 (9), rippleMagnitude: 0..20 (9)} adds randomly spaced ripples, as if the object were under water",
+            json!({"rippleSize": 9.0, "rippleMagnitude": 9.0}),
+        ),
        r(
            "sharpen.unsharpMask",
            "Unsharp Mask…",
@@ -0,0 +1,200 @@
+//! Effect › Distort (Diffuse Glow, Glass, Ocean Ripple).
+//!
+//! Glass and Ocean Ripple move each pixel's content by a shift that a surface decides (the slope
+//! of Glass's texture, smooth noise for the ripples), sampling the object bilinearly. The shift is
+//! capped, so the object reaches no farther than [`glass_shift`] or [`ripple_shift`] past its
+//! bounds. Diffuse Glow brightens the object's highlights towards white and sprinkles it with
+//! white grain. Every surface lies in document space around the object's centre, as the Texture
+//! filters' do.
+
+use vectorcraft_geom::{Point, Vec2};
+
+use super::pixelate::{Place, value_noise};
+use super::texture::{Texture, cell_noise, luma, premultiply, smooth_noise, straight};
+use super::{PixelSpace, blur_plane, pick};
+
+const SALT_GLOW: u64 = 120;
+const SALT_FROST: u64 = 128;
+const SALT_RIPPLE: u64 = 136;
+
+/// Glass's surfaces, in its Texture menu's order: (label, parameter value).
+pub const GLASS_TEXTURES: [(&str, &str); 4] = [("Blocks", "blocks"), ("Canvas", "canvas"), ("Frosted", "frosted"), ("Tiny Lens", "tinyLens")];
+
+/// A Glass surface.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum GlassTexture {
+    Blocks,
+    Canvas,
+    Frosted,
+    TinyLens,
+}
+
+impl GlassTexture {
+    const ALL: [GlassTexture; 4] = [GlassTexture::Blocks, GlassTexture::Canvas, GlassTexture::Frosted, GlassTexture::TinyLens];
+
+    /// The surface of `value` (a [`GLASS_TEXTURES`] value, any case); Frosted otherwise.
+    pub fn parse(value: &str) -> Self {
+        pick(&GLASS_TEXTURES, &Self::ALL, value, GlassTexture::Frosted)
+    }
+
+    /// The surface's height at `p` (points at 100 %), in points: slopes of about 1 at most.
+    fn height(self, p: Point) -> f64 {
+        match self {
+            GlassTexture::Blocks => blocks(p),
+            GlassTexture::Canvas => Texture::Canvas.height(p),
+            GlassTexture::Frosted => frosted(p),
+            GlassTexture::TinyLens => tiny_lens(p),
+        }
+    }
+}
+
+/// Square glass blocks 10 points across, flat on top with 2.5-point bevels.
+fn blocks(p: Point) -> f64 {
+    const SIZE: f64 = 10.0;
+    const BEVEL: f64 = 2.5;
+    let to_edge = |v: f64| {
+        let t = v.rem_euclid(SIZE);
+        t.min(SIZE - t)
+    };
+    to_edge(p.x).min(to_edge(p.y)).min(BEVEL)
+}
+
+/// Frosted glass: two octaves of fine smooth noise (1.2 and 0.5 points).
+fn frosted(p: Point) -> f64 {
+    0.8 * value_noise(SALT_FROST, p.x / 1.2, p.y / 1.2) + 0.2 * value_noise(SALT_FROST + 1, p.x / 0.5, p.y / 0.5)
+}
+
+/// Tiny lenses 4 points across in rows and columns, each a shallow dome.
+fn tiny_lens(p: Point) -> f64 {
+    const SIZE: f64 = 4.0;
+    let r = 0.5 * SIZE;
+    let off = |v: f64| v.rem_euclid(SIZE) - r;
+    let d2 = off(p.x).powi(2) + off(p.y).powi(2);
+    0.5 * r * (1.0 - d2 / (r * r)).max(0.0)
+}
+
+/// The longest shift (points) Glass gives at `distortion` (0..20).
+pub(super) fn glass_shift(distortion: f64) -> f64 {
+    0.5 * distortion.clamp(0.0, 20.0)
+}
+
+/// The ripples' size (points) for Ripple Size `size` (1..15).
+fn ripple_wave(size: f64) -> f64 {
+    2.0 + size.clamp(1.0, 15.0)
+}
+
+/// The longest shift (points) Ocean Ripple gives for Ripple Size `size` (1..15) and Ripple
+/// Magnitude `magnitude` (0..20).
+pub(super) fn ripple_shift(size: f64, magnitude: f64) -> f64 {
+    0.03 * magnitude.clamp(0.0, 20.0) * ripple_wave(size)
+}
+
+/// How far (points) Diffuse Glow spreads the highlights (the σ of their blur).
+pub(super) const GLOW_SPREAD: f64 = 2.0;
+
+/// Glass: the object seen through a `texture` surface scaled by `scaling` (0.5..2), bent by
+/// `distortion` (0..20) and smoothed by `smoothness` (1..15); `invert` turns the surface's heights
+/// over.
+#[allow(clippy::too_many_arguments)] // the effect's five options
+pub(super) fn glass(
+    px: &mut [[u8; 4]],
+    w: usize,
+    h: usize,
+    space: &PixelSpace,
+    distortion: f64,
+    smoothness: f64,
+    texture: GlassTexture,
+    scaling: f64,
+    invert: bool,
+) {
+    let Some(place) = Place::new(space, w, h) else { return };
+    if !(scaling.is_finite() && scaling > 0.0 && smoothness.is_finite()) {
+        return;
+    }
+    // Slopes over a quarter point of the surface per step of Smoothness, or half a pixel where
+    // pixels are larger: a smoother glass bends the image more gently.
+    let step = (0.25 * smoothness.clamp(1.0, 15.0)).max(0.5 * place.px / scaling);
+    let gain = 0.25 * distortion.clamp(0.0, 20.0) * if invert { -1.0 } else { 1.0 };
+    displace(px, w, h, &place, glass_shift(distortion), |q| {
+        let t = Point::new(q.x / scaling, q.y / scaling);
+        let at = |dx: f64, dy: f64| texture.height(Point::new(t.x + dx, t.y + dy));
+        Vec2::new(at(step, 0.0) - at(-step, 0.0), at(0.0, step) - at(0.0, -step)) * (gain / (2.0 * step))
+    });
+}
+
+/// Ocean Ripple: the object as if under rippling water, ripples about `size` (1..15) points plus
+/// two across, shifting it by up to [`ripple_shift`].
+pub(super) fn ocean_ripple(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, size: f64, magnitude: f64) {
+    let Some(place) = Place::new(space, w, h) else { return };
+    let (wave, most) = (ripple_wave(size), ripple_shift(size, magnitude));
+    displace(px, w, h, &place, most, |q| {
+        let n = |salt: u64| 0.7 * smooth_noise(salt, q, wave) + 0.3 * smooth_noise(salt + 2, q, 0.5 * wave);
+        Vec2::new(n(SALT_RIPPLE), n(SALT_RIPPLE + 1)) * most
+    });
+}
+
+/// Diffuse Glow: the object as seen through a soft diffusion filter. Its highlights, softened over
+/// [`GLOW_SPREAD`], glow white as strongly as `glow` (0..20) says, from the brightness that
+/// `clear` (0..20) leaves clear of glow; white grain as dense as `graininess` (0..10) says is
+/// sprinkled over it, thicker in the glow.
+pub(super) fn diffuse_glow(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, graininess: f64, glow: f64, clear: f64) {
+    let Some(place) = Place::new(space, w, h) else { return };
+    let mut light: Vec<f32> = px.iter().map(|p| luma(straight(*p)) * f32::from(p[3]) / 255.0).collect();
+    blur_plane(&mut light, w, h, GLOW_SPREAD / place.px);
+    let amount = (glow / 20.0).clamp(0.0, 1.0) as f32;
+    let from = (0.9 * clear / 20.0).clamp(0.0, 0.9) as f32;
+    let grain = (graininess / 10.0).clamp(0.0, 1.0);
+    place.each(px, |x, y, p| {
+        if p[3] == 0 {
+            return;
+        }
+        let g = ((light.get(y * w + x).copied().unwrap_or(0.0) - from) / (1.0 - from)).clamp(0.0, 1.0);
+        let chance = 0.5 * (cell_noise(SALT_GLOW, place.at(x, y), 1.0, 0) + 1.0);
+        let dot = if chance < grain * (0.08 + 0.32 * f64::from(g)) { 0.55 } else { 0.0 };
+        let white = (amount * g + dot).min(1.0);
+        *p = premultiply(straight(*p).map(|v| v + (1.0 - v) * white), f32::from(p[3]) / 255.0);
+    });
+}
+
+/// Move the object's content by `shift(q)` (document units; `q` a pixel's centre relative to the
+/// object's centre, its length capped at `most`): each pixel takes the colour `shift` away from it,
+/// interpolated between pixels, transparent beyond the raster.
+fn displace(px: &mut [[u8; 4]], w: usize, h: usize, place: &Place, most: f64, shift: impl Fn(Point) -> Vec2) {
+    if !(most.is_finite() && most > 0.0) {
+        return;
+    }
+    let src = px.to_vec();
+    place.each(px, |x, y, p| {
+        let q = place.at(x, y);
+        let d = shift(q);
+        if !(d.x.is_finite() && d.y.is_finite()) {
+            return;
+        }
+        let len = d.hypot();
+        let d = if len > most { d * (most / len) } else { d };
+        let s = place.to_px * (q + d);
+        *p = sample(&src, w, h, s.x - 0.5, s.y - 0.5);
+    });
+}
+
+/// The premultiplied colour at (`x`, `y`) of `w` × `h` pixels (pixel centres at whole
+/// coordinates), interpolated between the four around it, transparent outside.
+fn sample(src: &[[u8; 4]], w: usize, h: usize, x: f64, y: f64) -> [u8; 4] {
+    if !(x.is_finite() && y.is_finite()) {
+        return [0; 4];
+    }
+    let (x0, y0) = (x.floor(), y.floor());
+    let (fx, fy) = (x - x0, y - y0);
+    let at = |i: f64, j: f64| -> [f64; 4] {
+        if i < 0.0 || j < 0.0 || i >= w as f64 || j >= h as f64 {
+            return [0.0; 4];
+        }
+        src.get(j as usize * w + i as usize).map_or([0.0; 4], |p| p.map(f64::from))
+    };
+    let (a, b, c, d) = (at(x0, y0), at(x0 + 1.0, y0), at(x0, y0 + 1.0), at(x0 + 1.0, y0 + 1.0));
+    std::array::from_fn(|k| {
+        let top = a[k] + (b[k] - a[k]) * fx;
+        let bottom = c[k] + (d[k] - c[k]) * fx;
+        (top + (bottom - top) * fy).round().clamp(0.0, 255.0) as u8
+    })
+}
@@ -1,5 +1,6 @@
-//! Photoshop-style raster effects (Effect › Blur › Radial Blur and Smart Blur, Pixelate › Color
-//! Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask, Stylize › Glowing
+//! Photoshop-style raster effects (Effect › Blur › Radial Blur and Smart Blur, Distort › Diffuse
+//! Glow, Glass and Ocean Ripple, Pixelate › Color Halftone, Crystallize, Mezzotint and Pointillize,
+//! Sharpen › Unsharp Mask, Stylize › Glowing
 //! Edges, Texture › Craquelure, Grain, Mosaic Tiles, Patchwork, Stained Glass and Texturizer, and
 //! Video › De-Interlace and NTSC Colors): filters over premultiplied RGBA8 pixels.
 //!
@@ -11,6 +12,7 @@
 //! - Beyond the raster's edges is transparency.

 mod blur;
+mod distort;
 mod edges;
 mod pixelate;
 mod sharpen;
@@ -22,13 +24,17 @@ use vectorcraft_geom::{Affine, Point, Rect};

 use crate::util::{flag, num, text};

+pub use distort::{GLASS_TEXTURES, GlassTexture};
 pub use pixelate::{MEZZOTINT_TYPES, Mezzotint};
 pub use texture::{GRAIN_TYPES, Grain, LIGHT_DIRECTIONS, Light, TEXTURES, Texture};

 /// The Photoshop-style effect ids (all raster effects, see [`crate::is_raster`]).
-pub const PIXEL_EFFECTS: [&str; 16] = [
+pub const PIXEL_EFFECTS: [&str; 19] = [
    "blur.radial",
    "blur.smart",
+    "distort.diffuseGlow",
+    "distort.glass",
+    "distort.oceanRipple",
    "pixelate.colorHalftone",
    "pixelate.crystallize",
    "pixelate.mezzotint",
@@ -56,6 +62,16 @@ pub enum PixelFx {
    /// whose colour differs from its own by no more than `threshold` levels, over a grid of
    /// `samples` × `samples` neighbours at most.
    SmartBlur { radius: f64, threshold: f64, samples: u32 },
+    /// Distort › Diffuse Glow: the highlights glow white as strongly as `glow` (0..20), from the
+    /// brightness `clear` (0..20) leaves clear, under white grain as dense as `graininess` (0..10).
+    DiffuseGlow { graininess: f64, glow: f64, clear: f64 },
+    /// Distort › Glass: the object seen through a `texture` surface scaled by `scaling` (0.5..2),
+    /// bent by `distortion` (0..20), smoothed by `smoothness` (1..15), its heights turned over when
+    /// `invert`.
+    Glass { distortion: f64, smoothness: f64, texture: GlassTexture, scaling: f64, invert: bool },
+    /// Distort › Ocean Ripple: the object under ripples of `size` (1..15) shifting it as much as
+    /// `magnitude` (0..20) says.
+    OceanRipple { size: f64, magnitude: f64 },
    /// Sharpen › Unsharp Mask: colours pushed away from a Gaussian blur of σ = `radius` by `amount`
    /// (1 = 100 %), where they differ from it by at least `threshold` levels.
    UnsharpMask { amount: f64, radius: f64, threshold: f64 },
@@ -149,6 +165,21 @@ pub(crate) fn parse(id: &str, p: &Value) -> Option<PixelFx> {
            threshold: num(p, "threshold", 25.0).clamp(0.1, 100.0),
            samples: quality([("low", 5), ("medium", 7), ("high", 9)], 7),
        },
+        "distort.diffuseGlow" => PixelFx::DiffuseGlow {
+            graininess: num(p, "graininess", 6.0).clamp(0.0, 10.0),
+            glow: num(p, "glowAmount", 10.0).clamp(0.0, 20.0),
+            clear: num(p, "clearAmount", 15.0).clamp(0.0, 20.0),
+        },
+        "distort.glass" => PixelFx::Glass {
+            distortion: num(p, "distortion", 5.0).clamp(0.0, 20.0),
+            smoothness: num(p, "smoothness", 3.0).clamp(1.0, 15.0),
+            texture: GlassTexture::parse(text(p, "texture", "frosted")),
+            scaling: num(p, "scaling", 100.0).clamp(50.0, 200.0) / 100.0,
+            invert: flag(p, "invert", false),
+        },
+        "distort.oceanRipple" => {
+            PixelFx::OceanRipple { size: num(p, "rippleSize", 9.0).clamp(1.0, 15.0), magnitude: num(p, "rippleMagnitude", 9.0).clamp(0.0, 20.0) }
+        }
        "sharpen.unsharpMask" => PixelFx::UnsharpMask {
            amount: num(p, "amount", 50.0).clamp(1.0, 500.0) / 100.0,
            radius: num(p, "radius", 1.0).clamp(0.1, 250.0),
@@ -217,6 +248,10 @@ impl PixelFx {
            PixelFx::RadialBlur { zoom: false, .. } => (far - near).max(0.0),
            PixelFx::RadialBlur { amount, zoom: true, .. } => far * (blur::zoom_extent(amount).exp() - 1.0),
            PixelFx::SmartBlur { radius, .. } => radius,
+            PixelFx::DiffuseGlow { .. } => 0.0,
+            // Content shifted outwards reaches past the bounds by as much as the shift.
+            PixelFx::Glass { distortion, .. } => distort::glass_shift(distortion),
+            PixelFx::OceanRipple { size, magnitude } => distort::ripple_shift(size, magnitude),
            PixelFx::UnsharpMask { .. } => 0.0,
            PixelFx::GlowingEdges { width, smoothness, .. } => width.max(smoothness * 3.0),
            PixelFx::ColorHalftone { .. }
@@ -240,6 +275,9 @@ impl PixelFx {
        match *self {
            PixelFx::RadialBlur { .. } => None,
            PixelFx::SmartBlur { radius, .. } => Some(radius),
+            PixelFx::DiffuseGlow { .. } => Some(3.0 * distort::GLOW_SPREAD),
+            PixelFx::Glass { distortion, .. } => Some(distort::glass_shift(distortion)),
+            PixelFx::OceanRipple { size, magnitude } => Some(distort::ripple_shift(size, magnitude)),
            PixelFx::UnsharpMask { radius, .. } => Some(3.0 * radius),
            PixelFx::GlowingEdges { width, smoothness, .. } => Some(width.max(smoothness * 3.0)),
            // The cells around the pixel's, and the cells around theirs.
@@ -268,6 +306,11 @@ impl PixelFx {
        match *self {
            PixelFx::RadialBlur { amount, zoom, passes } => blur::radial(px, w, h, space, amount, zoom, passes),
            PixelFx::SmartBlur { radius, threshold, samples } => blur::smart(px, w, h, to_px(radius), threshold, samples),
+            PixelFx::DiffuseGlow { graininess, glow, clear } => distort::diffuse_glow(px, w, h, space, graininess, glow, clear),
+            PixelFx::Glass { distortion, smoothness, texture, scaling, invert } => {
+                distort::glass(px, w, h, space, distortion, smoothness, texture, scaling, invert)
+            }
+            PixelFx::OceanRipple { size, magnitude } => distort::ocean_ripple(px, w, h, space, size, magnitude),
            PixelFx::UnsharpMask { amount, radius, threshold } => sharpen::unsharp(px, w, h, amount, to_px(radius), threshold),
            PixelFx::GlowingEdges { width, brightness, smoothness } => edges::glow(px, w, h, to_px(width), brightness, to_px(smoothness)),
            PixelFx::ColorHalftone { max_radius, angles } => pixelate::color_halftone(px, w, h, space, max_radius, angles),
@@ -826,3 +826,159 @@ fn texture_patterns_follow_the_object_at_any_resolution() {
        assert_eq!(shifted, one, "{id}");
    }
 }
+
+#[test]
+fn distort_params_take_defaults_and_stay_in_range() {
+    assert_eq!(fx("distort.diffuseGlow", json!({})), PixelFx::DiffuseGlow { graininess: 6.0, glow: 10.0, clear: 15.0 });
+    assert_eq!(
+        fx("distort.diffuseGlow", json!({"graininess": 1e9, "glowAmount": -3, "clearAmount": "x"})),
+        PixelFx::DiffuseGlow { graininess: 10.0, glow: 0.0, clear: 15.0 }
+    );
+    assert_eq!(
+        fx("distort.glass", json!({})),
+        PixelFx::Glass { distortion: 5.0, smoothness: 3.0, texture: GlassTexture::Frosted, scaling: 1.0, invert: false }
+    );
+    assert_eq!(
+        fx("distort.glass", json!({"distortion": 1e308, "smoothness": 0, "texture": "TINYLENS", "scaling": 1, "invert": true})),
+        PixelFx::Glass { distortion: 20.0, smoothness: 1.0, texture: GlassTexture::TinyLens, scaling: 0.5, invert: true }
+    );
+    assert_eq!(fx("distort.glass", json!({"texture": "bubbles"})), fx("distort.glass", json!({})));
+    assert_eq!(fx("distort.oceanRipple", json!({})), PixelFx::OceanRipple { size: 9.0, magnitude: 9.0 });
+    assert_eq!(fx("distort.oceanRipple", json!({"rippleSize": 99, "rippleMagnitude": -1})), PixelFx::OceanRipple { size: 15.0, magnitude: 0.0 });
+    // Shifted content reaches past the bounds by the longest shift, and comes from as far.
+    let b = Rect::new(0.0, 0.0, 100.0, 50.0);
+    let glass = fx("distort.glass", json!({"distortion": 20}));
+    assert_eq!((glass.outset(b), glass.reach()), (10.0, Some(10.0)));
+    let ripple = fx("distort.oceanRipple", json!({}));
+    assert!((ripple.outset(b) - 0.03 * 9.0 * 11.0).abs() < 1e-9 && ripple.reach() == Some(ripple.outset(b)));
+    assert_eq!(fx("distort.diffuseGlow", json!({})).outset(b), 0.0);
+}
+
+/// Vertical stripes 5 points wide (out of step with every glass surface), alternately light and
+/// dark, over the whole raster.
+fn stripes(w: usize, h: usize) -> Vec<u8> {
+    image(w, h, |x, _| if (x / 5) % 2 == 0 { [230, 200, 60, 255] } else { [20, 40, 120, 255] })
+}
+
+#[test]
+fn glass_bends_the_image_by_its_texture() {
+    let (w, h) = (48, 40);
+    let src = stripes(w, h);
+    let run = |p: serde_json::Value| {
+        let mut d = src.clone();
+        fx("distort.glass", p).apply(&mut d, w, h, &space(w, h));
+        d
+    };
+    // No distortion, no change.
+    assert_eq!(run(json!({"distortion": 0})), src);
+    let mut seen = vec![];
+    for (_, texture) in GLASS_TEXTURES {
+        let bent = run(json!({"texture": texture, "distortion": 12}));
+        assert_ne!(bent, src, "{texture}");
+        assert!(!seen.contains(&bent), "{texture} differs from the other textures");
+        assert_ne!(run(json!({"texture": texture, "distortion": 12, "invert": true})), bent, "{texture} inverted");
+        // A colour moves; none is invented: every pixel blends two neighbouring stripes at most
+        // (those within a shift of the raster's edges also take in the transparency beyond it).
+        for (x, y) in (6..w - 6).flat_map(|x| (6..h - 6).map(move |y| (x, y))) {
+            let p = at(&bent, w, x, y);
+            assert!(p[3] == 255 && p[0] >= 20 && p[0] <= 230, "{texture} at ({x}, {y}): {p:?}");
+        }
+        seen.push(bent);
+    }
+    // Smoother glass bends the stripes differently (more gently).
+    assert_ne!(run(json!({"distortion": 12, "smoothness": 15})), run(json!({"distortion": 12, "smoothness": 1})));
+}
+
+#[test]
+fn ocean_ripple_moves_content_no_farther_than_its_magnitude() {
+    let (w, h) = (64, 32);
+    // The left half white, the right half transparent.
+    let src = image(w, h, |x, _| if x < 32 { grey(255) } else { [0; 4] });
+    let mut d = src.clone();
+    fx("distort.oceanRipple", json!({"rippleMagnitude": 0})).apply(&mut d, w, h, &space(w, h));
+    assert_eq!(d, src, "no magnitude, no ripples");
+    let f = fx("distort.oceanRipple", json!({"rippleSize": 6, "rippleMagnitude": 20}));
+    let most = f.reach().unwrap();
+    let mut d = src.clone();
+    f.apply(&mut d, w, h, &space(w, h));
+    assert_ne!(d, src);
+    // Away from the white's edge, and from the raster's (beyond which is transparency), nothing
+    // changes.
+    let inside = |v: usize, n: usize| (v as f64 + 0.5).min(n as f64 - v as f64 - 0.5) > most + 1.0;
+    for y in (0..h).filter(|y| inside(*y, h)) {
+        for x in (0..w).filter(|x| inside(*x, w)) {
+            let to_edge = (x as f64 + 0.5 - 32.0).abs();
+            if to_edge > most + 1.0 {
+                assert_eq!(at(&d, w, x, y), at(&src, w, x, y), "({x}, {y}) is {to_edge} from the edge, past {most}");
+            }
+        }
+    }
+    // The edge wanders: some rows reach farther right than others.
+    let ends: Vec<usize> = (0..h).map(|y| (0..w).filter(|x| at(&d, w, *x, y)[3] > 127).count()).collect();
+    assert!(ends.iter().min() != ends.iter().max(), "{ends:?}");
+}
+
+#[test]
+fn diffuse_glow_whitens_the_highlights_and_sprinkles_grain() {
+    let (w, h) = (48, 48);
+    // Dark on the left, light on the right, a transparent margin round them.
+    let src = image(w, h, |x, y| {
+        if !(4..44).contains(&x) || !(4..44).contains(&y) {
+            [0; 4]
+        } else if x < 24 {
+            [30, 30, 60, 255]
+        } else {
+            [200, 190, 170, 255]
+        }
+    });
+    let run = |p: serde_json::Value| {
+        let mut d = src.clone();
+        fx("distort.diffuseGlow", p).apply(&mut d, w, h, &space(w, h));
+        d
+    };
+    let clean = run(json!({"graininess": 0}));
+    // Transparency stays; the shadows stay clear; the highlights glow.
+    for (a, b) in clean.as_chunks::<4>().0.iter().zip(src.as_chunks::<4>().0) {
+        assert_eq!(a[3], b[3]);
+    }
+    assert_eq!(at(&clean, w, 10, 24), at(&src, w, 10, 24));
+    let (lit, before) = (at(&clean, w, 36, 24), at(&src, w, 36, 24));
+    assert!((0..3).all(|c| lit[c] > before[c]), "{lit:?} brighter than {before:?}");
+    // More Clear Amount leaves more of the image clear of glow.
+    assert!(at(&run(json!({"graininess": 0, "clearAmount": 20})), w, 36, 24)[0] < lit[0]);
+    assert_eq!(run(json!({"graininess": 0, "glowAmount": 0})), src);
+    // Grain: white specks, in the shadows too.
+    let grainy = run(json!({"graininess": 10}));
+    let specks = (4..24).flat_map(|x| (4..44).map(move |y| (x, y))).filter(|(x, y)| at(&grainy, w, *x, *y)[0] > 100).count();
+    assert!(specks > 10, "{specks} white specks in the shadows");
+}
+
+#[test]
+fn distort_patterns_follow_the_object_at_any_resolution() {
+    let (w, h) = (48, 48);
+    let art = |x: f64, y: f64| -> [u8; 4] {
+        if (8.0..40.0).contains(&x) && (8.0..40.0).contains(&y) { [(x * 5.0) as u8, (y * 5.0) as u8, 120, 255] } else { [0; 4] }
+    };
+    for (id, p) in [
+        ("distort.diffuseGlow", json!({"clearAmount": 5})),
+        ("distort.glass", json!({"texture": "blocks", "distortion": 8})),
+        ("distort.oceanRipple", json!({"rippleMagnitude": 12})),
+    ] {
+        let f = fx(id, p);
+        let mut one = image(w, h, |x, y| art(x as f64 + 0.5, y as f64 + 0.5));
+        f.apply(&mut one, w, h, &space(w, h));
+        let mut two = image(2 * w, 2 * h, |x, y| art((x as f64 + 0.5) / 2.0, (y as f64 + 0.5) / 2.0));
+        let fine = PixelSpace { to_doc: Affine::scale(0.5), px: 0.5, ..space(w, h) };
+        f.apply(&mut two, 2 * w, 2 * h, &fine);
+        let down = image(w, h, |x, y| {
+            let q = [(0, 0), (1, 0), (0, 1), (1, 1)].map(|(dx, dy)| at(&two, 2 * w, 2 * x + dx, 2 * y + dy));
+            std::array::from_fn(|c| (q.iter().map(|p| u32::from(p[c])).sum::<u32>() / 4) as u8)
+        });
+        let diff = one.iter().zip(&down).map(|(a, b)| f64::from(a.abs_diff(*b))).sum::<f64>() / one.len() as f64;
+        assert!(diff < 12.0, "{id}: {diff}");
+        let moved = PixelSpace { to_doc: Affine::translate((7.0, 3.0)), center: Point::new(31.0, 27.0), ..space(w, h) };
+        let mut shifted = image(w, h, |x, y| art(x as f64 + 0.5, y as f64 + 0.5));
+        f.apply(&mut shifted, w, h, &moved);
+        assert_eq!(shifted, one, "{id}");
+    }
+}
@@ -83,7 +83,7 @@ impl Texture {
    }

    /// The surface's height at `p` (points at 100 %), in points: slopes of about 1 at most.
-    fn height(self, p: Point) -> f64 {
+    pub(super) fn height(self, p: Point) -> f64 {
        match self {
            Texture::Brick => brick(p),
            Texture::Burlap => weave(p, 7.0, true),
@@ -155,13 +155,13 @@ const SALT_SURFACE: u64 = 112;
 pub(super) const CONTOUR_SOFTNESS: f64 = 1.0 / 6.0;

 /// A pixel's straight colour (0..1).
-fn straight(p: [u8; 4]) -> [f32; 3] {
+pub(super) fn straight(p: [u8; 4]) -> [f32; 3] {
    let a = f32::from(p[3]);
    [p[0], p[1], p[2]].map(|v| if a > 0.0 { (f32::from(v) / a).min(1.0) } else { 0.0 })
 }

 /// The pixel of straight colour `c` at coverage `alpha` (0..1), premultiplied.
-fn premultiply(c: [f32; 3], alpha: f32) -> [u8; 4] {
+pub(super) fn premultiply(c: [f32; 3], alpha: f32) -> [u8; 4] {
    let a = (alpha.clamp(0.0, 1.0) * 255.0).round();
    let [r, g, b] = c.map(|v| (v.clamp(0.0, 1.0) * a).round().min(a) as u8);
    [r, g, b, a as u8]
@@ -185,7 +185,7 @@ fn cover(d: f64, px: f64) -> f64 {
 }

 /// The luma of colour `c` (Rec. 601 weights).
-fn luma(c: [f32; 3]) -> f32 {
+pub(super) fn luma(c: [f32; 3]) -> f32 {
    0.299 * c[0] + 0.587 * c[1] + 0.114 * c[2]
 }

@@ -308,7 +308,7 @@ pub(super) fn craquelure(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSp
 }

 /// A random value in [-1, 1) for the `size`-point cell holding `q`; `k` picks one of several.
-fn cell_noise(salt: u64, q: Point, size: f64, k: u64) -> f64 {
+pub(super) fn cell_noise(salt: u64, q: Point, size: f64, k: u64) -> f64 {
    match (cell(q.x / size), cell(q.y / size)) {
        (Some(i), Some(j)) => 2.0 * rand(salt, i, j, k) - 1.0,
        _ => 0.0,
@@ -316,7 +316,7 @@ fn cell_noise(salt: u64, q: Point, size: f64, k: u64) -> f64 {
 }

 /// [`value_noise`] in [-1, 1) over cells `size` points wide.
-fn smooth_noise(salt: u64, q: Point, size: f64) -> f64 {
+pub(super) fn smooth_noise(salt: u64, q: Point, size: f64) -> f64 {
    2.0 * value_noise(salt, q.x / size, q.y / size) - 1.0
 }

@@ -1,5 +1,5 @@
-//! The Photoshop-style raster effects (Effect › Blur › Radial Blur and Smart Blur, Pixelate ›
-//! Color Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask, Texture ›
+//! The Photoshop-style raster effects (Effect › Blur › Radial Blur and Smart Blur, Distort ›
+//! Diffuse Glow, Glass and Ocean Ripple, Pixelate › Color Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask, Texture ›
 //! Craquelure, Grain, Mosaic Tiles, Patchwork, Stained Glass and Texturizer, Video): applied and
 //! edited as commands, listed in the catalogue, drawn on the canvas, and written to PDF and SVG
 //! as images of the effected object.
@@ -18,6 +18,11 @@ const EFFECTS: [(&str, &str); 3] = [
    ("sharpen.unsharpMask", r#"{"amount": 300, "radius": 3}"#),
 ];

+/// Effect › Distort (Diffuse Glow with its highlights glowing from a low brightness up, as the
+/// striped art's reds are dark).
+const DISTORT: [(&str, &str); 3] =
+    [("distort.diffuseGlow", r#"{"clearAmount": 0, "glowAmount": 20}"#), ("distort.glass", "{}"), ("distort.oceanRipple", "{}")];
+
 /// Effect › Pixelate, at their defaults.
 const PIXELATE: [(&str, &str); 4] =
    [("pixelate.colorHalftone", "{}"), ("pixelate.crystallize", "{}"), ("pixelate.mezzotint", "{}"), ("pixelate.pointillize", "{}")];
@@ -73,6 +78,7 @@ fn listed_applied_edited_and_undone() {
        EFFECTS.iter().map(|(id, _)| list["catalog"].as_array().unwrap().iter().find(|e| e["id"] == *id).unwrap()["menu"].clone()).collect();
    assert_eq!(menus, [json!(["Effect", "Blur"]), json!(["Effect", "Blur"]), json!(["Effect", "Sharpen"])]);
    for (group, menu) in [
+        (DISTORT.as_slice(), "Distort"),
        (PIXELATE.as_slice(), "Pixelate"),
        (TEXTURE.as_slice(), "Texture"),
        (VIDEO.as_slice(), "Video"),
@@ -102,7 +108,7 @@ fn listed_applied_edited_and_undone() {

 #[test]
 fn each_effect_changes_the_canvas_and_draws_the_same_twice() {
-    for (id, params) in EFFECTS.into_iter().chain(PIXELATE).chain(TEXTURE).chain(VIDEO) {
+    for (id, params) in EFFECTS.into_iter().chain(DISTORT).chain(PIXELATE).chain(TEXTURE).chain(VIDEO) {
        let (mut s, g) = striped();
        let plain = render(&s);
        let params: Value = serde_json::from_str(params).unwrap();
@@ -131,7 +137,7 @@ fn spin_blur_reaches_past_the_corners() {

 #[test]
 fn pdf_and_svg_write_the_effected_object_as_an_image() {
-    for (id, params) in EFFECTS.into_iter().chain(PIXELATE).chain(TEXTURE).chain(VIDEO) {
+    for (id, params) in EFFECTS.into_iter().chain(DISTORT).chain(PIXELATE).chain(TEXTURE).chain(VIDEO) {
        let (mut s, g) = striped();
        let params: Value = serde_json::from_str(params).unwrap();
        s.execute("effect.apply", &json!({"effect": id, "ids": [g], "params": params})).unwrap();
@@ -307,6 +307,9 @@ fn structured_junk() {
        ),
        ("effect.apply", json!({"effect": "video.deinterlace", "params": {"eliminate": 7, "create": ["x"]}})),
        ("effect.apply", json!({"effect": "video.ntscColors", "params": {"junk": 1e308}})),
+        ("effect.apply", json!({"effect": "distort.diffuseGlow", "params": {"graininess": "x", "glowAmount": 1e308, "clearAmount": -1e308}})),
+        ("effect.apply", json!({"effect": "distort.glass", "params": {"distortion": 1e308, "smoothness": "NaN", "texture": 3, "scaling": -1}})),
+        ("effect.apply", json!({"effect": "distort.oceanRipple", "params": {"rippleSize": [1], "rippleMagnitude": 1e308}})),
        ("effect.apply", json!({"effect": "no.such.effect"})),
        ("effect.remove", json!({"index": 99})),
        ("effect.setParams", json!({"index": 0, "params": null})),
@@ -159,6 +159,7 @@ fn choices(effect: &str, key: &str) -> Option<form::Choices> {
        ("blur.radial", "method") => Some(&[("Spin", "spin"), ("Zoom", "zoom")]),
        ("blur.radial", "quality") => Some(&[("Draft", "draft"), ("Good", "good"), ("Best", "best")]),
        ("blur.smart", "quality") => Some(&[("Low", "low"), ("Medium", "medium"), ("High", "high")]),
+        ("distort.glass", "texture") => Some(&vectorcraft_effects::pixel::GLASS_TEXTURES),
        ("pixelate.mezzotint", "type") => Some(&vectorcraft_effects::pixel::MEZZOTINT_TYPES),
        ("texture.grain", "grainType") => Some(&vectorcraft_effects::pixel::GRAIN_TYPES),
        ("texture.texturizer", "texture") => Some(&vectorcraft_effects::pixel::TEXTURES),
@@ -674,3 +674,7 @@
 	Texturizer…	Texturovač…
 	System Title Bar	Systémové záhlaví okna
 	Exit	Ukončit
+	Distort	Zkreslení
+	Diffuse Glow…	Rozptýlená záře…
+	Glass…	Sklo…
+	Ocean Ripple…	Vlnky na hladině…
@@ -3938,3 +3938,19 @@ theme	Appearance	Erscheinungsbild
 	On Both Sides	Auf beiden Seiten
 	Short	Kurz
 	Full Width	Volle Breite
+	Distort	Verzerren
+	Diffuse Glow…	Weiches Licht…
+	Glass…	Glas…
+	Ocean Ripple…	Ozeanwellen…
+	Diffuse Glow	Weiches Licht
+	Glass	Glas
+	Ocean Ripple	Ozeanwellen
+	Graininess	Körnung
+	Glow Amount	Lichtmenge
+	Clear Amount	Klarer Bereich
+	Ripple Size	Wellengröße
+	Ripple Magnitude	Wellenstärke
+	Blocks	Blöcke
+	Frosted	Mattiert
+	Tiny Lens	Kleine Linsen
+	Canvas	Leinwand
@@ -3982,3 +3982,18 @@ axis	Both	Ambos
 	On Both Sides	En ambos lados
 	Short	Corta
 	Full Width	Ancho completo
+	Distort	Distorsionar
+	Diffuse Glow…	Resplandor difuso…
+	Glass…	Vidrio…
+	Ocean Ripple…	Rizo oceánico…
+	Diffuse Glow	Resplandor difuso
+	Glass	Vidrio
+	Ocean Ripple	Rizo oceánico
+	Graininess	Granulosidad
+	Glow Amount	Cantidad de resplandor
+	Clear Amount	Cantidad de claridad
+	Ripple Size	Tamaño de rizo
+	Ripple Magnitude	Magnitud de rizo
+	Blocks	Bloques
+	Frosted	Esmerilado
+	Tiny Lens	Lente pequeña
@@ -3994,3 +3994,18 @@ effect	Soft	Doux
 	On Both Sides	Des deux côtés
 	Short	Courte
 	Full Width	Toute la largeur
+	Distort	Déformation
+	Diffuse Glow…	Diffusion lumineuse…
+	Glass…	Verre…
+	Ocean Ripple…	Ondulation océanique…
+	Diffuse Glow	Diffusion lumineuse
+	Glass	Verre
+	Ocean Ripple	Ondulation océanique
+	Graininess	Granularité
+	Glow Amount	Intensité de la lueur
+	Clear Amount	Zone claire
+	Ripple Size	Taille de l'ondulation
+	Ripple Magnitude	Amplitude de l'ondulation
+	Blocks	Blocs
+	Frosted	Dépoli
+	Tiny Lens	Petites lentilles
@@ -3984,3 +3984,18 @@ effect	Regular	Normale
 	On Both Sides	Su entrambi i lati
 	Short	Breve
 	Full Width	Larghezza intera
+	Distort	Distorsione
+	Diffuse Glow…	Bagliore diffuso…
+	Glass…	Vetro…
+	Ocean Ripple…	Increspatura oceanica…
+	Diffuse Glow	Bagliore diffuso
+	Glass	Vetro
+	Ocean Ripple	Increspatura oceanica
+	Graininess	Granulosità
+	Glow Amount	Quantità di bagliore
+	Clear Amount	Quantità di chiarezza
+	Ripple Size	Dimensione increspatura
+	Ripple Magnitude	Ampiezza increspatura
+	Blocks	Blocchi
+	Frosted	Smerigliato
+	Tiny Lens	Lente piccola
@@ -3977,3 +3977,18 @@ effect	Vertical	垂直
 	On Both Sides	両側
 	Short	短い
 	Full Width	全幅
+	Distort	変形
+	Diffuse Glow…	光彩拡散…
+	Glass…	ガラス…
+	Ocean Ripple…	海の波紋…
+	Diffuse Glow	光彩拡散
+	Glass	ガラス
+	Ocean Ripple	海の波紋
+	Graininess	粒子
+	Glow Amount	光彩の量
+	Clear Amount	クリア量
+	Ripple Size	波紋のサイズ
+	Ripple Magnitude	波紋の強さ
+	Blocks	ブロック
+	Frosted	すりガラス
+	Tiny Lens	小さなレンズ
@@ -2734,3 +2734,7 @@
 	Texturizer…	Texturizador…
 	System Title Bar	Barra de título do sistema
 	Exit	Sair
+	Distort	Distorcer
+	Diffuse Glow…	Brilho difuso…
+	Glass…	Vidro…
+	Ocean Ripple…	Ondulação oceânica…
@@ -3980,3 +3980,18 @@ axis	Both	Оба
 	On Both Sides	С обеих сторон
 	Short	Короткие
 	Full Width	Во всю ширину
+	Distort	Искажение
+	Diffuse Glow…	Рассеянное свечение…
+	Glass…	Стекло…
+	Ocean Ripple…	Океанские волны…
+	Diffuse Glow	Рассеянное свечение
+	Glass	Стекло
+	Ocean Ripple	Океанские волны
+	Graininess	Зернистость
+	Glow Amount	Сила свечения
+	Clear Amount	Чистые области
+	Ripple Size	Размер волн
+	Ripple Magnitude	Сила волн
+	Blocks	Блоки
+	Frosted	Матовое
+	Tiny Lens	Мелкие линзы
@@ -3965,3 +3965,18 @@ axis	Both	Обидві
 	On Both Sides	З обох боків
 	Short	Короткі
 	Full Width	На всю ширину
+	Distort	Спотворення
+	Diffuse Glow…	Розсіяне світіння…
+	Glass…	Скло…
+	Ocean Ripple…	Океанські хвилі…
+	Diffuse Glow	Розсіяне світіння
+	Glass	Скло
+	Ocean Ripple	Океанські хвилі
+	Graininess	Зернистість
+	Glow Amount	Сила світіння
+	Clear Amount	Чисті ділянки
+	Ripple Size	Розмір хвиль
+	Ripple Magnitude	Сила хвиль
+	Blocks	Блоки
+	Frosted	Матове
+	Tiny Lens	Дрібні лінзи
@@ -3613,3 +3613,18 @@ effect	Vertical	垂直
 	On Both Sides	两侧
 	Short	短
 	Full Width	全宽
+	Distort	扭曲
+	Diffuse Glow…	扩散亮光…
+	Glass…	玻璃…
+	Ocean Ripple…	海洋波纹…
+	Diffuse Glow	扩散亮光
+	Glass	玻璃
+	Ocean Ripple	海洋波纹
+	Graininess	颗粒
+	Glow Amount	发光量
+	Clear Amount	清除数量
+	Ripple Size	波纹大小
+	Ripple Magnitude	波纹幅度
+	Blocks	块状
+	Frosted	磨砂
+	Tiny Lens	小镜头
@@ -3394,3 +3394,18 @@ effect	Soft	柔和
 	On Both Sides	兩側
 	Short	短
 	Full Width	全寬
+	Distort	扭曲
+	Diffuse Glow…	擴散光暈…
+	Glass…	玻璃…
+	Ocean Ripple…	海洋波紋…
+	Diffuse Glow	擴散光暈
+	Glass	玻璃
+	Ocean Ripple	海洋波紋
+	Graininess	顆粒
+	Glow Amount	光暈量
+	Clear Amount	清除量
+	Ripple Size	波紋大小
+	Ripple Magnitude	波紋強度
+	Blocks	塊狀
+	Frosted	磨砂
+	Tiny Lens	小鏡頭
@@ -3297,8 +3297,9 @@ fn font_items(english_names: bool) -> Vec<Item> {

 /// The raster effects' submenus of the Effect menu (the Photoshop-style effects, below the
 /// vector effects): (submenu, the catalogue's menu path of its effects).
-const RASTER_MENUS: [(&str, &[&str]); 5] = [
+const RASTER_MENUS: [(&str, &[&str]); 6] = [
    ("Blur", &["Effect", "Blur"]),
+    ("Distort", &["Effect", "Distort"]),
    ("Pixelate", &["Effect", "Pixelate"]),
    ("Sharpen", &["Effect", "Sharpen"]),
    ("Texture", &["Effect", "Texture"]),
@@ -78,6 +78,23 @@ fn effect_menu_lists_the_video_filters_last() {
    assert!(at("Sharpen") < at("Video"));
 }

+/// Effect › Distort, between Blur and Pixelate: each filter opens its dialog.
+#[test]
+fn effect_menu_lists_the_distort_filters_between_blur_and_pixelate() {
+    let app = app();
+    let entries = menus::menu_entries(&app);
+    let distort: Vec<_> = entries.iter().filter(|e| e.path == ["Effect", "Distort"]).collect();
+    let labels: Vec<&str> = distort.iter().map(|e| e.label.as_str()).collect();
+    assert_eq!(labels, ["Diffuse Glow…", "Glass…", "Ocean Ripple…"]);
+    assert!(distort.iter().all(|e| e.command.as_deref() == Some("effect.dialog")));
+    let raster: Vec<&str> =
+        entries.iter().filter_map(|e| e.path.get(1).filter(|_| e.path.len() == 2 && e.path[0] == "Effect")).map(String::as_str).collect();
+    let at = |name: &str| raster.iter().position(|s| *s == name).unwrap();
+    assert!(at("Blur") < at("Distort") && at("Distort") < at("Pixelate"));
+    // The vector Distort & Transform stays its own submenu.
+    assert!(raster.contains(&"Distort & Transform"));
+}
+
 /// Effect › Texture, between Sharpen and Video: each filter opens its dialog.
 #[test]
 fn effect_menu_lists_the_texture_filters_between_sharpen_and_video() {