fix(renderer): keep boxed glyphs visible

Author: eval-exec

neomacs-renderer-wgpu/src/renderer/content.rs

@@ -283,9 +283,9 @@ impl WgpuRenderer {
         //
         // Rendering order:
         //   1. Backgrounds (window bg, stretches, char bg)
-        //   2. Text (mask glyphs, color glyphs, composed)
-        //   3. Decorations (underline, overline, strikethrough)
-        //   4. Box borders (sharp and rounded)
+        //   2. Box borders (sharp and rounded)
+        //   3. Text (mask glyphs, color glyphs, composed)
+        //   4. Decorations (underline, overline, strikethrough)
         //   5. Inline media (images, videos, webkit)
         //   6. Cursors, borders, scroll bars (on top)
         let mut bg_vertices: Vec<RectVertex> = Vec::new();
@@ -1449,6 +1449,29 @@ impl WgpuRenderer {
                 pass.draw(0..rounded_fill_vertices.len() as u32, 0..1);
             }
 
+            // GNU draws character/composition box relief before the glyph so
+            // thick inset borders cannot cover a narrow character cell.
+            if let Some(upload) =
+                self.arenas
+                    .rect
+                    .upload(&self.device, &self.queue, &sharp_border_vertices)
+            {
+                pass.set_pipeline(rect_pl);
+                pass.set_bind_group(0, &self.uniform_bind_group, &[]);
+                pass.set_vertex_buffer(0, upload.buffer_slice());
+                pass.draw(0..sharp_border_vertices.len() as u32, 0..1);
+            }
+            if let Some(upload) =
+                self.arenas
+                    .rounded
+                    .upload(&self.device, &self.queue, &rounded_border_vertices)
+            {
+                pass.set_pipeline(rounded_rect_pl);
+                pass.set_bind_group(0, &self.uniform_bind_group, &[]);
+                pass.set_vertex_buffer(0, upload.buffer_slice());
+                pass.draw(0..rounded_border_vertices.len() as u32, 0..1);
+            }
+
             // --- Draw mask text glyphs ---
             if !mask_data.is_empty() {
                 let all_vertices: Vec<GlyphVertex> = mask_data
@@ -1593,30 +1616,6 @@ impl WgpuRenderer {
                 pass.draw(0..decoration_vertices.len() as u32, 0..1);
             }
 
-            // --- Draw sharp box borders ---
-            if let Some(upload) =
-                self.arenas
-                    .rect
-                    .upload(&self.device, &self.queue, &sharp_border_vertices)
-            {
-                pass.set_pipeline(rect_pl);
-                pass.set_bind_group(0, &self.uniform_bind_group, &[]);
-                pass.set_vertex_buffer(0, upload.buffer_slice());
-                pass.draw(0..sharp_border_vertices.len() as u32, 0..1);
-            }
-
-            // --- Draw rounded box borders ---
-            if let Some(upload) =
-                self.arenas
-                    .rounded
-                    .upload(&self.device, &self.queue, &rounded_border_vertices)
-            {
-                pass.set_pipeline(rounded_rect_pl);
-                pass.set_bind_group(0, &self.uniform_bind_group, &[]);
-                pass.set_vertex_buffer(0, upload.buffer_slice());
-                pass.draw(0..rounded_border_vertices.len() as u32, 0..1);
-            }
-
             // --- Draw inline images ---
             pass.set_pipeline(image_pl);
             pass.set_bind_group(0, &self.uniform_bind_group, &[]);

neomacs-renderer-wgpu/src/renderer/layer_text.rs

@@ -1,6 +1,6 @@
-//! Text phases of `render_frame_glyphs` (z-order steps 4-6): glyph batch
-//! building, batched text draws, text decorations, and box borders, run once
-//! for buffer text and once for overlay (mode-line/echo) text.
+//! Text phases of `render_frame_glyphs` (z-order steps 4-6): box borders,
+//! glyph batches, and text decorations, run once for buffer text and once for
+//! overlay (mode-line/echo) text.
 
 use neomacs_display_protocol::types::{FaceId, Rect};
 use std::collections::HashSet;
@@ -78,9 +78,9 @@ impl WgpuRenderer {
                 &batches.rendered_char_bounds,
             );
 
+            self.draw_box_borders(ctx, want_overlay, spans);
             self.draw_text_glyph_batches(ctx, want_overlay, glyph_atlas, &batches, stats);
             self.draw_text_decorations(ctx, want_overlay);
-            self.draw_box_borders(ctx, want_overlay, spans);
         }
 
         // Both passes ran: promote this frame's captured rows to the cache.

neomacs-renderer-wgpu/tests/offscreen_frame.rs

@@ -319,6 +319,95 @@ fn negative_box_line_width_paints_an_inset_border() {
     );
 }
 
+fn boxed_one_cell_frame() -> FrameGlyphBuffer {
+    let mut frame = FrameGlyphBuffer::with_size(W as f32, H as f32);
+    frame.background = Color::BLACK;
+    let face_id = FaceId::new(21);
+    frame.set_face(
+        face_id,
+        Color::WHITE,
+        Some(Color::rgb(0.2, 0.2, 0.2)),
+        400,
+        false,
+        0,
+        None,
+        0,
+        None,
+        0,
+        None,
+    );
+    let face = frame.faces.get_mut(&face_id).unwrap();
+    face.attributes |= FaceAttributes::BOX;
+    face.box_type = BoxType::Line;
+    face.box_color = Some(Color::BLACK);
+    face.box_line_width = (-4).into();
+    frame.set_draw_context(DisplayWindowId::new(1), GlyphRowRole::Text, None);
+    frame.add_char('p', 20.0, 20.0, 8.0, 18.0, 14.0, false);
+    frame
+}
+
+fn boxed_p_is_visible(buf: &[u8]) -> bool {
+    (20..28).any(|x| {
+        (20..38).any(|y| {
+            let pixel = px(buf, x, y);
+            pixel[0] > 120 && pixel[1] > 120 && pixel[2] > 120
+        })
+    })
+}
+
+#[test]
+fn negative_box_border_does_not_cover_a_one_cell_glyph() {
+    let Some(mut h) = try_harness() else {
+        return;
+    };
+    let frame = boxed_one_cell_frame();
+    h.renderer.render_frame_glyphs(
+        &h.view,
+        &frame,
+        &mut h.atlas,
+        W,
+        H,
+        false,
+        None,
+        (0.0, 0.0),
+        None,
+        None,
+        None,
+    );
+    let buf = read_back(&h);
+    assert!(
+        boxed_p_is_visible(&buf),
+        "GNU draws character glyphs over their box; the boxed `p` must remain visible"
+    );
+}
+
+#[test]
+fn child_frame_negative_box_border_does_not_cover_a_one_cell_glyph() {
+    let Some(mut h) = try_harness() else {
+        return;
+    };
+    let frame = boxed_one_cell_frame();
+    h.renderer.render_frame_content(
+        &h.view,
+        &frame,
+        &mut h.atlas,
+        W,
+        H,
+        0.0,
+        0.0,
+        false,
+        None,
+        0.0,
+        None,
+        None,
+    );
+    let buf = read_back(&h);
+    assert!(
+        boxed_p_is_visible(&buf),
+        "child-frame glyphs must be drawn over their boxes like GNU Emacs"
+    );
+}
+
 #[test]
 fn cursor_visible_false_suppresses_cursor() {
     let Some(mut h) = try_harness() else {