Bump edition to now stable 2024 edition (shiny!).

libk/src/io/framebuffer.rs

@@ -1,52 +1,69 @@
 use limine::request::FramebufferRequest;
 
 #[used]
-#[link_section = ".requests"]
+#[unsafe(link_section = ".requests")]
 static FRAMEBUFFER_REQUEST: FramebufferRequest = FramebufferRequest::new();
 
 mod colour;
 
-pub use colour::Color;
+pub use colour::Colour;
 use core::panic;
 
 use limine::framebuffer::Framebuffer;
 use spin::{Lazy, Mutex};
 
-// use crate::{colour::Color, FRAMEBUFFER_REQUEST};
-
 pub static FRAMEBUFFER_WRITER: Lazy<Mutex<Option<FramebufferWriter>>> = Lazy::new(|| {
-    Mutex::new(
-        if let Some(framebuffer_response) = FRAMEBUFFER_REQUEST.get_response() {
-            let framebuffer = framebuffer_response.framebuffers().next().unwrap();
-            Some(FramebufferWriter::new(framebuffer))
-        } else {
+    Mutex::new(FRAMEBUFFER_REQUEST.get_response().map_or_else(
+        || {
             panic!("Framebuffer request failed");
         },
-    )
+        |framebuffer_response| {
+            let framebuffer = framebuffer_response.framebuffers().next().unwrap();
+            Some(FramebufferWriter::new(framebuffer))
+        },
+    ))
 });
 
-pub struct FramebufferWriter<'a> {
-    framebuffer: Framebuffer<'a>,
+/// The updated writer stores necessary fields from the [Framebuffer].
+/// This ensures that the contained types are Send, as Framebuffer was
+/// not marked as Send.
+///
+/// It also avoids the requirement for lifetimes.
+///
+/// Note this does not implement Writer as these functions only handle drawing pixels.
+pub struct FramebufferWriter {
+    pitch: u64,
+    bpp: u16,
+    addr: *mut u8,
+    width: u64,
+    height: u64,
 }
 
-unsafe impl<'a> Send for FramebufferWriter<'a> {}
-unsafe impl<'a> Sync for FramebufferWriter<'a> {}
-impl<'a> FramebufferWriter<'a> {
-    pub fn new(framebuffer: Framebuffer<'a>) -> Self {
-        Self { framebuffer }
-    }
+unsafe impl Send for FramebufferWriter {}
+unsafe impl Sync for FramebufferWriter {}
 
-    pub fn write_pixel(&self, x: usize, y: usize, color: Color) {
-        let pitch = self.framebuffer.pitch() as usize;
-        let bpp = (self.framebuffer.bpp() / 8) as usize;
-        let pixel_offset = y * pitch + x * bpp;
-
-        unsafe {
-            *(self.framebuffer.addr().add(pixel_offset) as *mut u32) = color.into();
+impl FramebufferWriter {
+    pub fn new(framebuffer: Framebuffer) -> Self {
+        Self {
+            pitch: framebuffer.pitch(),
+            bpp: framebuffer.bpp(),
+            addr: framebuffer.addr(),
+            width: framebuffer.width(),
+            height: framebuffer.height(),
         }
     }
 
-    pub fn render_frame(&self, buffer: &[Color; 1280 * 800]) {
+    pub fn write_pixel(&self, x: usize, y: usize, color: Colour) {
+        let pitch = self.pitch as usize;
+        let bpp = (self.bpp / 8) as usize;
+        let pixel_offset = y * pitch + x * bpp;
+
+        unsafe {
+            *(self.addr.add(pixel_offset) as *mut u32) = color.into();
+        }
+    }
+
+    pub fn render_frame(&self, buffer: &[Colour; 1280 * 800]) {
         for (y, row) in buffer.chunks(1280).enumerate() {
             for (x, pixel) in row.iter().enumerate() {
                 self.write_pixel(x, y, *pixel);
@@ -54,30 +71,29 @@ impl<'a> FramebufferWriter<'a> {
         }
     }
 
-    pub fn width(&self) -> u32 {
-        self.framebuffer.width() as u32
+    pub const fn width(&self) -> u32 {
+        self.width as u32
     }
 
-    pub fn height(&self) -> u32 {
-        self.framebuffer.height() as u32
+    pub const fn height(&self) -> u32 {
+        self.height as u32
     }
 
     pub fn clear(&self) {
-        let width = self.framebuffer.width() as usize;
-        let height = self.framebuffer.height() as usize;
+        let width = self.width as usize;
+        let height = self.height as usize;
 
         for y in 0..height {
             for x in 0..width {
-                self.write_pixel(x, y, Color::Black);
+                self.write_pixel(x, y, Colour::Black);
             }
         }
     }
 }
 
 pub fn screensize_px() -> (u32, u32) {
-    if let Some(writer) = FRAMEBUFFER_WRITER.lock().as_mut() {
-        (writer.width(), writer.height())
-    } else {
-        (0, 0)
-    }
+    FRAMEBUFFER_WRITER
+        .lock()
+        .as_mut()
+        .map_or_else(|| (0, 0), |writer| (writer.width(), writer.height()))
 }