Trying to make 640x480x16 faster

Cargo.toml

@@ -28,3 +28,10 @@ x86_64 = "0.9.6"
 [dependencies.num-traits]
 version = "0.2.11"
 default-features = false
+
+[features]
+default = []
+alloc = []
+
+[package.metadata.docs.rs]
+features = ["alloc"]

src/configurations.rs

@@ -249,7 +249,7 @@ pub const MODE_640X480X16_CONFIGURATION: VgaConfiguration = VgaConfiguration {
     sequencer_registers: &[
         (SequencerIndex::SequencerReset, 0x03),
         (SequencerIndex::ClockingMode, 0x01),
-        (SequencerIndex::PlaneMask, 0x08),
+        (SequencerIndex::PlaneMask, 0x0F),
         (SequencerIndex::CharacterFont, 0x00),
         (SequencerIndex::MemoryMode, 0x06),
     ],
@@ -286,7 +286,7 @@ pub const MODE_640X480X16_CONFIGURATION: VgaConfiguration = VgaConfiguration {
         (GraphicsControllerIndex::ColorCompare, 0x00),
         (GraphicsControllerIndex::DataRotate, 0x00),
         (GraphicsControllerIndex::ReadPlaneSelect, 0x03),
-        (GraphicsControllerIndex::GraphicsMode, 0x00),
+        (GraphicsControllerIndex::GraphicsMode, 0x02),
         (GraphicsControllerIndex::Miscellaneous, 0x05),
         (GraphicsControllerIndex::ColorDontCare, 0x0F),
         (GraphicsControllerIndex::BitMask, 0xFF),

src/drawing/bresenham.rs

@@ -16,15 +16,15 @@ impl<T: SignedNum> Bresenham<T> {
         let start = octant.to(start);
         let end = octant.to(end);
 
-        let delta_x = end.0 - start.0;
+        let delta_x = end.x - start.x;
-        let delta_y = end.1 - start.1;
+        let delta_y = end.y - start.y;
 
         Self {
             delta_x,
             delta_y,
             octant,
             point: start,
-            end_x: end.0,
+            end_x: end.x,
             error: delta_y - delta_x,
         }
     }
@@ -38,15 +38,15 @@ where
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        if self.point.0 <= self.end_x {
+        if self.point.x <= self.end_x {
             let point = self.octant.from(self.point);
 
             if self.error >= T::zero() {
-                self.point.1 += T::one();
+                self.point.y += T::one();
                 self.error -= self.delta_x;
             }
 
-            self.point.0 += T::one();
+            self.point.x += T::one();
             self.error += self.delta_y;
 
             Some(point)

src/drawing/device.rs

@@ -0,0 +1,83 @@
+use super::Point;
+use crate::writers::{GraphicsWriter, Screen};
+use core::cmp::{max, min};
+
+/// A helper trait used to draw to the vga screen in graphics mode.
+pub trait Device<Color>
+where
+    Self: Screen + GraphicsWriter<Color>,
+    Color: Clone + Copy,
+{
+    /// Draws an 8x8 character at the given `(x, y)` coordinant to the specified `color`.
+    ///
+    /// **Note:** This does no bounds checking and will panick if
+    /// any of the pixels fall outside of the screen range.
+    /// `x + 8 >= self.get_width() || y + 8 >= self.get_height()`.
+    fn draw_character(&mut self, x: usize, y: usize, character: char, color: Color);
+
+    /// Draws a line from `start` to `end` with the specified `color`.
+    ///
+    /// **Note:** This does no bounds checking and will panick if
+    /// `x >= self.get_width() || y >= self.get_height()`.
+    fn draw_line(&mut self, start: Point<isize>, end: Point<isize>, color: Color);
+
+    /// Draws a triangle to the screen with the given points `(v0, v1, v2)`
+    /// and the given `color`.
+    ///
+    /// **Note:** This function will clip any pixels that are
+    /// not contained within the screen coordinates.
+    /// `x < 0 || x >= self.get_width() || y < 0 || y >= self.get_height()`.
+    fn draw_triangle(&mut self, v0: Point<i32>, v1: Point<i32>, v2: Point<i32>, color: Color) {
+        let screen_width = self.get_width() as i32;
+        let screen_height = self.get_height() as i32;
+        let (a01, b01) = (v0.y - v1.y, v1.x - v0.x);
+        let (a12, b12) = (v1.y - v2.y, v2.x - v1.x);
+        let (a20, b20) = (v2.y - v0.y, v0.x - v2.x);
+
+        let mut min_x = min(v0.x, min(v1.x, v2.x));
+        let mut min_y = min(v0.y, min(v1.y, v2.y));
+        let mut max_x = max(v0.x, max(v1.x, v2.x));
+        let mut max_y = max(v0.y, max(v1.y, v2.y));
+
+        min_x = max(min_x, 0);
+        min_y = max(min_y, 0);
+        max_x = min(max_x, screen_width - 1);
+        max_y = min(max_y, screen_height - 1);
+
+        let p = Point::new(min_x, min_y);
+        let mut w0_row = orient2d(v1, v2, p);
+        let mut w1_row = orient2d(v2, v0, p);
+        let mut w2_row = orient2d(v0, v1, p);
+
+        for y in p.y..=max_y {
+            let mut w0 = w0_row;
+            let mut w1 = w1_row;
+            let mut w2 = w2_row;
+
+            for x in p.x..=max_x {
+                if (w0 | w1 | w2) >= 0 {
+                    self.set_pixel(x as usize, y as usize, color);
+                }
+
+                w0 += a12;
+                w1 += a20;
+                w2 += a01;
+            }
+
+            w0_row += b12;
+            w1_row += b20;
+            w2_row += b01;
+        }
+    }
+
+    /// Copies the screen buffer in the `GraphicsWriter` to vga memory.
+    ///
+    /// **Note:** No draw calls will be displayed on the screen unless
+    /// this method is called.
+    fn present(&self);
+}
+
+#[inline]
+fn orient2d(a: Point<i32>, b: Point<i32>, c: Point<i32>) -> i32 {
+    (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x)
+}

src/drawing/mod.rs

@@ -3,13 +3,28 @@
 use num_traits::{NumAssignOps, NumCast, Signed};
 
 mod bresenham;
+mod device;
 mod octant;
 
 pub(crate) use bresenham::Bresenham;
+pub use device::Device;
 use octant::Octant;
 
 /// A point in 2D space.
-pub type Point<T> = (T, T);
+#[derive(Copy, Clone)]
+pub struct Point<T> {
+    /// The x coordinate of the `Point`.
+    pub x: T,
+    /// The y coordinate of the `Point`.
+    pub y: T,
+}
+
+impl<T> Point<T> {
+    /// Creates a new `Point` with the given `(x, y)` coordinates.
+    pub fn new(x: T, y: T) -> Point<T> {
+        Point { x, y }
+    }
+}
 
 pub(crate) trait SignedNum: Signed + Ord + Copy + NumCast + NumAssignOps {
     fn cast<T: NumCast>(value: T) -> Self {

src/drawing/octant.rs

@@ -15,8 +15,8 @@ impl Octant {
         T: Sub<Output = T> + Neg<Output = T> + PartialOrd + Zero,
     {
         let mut value = 0;
-        let mut dx = end.0 - start.0;
+        let mut dx = end.x - start.x;
-        let mut dy = end.1 - start.1;
+        let mut dy = end.y - start.y;
 
         if dy < T::zero() {
             dx = -dx;
@@ -45,14 +45,14 @@ impl Octant {
         T: Neg<Output = T>,
     {
         match self.value {
-            0 => (point.0, point.1),
+            0 => Point::new(point.x, point.y),
-            1 => (point.1, point.0),
+            1 => Point::new(point.y, point.x),
-            2 => (point.1, -point.0),
+            2 => Point::new(point.y, -point.x),
-            3 => (-point.0, point.1),
+            3 => Point::new(-point.x, point.y),
-            4 => (-point.0, -point.1),
+            4 => Point::new(-point.x, -point.y),
-            5 => (-point.1, -point.0),
+            5 => Point::new(-point.y, -point.x),
-            6 => (-point.1, point.0),
+            6 => Point::new(-point.y, point.x),
-            7 => (point.0, -point.1),
+            7 => Point::new(point.x, -point.y),
             _ => unreachable!(),
         }
     }
@@ -61,14 +61,14 @@ impl Octant {
     #[inline]
     pub fn from<T: Neg<Output = T>>(&self, point: Point<T>) -> Point<T> {
         match self.value {
-            0 => (point.0, point.1),
+            0 => Point::new(point.x, point.y),
-            1 => (point.1, point.0),
+            1 => Point::new(point.y, point.x),
-            2 => (-point.1, point.0),
+            2 => Point::new(-point.y, point.x),
-            3 => (-point.0, point.1),
+            3 => Point::new(-point.x, point.y),
-            4 => (-point.0, -point.1),
+            4 => Point::new(-point.x, -point.y),
-            5 => (-point.1, -point.0),
+            5 => Point::new(-point.y, -point.x),
-            6 => (point.1, -point.0),
+            6 => Point::new(point.y, -point.x),
-            7 => (point.0, -point.1),
+            7 => Point::new(point.x, -point.y),
             _ => unreachable!(),
         }
     }

src/lib.rs

@@ -7,8 +7,12 @@
 #![no_std]
 #![warn(missing_docs)]
 
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
 pub mod colors;
 pub mod configurations;
+#[cfg(feature = "alloc")]
 pub mod drawing;
 pub mod fonts;
 pub mod registers;

src/registers/general.rs

@@ -1,6 +1,7 @@
 use super::{
-    FCR_CGA_WRITE_ADDRESS, FCR_MDA_WRITE_ADDRESS, FCR_READ_ADDRESS, MSR_READ_ADDRESS,
+    EmulationMode, FCR_CGA_WRITE_ADDRESS, FCR_MDA_WRITE_ADDRESS, FCR_READ_ADDRESS,
-    MSR_WRITE_ADDRESS, ST00_READ_ADDRESS, ST01_READ_CGA_ADDRESS, ST01_READ_MDA_ADDRESS,
+    MSR_READ_ADDRESS, MSR_WRITE_ADDRESS, ST00_READ_ADDRESS, ST01_READ_CGA_ADDRESS,
+    ST01_READ_MDA_ADDRESS,
 };
 use x86_64::instructions::port::{PortReadOnly, PortWriteOnly};
 
@@ -42,4 +43,13 @@ impl GeneralRegisters {
             self.msr_write.write(value);
         }
     }
+
+    /// Reads the current value from the input status 1 register
+    /// as specified by the `emulation_mode`.
+    pub fn read_st01(&mut self, emulation_mode: EmulationMode) -> u8 {
+        match emulation_mode {
+            EmulationMode::Cga => unsafe { self.st01_read_cga.read() },
+            EmulationMode::Mda => unsafe { self.st01_read_mda.read() },
+        }
+    }
 }

src/writers/graphics_320x200x256.rs

@@ -1,11 +1,12 @@
 use super::{GraphicsWriter, Screen};
 use crate::{
     colors::DEFAULT_PALETTE,
-    drawing::{Bresenham, Point},
+    drawing::{Bresenham, Device, Point},
-    vga::{Vga, VideoMode, VGA},
+    vga::{VideoMode, VGA},
 };
+use alloc::vec::Vec;
+use core::ptr;
 use font8x8::UnicodeFonts;
-use spinning_top::SpinlockGuard;
 
 const WIDTH: usize = 320;
 const HEIGHT: usize = 200;
@@ -34,7 +35,9 @@ const SIZE: usize = WIDTH * HEIGHT;
 /// }
 /// ```
 #[derive(Default)]
-pub struct Graphics320x200x256 {}
+pub struct Graphics320x200x256 {
+    screen_buffer: Vec<u8>,
+}
 
 impl Screen for Graphics320x200x256 {
     #[inline]
@@ -53,27 +56,8 @@ impl Screen for Graphics320x200x256 {
     }
 }
 
-impl GraphicsWriter<u8> for Graphics320x200x256 {
+impl Device<u8> for Graphics320x200x256 {
-    fn clear_screen(&self, color: u8) {
+    fn draw_character(&mut self, x: usize, y: usize, character: char, color: u8) {
-        for x in 0..WIDTH {
-            for y in 0..HEIGHT {
-                self.set_pixel(x, y, color);
-            }
-        }
-    }
-    fn draw_line(&self, start: Point<isize>, end: Point<isize>, color: u8) {
-        for (x, y) in Bresenham::new(start, end) {
-            self.set_pixel(x as usize, y as usize, color);
-        }
-    }
-    fn set_pixel(&self, x: usize, y: usize, color: u8) {
-        let (_vga, frame_buffer) = self.get_frame_buffer();
-        let offset = (y * WIDTH) + x;
-        unsafe {
-            frame_buffer.add(offset).write_volatile(color);
-        }
-    }
-    fn draw_character(&self, x: usize, y: usize, character: char, color: u8) {
         let character = match font8x8::BASIC_FONTS.get(character) {
             Some(character) => character,
             // Default to a filled block if the character isn't found
@@ -89,6 +73,42 @@ impl GraphicsWriter<u8> for Graphics320x200x256 {
             }
         }
     }
+
+    fn draw_line(&mut self, start: Point<isize>, end: Point<isize>, color: u8) {
+        for Point { x, y } in Bresenham::new(start, end) {
+            self.set_pixel(x as usize, y as usize, color);
+        }
+    }
+
+    fn present(&self) {
+        {
+            let mut vga = VGA.lock();
+            let emulation_mode = vga.get_emulation_mode();
+            while vga.general_registers.read_st01(emulation_mode) & 0x3 != 0 {}
+        }
+        unsafe {
+            ptr::copy_nonoverlapping(
+                self.screen_buffer.as_ptr(),
+                self.get_frame_buffer(),
+                self.screen_buffer.len(),
+            );
+        }
+    }
+}
+
+impl GraphicsWriter<u8> for Graphics320x200x256 {
+    fn clear_screen(&mut self, color: u8) {
+        unsafe {
+            self.screen_buffer
+                .as_mut_ptr()
+                .write_bytes(color, self.screen_buffer.len());
+        }
+    }
+
+    fn set_pixel(&mut self, x: usize, y: usize, color: u8) {
+        self.screen_buffer[(y * WIDTH) + x] = color;
+    }
+
     fn set_mode(&self) {
         let mut vga = VGA.lock();
         vga.set_video_mode(VideoMode::Mode320x200x256);
@@ -102,15 +122,14 @@ impl GraphicsWriter<u8> for Graphics320x200x256 {
 impl Graphics320x200x256 {
     /// Creates a new `Graphics320x200x256`.
     pub fn new() -> Graphics320x200x256 {
-        Graphics320x200x256 {}
+        let mut screen_buffer = Vec::with_capacity(SIZE);
+        for _ in 0..SIZE {
+            screen_buffer.push(0);
+        }
+        Graphics320x200x256 { screen_buffer }
     }
 
-    /// Returns the start of the `FrameBuffer` as `*mut u8` as
+    fn get_frame_buffer(&self) -> *mut u8 {
-    /// well as a lock to the vga driver. This ensures the vga
+        u32::from(VGA.lock().get_frame_buffer()) as *mut u8
-    /// driver stays locked while the frame buffer is in use.
-    fn get_frame_buffer(&self) -> (SpinlockGuard<Vga>, *mut u8) {
-        let mut vga = VGA.lock();
-        let frame_buffer = vga.get_frame_buffer();
-        (vga, u32::from(frame_buffer) as *mut u8)
     }
 }

src/writers/graphics_640x480x16.rs

@@ -1,18 +1,15 @@
 use super::{GraphicsWriter, Screen};
 use crate::{
     colors::{Color16, DEFAULT_PALETTE},
-    drawing::{Bresenham, Point},
+    drawing::{Bresenham, Device, Point},
-    registers::{PlaneMask, WriteMode},
+    vga::{VideoMode, VGA},
-    vga::{Vga, VideoMode, VGA},
 };
+use alloc::vec::Vec;
 use font8x8::UnicodeFonts;
-use spinning_top::SpinlockGuard;
 
 const WIDTH: usize = 640;
 const HEIGHT: usize = 480;
 const SIZE: usize = WIDTH * HEIGHT;
-const ALL_PLANES_SCREEN_SIZE: usize = (WIDTH * HEIGHT) / 8;
-const WIDTH_IN_BYTES: usize = WIDTH / 8;
 
 /// A basic interface for interacting with vga graphics mode 640x480x16
 ///
@@ -37,7 +34,9 @@ const WIDTH_IN_BYTES: usize = WIDTH / 8;
 /// }
 /// ```
 #[derive(Default)]
-pub struct Graphics640x480x16;
+pub struct Graphics640x480x16 {
+    screen_buffer: Vec<u8>,
+}
 
 impl Screen for Graphics640x480x16 {
     fn get_width(&self) -> usize {
@@ -51,26 +50,8 @@ impl Screen for Graphics640x480x16 {
     }
 }
 
-impl GraphicsWriter<Color16> for Graphics640x480x16 {
+impl Device<Color16> for Graphics640x480x16 {
-    fn clear_screen(&self, color: Color16) {
+    fn draw_character(&mut self, x: usize, y: usize, character: char, color: Color16) {
-        self.set_write_mode_2();
-        let (_vga, frame_buffer) = self.get_frame_buffer();
-        for offset in 0..ALL_PLANES_SCREEN_SIZE {
-            unsafe {
-                frame_buffer.add(offset).write_volatile(u8::from(color));
-            }
-        }
-    }
-
-    fn draw_line(&self, start: Point<isize>, end: Point<isize>, color: Color16) {
-        self.set_write_mode_0(color);
-        for (x, y) in Bresenham::new(start, end) {
-            self._set_pixel(x as usize, y as usize, color);
-        }
-    }
-
-    fn draw_character(&self, x: usize, y: usize, character: char, color: Color16) {
-        self.set_write_mode_2();
         let character = match font8x8::BASIC_FONTS.get(character) {
             Some(character) => character,
             // Default to a filled block if the character isn't found
@@ -81,19 +62,51 @@ impl GraphicsWriter<Color16> for Graphics640x480x16 {
             for bit in 0..8 {
                 match *byte & 1 << bit {
                     0 => (),
-                    _ => self._set_pixel(x + bit, y + row, color),
+                    _ => self.set_pixel(x + bit, y + row, color),
                 }
             }
         }
     }
 
-    /// **Note:** This method is provided for convenience, but has terrible
+    fn draw_line(&mut self, start: Point<isize>, end: Point<isize>, color: Color16) {
-    /// performance since it needs to ensure the correct `WriteMode` per pixel
+        for Point { x, y } in Bresenham::new(start, end) {
-    /// drawn. If you need to draw more then one pixel, consider using a method
+            self.set_pixel(x as usize, y as usize, color);
-    /// such as `draw_line`.
+        }
-    fn set_pixel(&self, x: usize, y: usize, color: Color16) {
+    }
-        self.set_write_mode_2();
+
-        self._set_pixel(x, y, color);
+    fn present(&self) {
+        let frame_buffer = self.get_frame_buffer();
+        let mut vga = VGA.lock();
+        let emulation_mode = vga.get_emulation_mode();
+        while vga.general_registers.read_st01(emulation_mode) & 0x3 != 0 {}
+        for offset in 0..SIZE {
+            let color = self.screen_buffer[offset];
+            // Set the mask to the pixel being modified
+            vga.graphics_controller_registers
+                .set_bit_mask(0x80 >> (offset & 0x7));
+            // Faster then offset / 8 ?
+            let offset = offset >> 3;
+            unsafe {
+                // Load the memory latch with 8 pixels
+                frame_buffer.add(offset).read_volatile();
+                // Write the color to the masked pixel
+                frame_buffer.add(offset).write_volatile(color);
+            }
+        }
+    }
+}
+
+impl GraphicsWriter<Color16> for Graphics640x480x16 {
+    fn clear_screen(&mut self, color: Color16) {
+        for x in 0..WIDTH {
+            for y in 0..HEIGHT {
+                self.set_pixel(x, y, color);
+            }
+        }
+    }
+
+    fn set_pixel(&mut self, x: usize, y: usize, color: Color16) {
+        self.screen_buffer[(WIDTH * y) + x] = color as u8;
     }
 
     fn set_mode(&self) {
@@ -109,45 +122,14 @@ impl GraphicsWriter<Color16> for Graphics640x480x16 {
 impl Graphics640x480x16 {
     /// Creates a new `Graphics640x480x16`.
     pub fn new() -> Graphics640x480x16 {
-        Graphics640x480x16 {}
+        let mut screen_buffer = Vec::with_capacity(SIZE);
+        for _ in 0..SIZE {
+            screen_buffer.push(0);
+        }
+        Graphics640x480x16 { screen_buffer }
     }
 
-    fn set_write_mode_0(&self, color: Color16) {
+    fn get_frame_buffer(&self) -> *mut u8 {
-        let (mut vga, _frame_buffer) = self.get_frame_buffer();
+        u32::from(VGA.lock().get_frame_buffer()) as *mut u8
-        vga.graphics_controller_registers.write_set_reset(color);
-        vga.graphics_controller_registers
-            .write_enable_set_reset(0xF);
-        vga.graphics_controller_registers
-            .set_write_mode(WriteMode::Mode0);
-    }
-
-    fn set_write_mode_2(&self) {
-        let (mut vga, _frame_buffer) = self.get_frame_buffer();
-        vga.graphics_controller_registers
-            .set_write_mode(WriteMode::Mode2);
-        vga.graphics_controller_registers.set_bit_mask(0xFF);
-        vga.sequencer_registers
-            .set_plane_mask(PlaneMask::ALL_PLANES);
-    }
-
-    /// Returns the start of the `FrameBuffer` as `*mut u8` as
-    /// well as a lock to the vga driver. This ensures the vga
-    /// driver stays locked while the frame buffer is in use.
-    fn get_frame_buffer(&self) -> (SpinlockGuard<Vga>, *mut u8) {
-        let mut vga = VGA.lock();
-        let frame_buffer = vga.get_frame_buffer();
-        (vga, u32::from(frame_buffer) as *mut u8)
-    }
-
-    #[inline]
-    fn _set_pixel(&self, x: usize, y: usize, color: Color16) {
-        let (mut vga, frame_buffer) = self.get_frame_buffer();
-        let offset = x / 8 + y * WIDTH_IN_BYTES;
-        let pixel_mask = 0x80 >> (x & 0x07);
-        vga.graphics_controller_registers.set_bit_mask(pixel_mask);
-        unsafe {
-            frame_buffer.add(offset).read_volatile();
-            frame_buffer.add(offset).write_volatile(u8::from(color));
-        }
     }
 }

src/writers/mod.rs

@@ -1,5 +1,7 @@
 //! Writers for common vga modes.
+#[cfg(feature = "alloc")]
 mod graphics_320x200x256;
+#[cfg(feature = "alloc")]
 mod graphics_640x480x16;
 mod text_40x25;
 mod text_40x50;
@@ -7,13 +9,13 @@ mod text_80x25;
 
 use super::{
     colors::{Color16, TextModeColor},
-    drawing::Point,
     registers::CrtcControllerIndex,
-    vga::{Vga, VGA},
+    vga::VGA,
 };
-use spinning_top::SpinlockGuard;
 
+#[cfg(feature = "alloc")]
 pub use graphics_320x200x256::Graphics320x200x256;
+#[cfg(feature = "alloc")]
 pub use graphics_640x480x16::Graphics640x480x16;
 pub use text_40x25::Text40x25;
 pub use text_40x50::Text40x50;
@@ -65,20 +67,18 @@ pub trait TextWriter: Screen {
     /// the `TextWriter` implementation.
     fn set_mode(&self);
 
-    /// Returns the start of the `FrameBuffer` as `*mut ScreenCharacter`
+    /// Returns the start of the `FrameBuffer` as `*mut ScreenCharacter`.
-    /// as well as a lock to the vga driver. This ensures the vga
+    fn get_frame_buffer(&self) -> *mut ScreenCharacter {
-    /// driver stays locked while the frame buffer is in use.
-    fn get_frame_buffer(&self) -> (SpinlockGuard<Vga>, *mut ScreenCharacter) {
         let mut vga = VGA.lock();
         let frame_buffer = vga.get_frame_buffer();
-        (vga, u32::from(frame_buffer) as *mut ScreenCharacter)
+        u32::from(frame_buffer) as *mut ScreenCharacter
     }
 
     /// Clears the screen by setting all cells to `b' '` with
     /// a background color of `Color16::Black` and a foreground
     /// color of `Color16::Yellow`.
     fn clear_screen(&self) {
-        let (_vga, frame_buffer) = self.get_frame_buffer();
+        let frame_buffer = self.get_frame_buffer();
         let screen_size = self.get_width() * self.get_height();
         for i in 0..screen_size {
             unsafe {
@@ -89,7 +89,7 @@ pub trait TextWriter: Screen {
 
     /// Disables the cursor in vga text modes.
     fn disable_cursor(&self) {
-        let (mut vga, _frame_buffer) = self.get_frame_buffer();
+        let mut vga = VGA.lock();
         let emulation_mode = vga.get_emulation_mode();
         let cursor_start = vga
             .crtc_controller_registers
@@ -103,7 +103,7 @@ pub trait TextWriter: Screen {
 
     /// Enables the cursor in vga text modes.
     fn enable_cursor(&self) {
-        let (mut vga, _frame_buffer) = self.get_frame_buffer();
+        let mut vga = VGA.lock();
         let emulation_mode = vga.get_emulation_mode();
         let cursor_start = vga
             .crtc_controller_registers
@@ -117,7 +117,7 @@ pub trait TextWriter: Screen {
 
     /// Returns the `ScreenCharacter` at the given `(x, y)` position.
     fn read_character(&self, x: usize, y: usize) -> ScreenCharacter {
-        let (_vga, frame_buffer) = self.get_frame_buffer();
+        let frame_buffer = self.get_frame_buffer();
         let offset = self.get_width() * y + x;
         unsafe { frame_buffer.add(offset).read_volatile() }
     }
@@ -129,7 +129,7 @@ pub trait TextWriter: Screen {
     /// determined by `CrtcControllerIndex::MaxiumumScanLine (usually 15)`.
     /// If `scan_line_start > scan_line_end`, the cursor isn't drawn.
     fn set_cursor(&self, scan_line_start: u8, scan_line_end: u8) {
-        let (mut vga, _frame_buffer) = self.get_frame_buffer();
+        let mut vga = VGA.lock();
         let emulation_mode = vga.get_emulation_mode();
         let cursor_start = vga
             .crtc_controller_registers
@@ -155,7 +155,7 @@ pub trait TextWriter: Screen {
     /// `x` and `y`.
     fn set_cursor_position(&self, x: usize, y: usize) {
         let offset = self.get_width() * y + x;
-        let (mut vga, _frame_buffer) = self.get_frame_buffer();
+        let mut vga = VGA.lock();
         let emulation_mode = vga.get_emulation_mode();
         let cursor_start = offset & 0xFF;
         let cursor_end = (offset >> 8) & 0xFF;
@@ -173,7 +173,7 @@ pub trait TextWriter: Screen {
 
     /// Prints the given `character` and `color` at `(x, y)`.
     fn write_character(&self, x: usize, y: usize, screen_character: ScreenCharacter) {
-        let (_vga, frame_buffer) = self.get_frame_buffer();
+        let frame_buffer = self.get_frame_buffer();
         let offset = self.get_width() * y + x;
         unsafe {
             frame_buffer.add(offset).write_volatile(screen_character);
@@ -184,13 +184,12 @@ pub trait TextWriter: Screen {
 /// A helper trait used to interact with various vga graphics modes.
 pub trait GraphicsWriter<Color> {
     /// Clears the screen by setting all pixels to the specified `color`.
-    fn clear_screen(&self, color: Color);
+    fn clear_screen(&mut self, color: Color);
-    /// Draws a line from `start` to `end` with the specified `color`.
-    fn draw_line(&self, start: Point<isize>, end: Point<isize>, color: Color);
-    /// Draws a character at the given `(x, y)` coordinant to the specified `color`.
-    fn draw_character(&self, x: usize, y: usize, character: char, color: Color);
     /// Sets the given pixel at `(x, y)` to the given `color`.
-    fn set_pixel(&self, x: usize, y: usize, color: Color);
+    ///
+    /// **Note:** This does no bounds checking and will panick if
+    /// `x >= self.get_width() || y >= self.get_height()`.
+    fn set_pixel(&mut self, x: usize, y: usize, color: Color);
     /// Sets the graphics device to a `VideoMode`.
     fn set_mode(&self);
 }