Page 03: VGA Text Mode (#6)

* Working `println!` and `print!` macros

* Colors!

* A Very Normal Sphere

* Small Tweaks 🤏

* Update `README.md`

* Fix a few typos

Author: c1m50c

Cargo.lock

@@ -1 +1,65 @@
-# rust-os
+# rust-os
+
+[![Verify](https://github.com/c1m50c/rust-os/actions/workflows/verify.yaml/badge.svg?branch=main&event=push)](https://github.com/c1m50c/rust-os/actions/workflows/verify.yaml)
+
+Repository following the ["Writing an Operating System in Rust"] blog by Philipp Oppermann. 
+
+["Writing an Operating System in Rust"]: https://os.phil-opp.com/
+
+## Installing Requirements
+
+### Compilation Tools
+
+This operating system is written in Rust so you'll need to install the language's compilation tools by running the following commmands:
+
+#### Windows
+
+```bash
+$ choco install rust
+```
+
+#### MacOS
+
+```bash
+$ brew install rust
+```
+
+### Nightly Channel
+
+Alongside the normal compilation toolkit you'll need to add the [`nightly`] channel to your [`rustup`] installation, you can do so by running the following commands:
+
+```bash
+$ rustup update
+> ...
+
+$ rustup toolchain install nightly
+> ...
+
+# Also add the `x86_64-unknown-none` build target for compiling our kernel.
+$ rustup target add x86_64-unknown-none
+```
+
+[`rustup`]: https://rust-lang.github.io/rustup/index.html
+[`nightly`]: https://rust-lang.github.io/rustup/concepts/channels.html#working-with-nightly-rust
+
+### QEMU
+
+Lastly, you'll need to install [QEMU] to emulate our operating system. To do so, follow the [installation instructions] for the platform you're currently using.
+
+[QEMU]: https://www.qemu.org/
+[installation instructions]: https://www.qemu.org/download/
+
+## Running
+
+After you've installed all of the requirements, running the operating system should be as simple as executing any of the following commands:
+
+```bash
+$ cargo run --release -- help
+> ... # Help menu will pop up displaying a valid list of commands
+
+$ cargo run --release -- uefi
+> ... # QEMU Window should pop up launching our kernel's UEFI image
+
+$ cargo run --release -- bios
+> ... # QEMU Window should pop up launching our kernel's BIOS image
+```

README.md

@@ -6,5 +6,9 @@ edition = "2021"
 publish = false
 
 [dependencies]
+lazy_static = { version = "1.4.0", features = [ "spin_no_std" ] }
 noto-sans-mono-bitmap = "0.2.0"
 bootloader_api = "0.11.3"
+fixed-vectors = "3.2.1"
+spin = "0.9.8"
+libm = "0.2.6"

kernel/Cargo.toml

@@ -0,0 +1,37 @@
+use core::fmt::{self, Write};
+use core::ops::DerefMut;
+
+use crate::FRAME_BUFFER_WRITER;
+
+
+#[macro_export]
+macro_rules! print {
+    ($($arg: tt)*) => {
+        $crate::macros::_print(
+            format_args!( $($arg)* )
+        );
+    };
+}
+
+
+#[macro_export]
+macro_rules! println {
+    () => {
+        $crate::print!("\n");
+    };
+
+    ($($arg: tt)*) => {
+        $crate::print!("{}\n", format_args!($($arg)*));
+    }
+}
+
+
+#[doc(hidden)]
+pub fn _print(args: fmt::Arguments) {
+    let mut lock = FRAME_BUFFER_WRITER.lock();
+
+    if let Some(writer) = lock.deref_mut() {
+        writer.write_fmt(args)
+            .expect("In `_print()`, the `write_fmt()` function is expected not to fail");
+    }
+}

kernel/src/macros/mod.rs

@@ -1,35 +1,64 @@
-#![allow(clippy::empty_loop)]
+#![allow(clippy::empty_loop, unused_labels)]
 #![no_main]
 #![no_std]
 
-
 use bootloader_api::info::Optional;
 use bootloader_api::BootInfo;
+
+use lazy_static::lazy_static;
+use fixed_vectors::Vector2;
+use spin::Mutex;
+
+use core::ops::DerefMut;
+#[cfg(not(test))]
 use core::panic::PanicInfo;
-use core::fmt::Write;
 
+pub mod raytracer;
 pub mod writer;
-pub mod math;
+pub mod macros;
+
+
+lazy_static!{
+    pub static ref FRAME_BUFFER_WRITER: Mutex<Option<writer::FrameBufferWriter<'static>>> = Mutex::new(
+        // The `FRAME_BUFFER_WRITER` needs to be initialized in `main` with the `info.framebuffer`
+        None
+    );
+}
 
 
 #[panic_handler]
-fn panic(_info: &PanicInfo) -> ! {
+#[cfg(not(test))]
+fn panic(info: &PanicInfo) -> ! {
+    println!("PANIC: {}", info);
+
     loop {  }
 }
 
 
 fn main(info: &'static mut BootInfo) -> ! {
+    // Initialize `FRAME_BUFFER_WRITER` with `info.framebuffer`
     if let Optional::Some(buffer) = &mut info.framebuffer {
         let frame_buffer_info = buffer.info();
         let frame_buffer = buffer.buffer_mut();
 
-        let mut font_writer = writer::FontWriter::new(frame_buffer_info, frame_buffer);
-        font_writer.clear();
+        let mut lock = FRAME_BUFFER_WRITER.lock();
+
+        let mut writer = writer::FrameBufferWriter::new(frame_buffer_info, frame_buffer);
+        writer.clear();
 
-        let _ = write!(&mut font_writer, "Hello, World!\n");
-        let _ = write!(&mut font_writer, "https://github.com/c1m50c/rust-os");
+        *lock = Some(writer);
     }
 
+    let mut lock = FRAME_BUFFER_WRITER.lock();
+    let Some(writer) = lock.deref_mut() else { unreachable!() };
+
+    let resolution = Vector2::new(
+        writer.frame_buffer_info.width, writer.frame_buffer_info.height
+    );
+
+    let mut raytracer = raytracer::Raytracer::new(resolution, writer);
+    raytracer.run();
+
     loop {  }
 }