M3.86: Alt-click the mask thumbnail to view only the mask

transparency.viewOpacityMask {on?, id?} shows only the opacity mask on the
canvas as greyscale coverage (luminance, clip and invert applied; the rest of
the art hidden) and enters mask editing; called again it shows the artwork and
keeps editing. The Transparency panel's mask thumbnail runs it on Alt-click and
is outlined in the accent colour while the mask is viewed. The state is
DocState.mask_view (shown while that mask is edited: DocState::shown_mask) and
reaches the renderer as RenderOptions.mask_view.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

crates/render/src/lib.rs

@@ -82,6 +82,9 @@ pub struct RenderOptions {
     /// Pattern editing mode's tile edge and swatch bounds colour (Object → Pattern → Tile Edge
     /// Color), RGB.
     pub tile_edge: [u8; 3],
+    /// View Opacity Mask (Alt-click the mask thumbnail): instead of the artwork, show this object's
+    /// opacity mask alone as its coverage in greyscale (white = opaque, black = transparent).
+    pub mask_view: Option<NodeId>,
 }
 
 impl Default for RenderOptions {
@@ -97,6 +100,7 @@ impl Default for RenderOptions {
             trim: false,
             skip_templates: false,
             tile_edge: vectorcraft_doc::LAYER_COLORS[0].1,
+            mask_view: None,
         }
     }
 }
@@ -323,6 +327,18 @@ impl Renderer {
         // Raster filters (drop shadow, glows, blur) are rendered offscreen on this thread when the
         // main context is multithreaded (see `fx::with_filters`).
         let threads = self.threads;
+        self.stats = FrameStats::default();
+        let inv = view.inverse();
+        let visible = inv.transform_rect_bbox(Rect::new(0.0, 0.0, w as f64, h as f64));
+        let px = 1.0 / view.determinant().abs().sqrt().max(1e-12);
+        let frame = Frame { mt: threads > 0, doc, view, visible, px, opts };
+        // View Opacity Mask: the mask's coverage in greyscale instead of the artwork.
+        if let Some(m) = opts.mask_view.and_then(|id| doc.node(id)).and_then(|n| n.mask.as_deref()) {
+            self.stamp += 1;
+            let pixels = self.mask_values(&frame, m, w, h).into_iter().flat_map(|v| [v, v, v, 255]).collect();
+            self.stats.micros = now().saturating_sub(start);
+            return Rendered { width: w as u32, height: h as u32, pixels };
+        }
         let slot = if threads == 0 { self.ctx_st.take() } else { self.ctx.take() };
         let mut ctx = match slot {
             Some(mut c) if c.width() == w && c.height() == h => {
@@ -331,12 +347,6 @@ impl Renderer {
             }
             _ => RenderContext::new_with(w, h, vello_cpu::RenderSettings { num_threads: threads, ..Default::default() }),
         };
-        self.stats = FrameStats::default();
-        let inv = view.inverse();
-        let visible = inv.transform_rect_bbox(Rect::new(0.0, 0.0, w as f64, h as f64));
-        let px = 1.0 / view.determinant().abs().sqrt().max(1e-12);
-        let frame = Frame { mt: threads > 0, doc, view, visible, px, opts };
-
         if let Some(bg) = opts.background {
             ctx.set_transform(Affine::IDENTITY);
             ctx.set_paint(peniko::Color::from_rgba8(bg[0], bg[1], bg[2], bg[3]));
@@ -548,6 +558,12 @@ impl Renderer {
 
     /// Render an opacity mask's art offscreen and turn its luminance into a coverage mask.
     fn opacity_mask(&mut self, f: &Frame, m: &vectorcraft_doc::OpacityMask, w: u16, h: u16) -> vello_cpu::Mask {
+        vello_cpu::Mask::from_parts(self.mask_values(f, m, w, h), w, h)
+    }
+
+    /// The coverage of opacity mask `m` per output pixel (row-major): its art rendered offscreen,
+    /// as luminance ([`mask_value`]).
+    fn mask_values(&mut self, f: &Frame, m: &vectorcraft_doc::OpacityMask, w: u16, h: u16) -> Vec<u8> {
         let mut mctx = single_threaded_context(w, h);
         // Mask art is a picture of its own: it takes no part in a knockout group around the object.
         let outer =
@@ -557,8 +573,7 @@ impl Renderer {
         mctx.flush();
         let mut pm = Pixmap::new(w, h);
         mctx.render(&mut pm, &mut self.resources);
-        let data = pm.data().iter().map(|p| mask_value(p.r, p.g, p.b, p.a, m.clip, m.invert)).collect();
-        vello_cpu::Mask::from_parts(data, w, h)
+        pm.data().iter().map(|p| mask_value(p.r, p.g, p.b, p.a, m.clip, m.invert)).collect()
     }
 
     /// Everything [`Self::draw_arc`] does after culling.