feat(graphics): add graphics demo showing all primitives

Add a visual demonstration of the graphics stack that runs during
kernel boot in interactive mode:

- demo.rs: Draws colorful shapes and text showcasing:
  - Filled and outlined rectangles in various colors
  - Circles (filled and outlined, concentric)
  - Radiating lines in a color gradient
  - Diagonal line patterns
  - Text in multiple colors (red, green, blue, yellow)
  - Highlighted text with background color
  - Multi-line text rendering

- Hooks into kernel_main() after double buffer upgrade
- Displays for 3 seconds before clearing and continuing boot
- Only runs with --features interactive

Also fixes Glyph::pixels() to use rasterized.raster() directly
and adds double_buffer_mut() accessor to ShellFrameBuffer.

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

Author: ryanbreen

kernel/src/graphics/demo.rs

@@ -0,0 +1,203 @@
+//! Graphics demonstration module.
+//!
+//! Provides a visual demo of the graphics stack capabilities
+//! that runs during kernel boot.
+
+use super::font::Font;
+use super::primitives::{
+    draw_circle, draw_line, draw_rect, draw_text, fill_circle, fill_rect, Canvas, Color, Rect,
+    TextStyle,
+};
+
+/// Run a graphics demonstration on the given canvas.
+///
+/// This draws various shapes and text to showcase the graphics stack.
+pub fn run_demo(canvas: &mut impl Canvas) {
+    let width = canvas.width() as i32;
+    let height = canvas.height() as i32;
+
+    // Clear to a dark blue background
+    fill_rect(
+        canvas,
+        Rect {
+            x: 0,
+            y: 0,
+            width: width as u32,
+            height: height as u32,
+        },
+        Color::rgb(20, 30, 50),
+    );
+
+    // Draw a header banner
+    fill_rect(
+        canvas,
+        Rect {
+            x: 0,
+            y: 0,
+            width: width as u32,
+            height: 60,
+        },
+        Color::rgb(40, 80, 120),
+    );
+
+    // Title text
+    let title_style = TextStyle::new()
+        .with_color(Color::WHITE)
+        .with_font(Font::default_font());
+
+    draw_text(canvas, 20, 20, "Breenix Graphics Stack Demo", &title_style);
+
+    // Draw colorful rectangles
+    let colors = [
+        Color::RED,
+        Color::GREEN,
+        Color::BLUE,
+        Color::rgb(255, 255, 0),   // Yellow
+        Color::rgb(255, 0, 255),   // Magenta
+        Color::rgb(0, 255, 255),   // Cyan
+    ];
+
+    let box_width = 80;
+    let box_height = 60;
+    let start_x = 50;
+    let start_y = 100;
+
+    for (i, &color) in colors.iter().enumerate() {
+        let x = start_x + (i as i32 % 3) * (box_width + 20);
+        let y = start_y + (i as i32 / 3) * (box_height + 20);
+
+        // Filled rectangle
+        fill_rect(
+            canvas,
+            Rect {
+                x,
+                y,
+                width: box_width as u32,
+                height: box_height as u32,
+            },
+            color,
+        );
+
+        // White border
+        draw_rect(
+            canvas,
+            Rect {
+                x: x - 2,
+                y: y - 2,
+                width: (box_width + 4) as u32,
+                height: (box_height + 4) as u32,
+            },
+            Color::WHITE,
+        );
+    }
+
+    // Draw circles section
+    let circle_y = start_y + 180;
+    let circle_text_style = TextStyle::new().with_color(Color::rgb(200, 200, 200));
+
+    draw_text(canvas, 50, circle_y, "Circles:", &circle_text_style);
+
+    // Filled circles
+    fill_circle(canvas, 100, circle_y + 60, 30, Color::rgb(255, 100, 100));
+    fill_circle(canvas, 180, circle_y + 60, 25, Color::rgb(100, 255, 100));
+    fill_circle(canvas, 250, circle_y + 60, 20, Color::rgb(100, 100, 255));
+
+    // Circle outlines
+    draw_circle(canvas, 340, circle_y + 60, 35, Color::WHITE);
+    draw_circle(canvas, 340, circle_y + 60, 25, Color::rgb(255, 200, 0));
+    draw_circle(canvas, 340, circle_y + 60, 15, Color::rgb(255, 100, 0));
+
+    // Draw lines section
+    let lines_y = circle_y + 130;
+    draw_text(canvas, 50, lines_y, "Lines:", &circle_text_style);
+
+    // Draw radiating lines (pre-computed approximate directions)
+    // Using 12 directions at 30-degree increments
+    let center_x = 150;
+    let center_y = lines_y + 60;
+    let radius = 50i32;
+
+    // Pre-computed (cos, sin) * 100 for angles 0, 30, 60, ..., 330 degrees
+    let directions: [(i32, i32); 12] = [
+        (100, 0),    // 0°
+        (87, 50),    // 30°
+        (50, 87),    // 60°
+        (0, 100),    // 90°
+        (-50, 87),   // 120°
+        (-87, 50),   // 150°
+        (-100, 0),   // 180°
+        (-87, -50),  // 210°
+        (-50, -87),  // 240°
+        (0, -100),   // 270°
+        (50, -87),   // 300°
+        (87, -50),   // 330°
+    ];
+
+    for (i, (dx, dy)) in directions.iter().enumerate() {
+        let end_x = center_x + (radius * dx) / 100;
+        let end_y = center_y + (radius * dy) / 100;
+        let intensity = ((i as u32 * 255) / 12) as u8;
+        let color = Color::rgb(255, intensity, 255 - intensity);
+        draw_line(canvas, center_x, center_y, end_x, end_y, color);
+    }
+
+    // Draw diagonal lines
+    for i in 0..10 {
+        let x1 = 280 + i * 8;
+        let color = Color::rgb(50 + i as u8 * 20, 100 + i as u8 * 15, 200);
+        draw_line(canvas, x1, lines_y + 20, x1 + 60, lines_y + 100, color);
+    }
+
+    // Text rendering showcase
+    let text_y = lines_y + 140;
+    draw_text(canvas, 50, text_y, "Text Rendering:", &circle_text_style);
+
+    // Different colored text
+    let red_style = TextStyle::new().with_color(Color::RED);
+    let green_style = TextStyle::new().with_color(Color::GREEN);
+    let blue_style = TextStyle::new().with_color(Color::BLUE);
+    let yellow_style = TextStyle::new().with_color(Color::rgb(255, 255, 0));
+
+    draw_text(canvas, 50, text_y + 30, "Red Text", &red_style);
+    draw_text(canvas, 150, text_y + 30, "Green Text", &green_style);
+    draw_text(canvas, 270, text_y + 30, "Blue Text", &blue_style);
+
+    // Text with background
+    let bg_style = TextStyle::new()
+        .with_color(Color::BLACK)
+        .with_background(Color::rgb(255, 255, 0));
+
+    draw_text(canvas, 50, text_y + 60, " Highlighted Text ", &bg_style);
+
+    // Multi-line text
+    let multiline_style = TextStyle::new().with_color(Color::rgb(180, 180, 255));
+    draw_text(
+        canvas,
+        50,
+        text_y + 95,
+        "Multi-line text:\n  Line 1\n  Line 2\n  Line 3",
+        &multiline_style,
+    );
+
+    // Footer
+    let footer_style = TextStyle::new().with_color(Color::rgb(100, 100, 100));
+    draw_text(
+        canvas,
+        50,
+        height - 40,
+        "Phase 4: Text Rendering Complete!",
+        &footer_style,
+    );
+
+    // Draw a decorative border
+    draw_rect(
+        canvas,
+        Rect {
+            x: 10,
+            y: 70,
+            width: (width - 20) as u32,
+            height: (height - 120) as u32,
+        },
+        Color::rgb(60, 100, 140),
+    );
+}

kernel/src/graphics/font.rs

@@ -155,18 +155,11 @@ impl Glyph {
         self.rasterized.height()
     }
 
-    /// Get the raster data as rows of intensity values (0-255).
-    /// Each row is a slice of bytes, one per pixel column.
-    pub fn raster(&self) -> &[[u8; 8]] {
-        // noto-sans-mono-bitmap returns fixed-width arrays
-        self.rasterized.raster()
-    }
-
     /// Iterate over the glyph pixels with coordinates and intensity.
     /// Yields (x, y, intensity) for each pixel.
     pub fn pixels(&self) -> impl Iterator<Item = (usize, usize, u8)> + '_ {
         let width = self.width();
-        self.raster().iter().enumerate().flat_map(move |(y, row)| {
+        self.rasterized.raster().iter().enumerate().flat_map(move |(y, row)| {
             row.iter()
                 .take(width)
                 .enumerate()

kernel/src/graphics/mod.rs

@@ -2,6 +2,7 @@
 //!
 //! Provides framebuffer abstractions used by the kernel graphics stack.
 
+pub mod demo;
 pub mod double_buffer;
 pub mod font;
 pub mod primitives;

kernel/src/logger.rs

@@ -141,6 +141,13 @@ impl ShellFrameBuffer {
         }
     }
 
+    /// Get mutable access to the double buffer (if available).
+    ///
+    /// Returns None if double buffering has not been enabled yet.
+    pub fn double_buffer_mut(&mut self) -> Option<&mut DoubleBufferedFrameBuffer> {
+        self.double_buffer.as_mut()
+    }
+
     /// Clear the framebuffer (fill with black)
     pub fn clear(&mut self) {
         self.x_pos = BORDER_PADDING;

kernel/src/main.rs

@@ -180,6 +180,33 @@ fn kernel_main(boot_info: &'static mut bootloader_api::BootInfo) -> ! {
     #[cfg(feature = "interactive")]
     logger::upgrade_to_double_buffer();
 
+    // Run graphics demo to showcase the graphics stack
+    #[cfg(feature = "interactive")]
+    {
+        log::info!("Running graphics demo...");
+        if let Some(fb) = logger::SHELL_FRAMEBUFFER.get() {
+            let mut fb_guard = fb.lock();
+            graphics::demo::run_demo(&mut *fb_guard);
+            // Flush the demo to screen (access double buffer directly)
+            if let Some(db) = fb_guard.double_buffer_mut() {
+                db.flush_full();
+            }
+            log::info!("Graphics demo complete - display showing for 3 seconds");
+        }
+        // Wait 3 seconds so user can see the demo
+        for _ in 0..30 {
+            // Simple delay loop (approximately 100ms each iteration)
+            for _ in 0..10_000_000 {
+                core::hint::spin_loop();
+            }
+        }
+        // Clear and continue to normal boot
+        if let Some(fb) = logger::SHELL_FRAMEBUFFER.get() {
+            let mut fb_guard = fb.lock();
+            fb_guard.clear();
+        }
+    }
+
     // Phase 0: Log kernel layout inventory
     memory::layout::log_kernel_layout();