- added a new libary libm containing procedural macros for the kernel.

these should be used to include external files and resources in the kernel binary
  at compile time.
  - libm currently supports loading psf-1 formatted fonts
- added two fonts that are included in the binary at compile time
- refactored libk to make the crate structure more organised and maintainable in future.
  new structure:
    - drivers   (hardware interaction)
    - resources (consts and statics included either manually or via macros)
    - std       (standard functions for higher level interaction with the os, for example creating windows)
- added geometry.rs
  - provides the Vec2<T> struct for use with dimensions, coordinates etc.
- added window.rs
  - provides the Window struct for rendering the state of an application to the screen
- added application.rs
  - provides the Application trait for custom programs to implement in order to run

libk/src/std/application/application.rs

@@ -0,0 +1,14 @@
+use crate::prelude::*;
+
+pub trait Application {
+    type Output;
+
+    async fn run(&mut self, args: Vec<String>) -> Result<Self::Output, Error>;
+}
+
+#[derive(Debug)]
+pub enum Error {
+    UnknownCommand(String),
+    ApplicationFailed(String),
+    KernelError(String),
+}

libk/src/std/application/mod.rs

@@ -0,0 +1,2 @@
+pub mod application;
+pub mod window;

libk/src/std/application/window.rs

@@ -0,0 +1,74 @@
+use crate::{prelude::*, std::maths::geometry::Vec2};
+
+pub struct Window {
+    dimensions: Vec2<usize>,
+    position: Vec2<usize>,
+    bordered: bool,
+    opened: bool,
+    title: String,
+}
+
+impl Window {
+    pub const fn new() -> Window {
+        Window {
+            dimensions: Vec2::new(0, 0),
+            position: Vec2::new(0, 0),
+            bordered: true,
+            opened: false,
+            title: String::new(),
+        }
+    }
+
+    pub fn is_bordered(&self) -> bool {
+        self.bordered
+    }
+
+    pub fn is_open(&self) -> bool {
+        self.opened
+    }
+
+    pub fn open(&mut self) {
+        self.opened = true;
+    }
+
+    pub fn close(&mut self) {
+        self.opened = false;
+    }
+
+    // some basic getters and setters for utility.
+    pub fn title(&self) -> &str {
+        &self.title
+    }
+
+    pub fn dimensions(&self) -> Vec2<usize> {
+        self.dimensions
+    }
+
+    pub fn position(&self) -> Vec2<usize> {
+        self.position
+    }
+
+    pub fn set_title(&mut self, title: String) {
+        self.title = title;
+    }
+
+    pub fn move_window(&mut self, offset: Vec2<usize>) {
+        self.position += offset;
+    }
+
+    pub fn set_position(&mut self, position: Vec2<usize>) {
+        self.position = position;
+    }
+
+    pub fn set_dimensions(&mut self, dimensions: Vec2<usize>) {
+        self.dimensions = dimensions;
+    }
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        if self.opened {
+            self.close();
+        }
+    }
+}

libk/src/std/maths/geometry.rs

@@ -0,0 +1,73 @@
+use core::ops::{AddAssign, DivAssign, MulAssign, SubAssign};
+
+pub trait Coordinate:
+    Copy + Clone + PartialEq + AddAssign + MulAssign + SubAssign + DivAssign
+{
+}
+
+impl Coordinate for usize {}
+impl Coordinate for isize {}
+impl Coordinate for u8 {}
+impl Coordinate for i8 {}
+impl Coordinate for u16 {}
+impl Coordinate for i16 {}
+impl Coordinate for u32 {}
+impl Coordinate for i32 {}
+impl Coordinate for u64 {}
+impl Coordinate for i64 {}
+impl Coordinate for u128 {}
+impl Coordinate for i128 {}
+impl Coordinate for f32 {}
+impl Coordinate for f64 {}
+
+#[derive(Copy, Clone, PartialEq, PartialOrd, Debug)]
+pub struct Vec2<T: Coordinate> {
+    x: T,
+    y: T,
+}
+
+impl<T: Coordinate> Vec2<T> {
+    pub const fn new(x: T, y: T) -> Self {
+        Self { x, y }
+    }
+
+    pub fn into<S: Coordinate + From<T>>(&self) -> Vec2<S> {
+        Vec2::new(self.x.clone().into(), self.y.clone().into())
+    }
+
+    pub fn x(&self) -> T {
+        self.x
+    }
+
+    pub fn y(&self) -> T {
+        self.y
+    }
+}
+
+impl<T: Coordinate> AddAssign for Vec2<T> {
+    fn add_assign(&mut self, rhs: Self) {
+        self.x += rhs.x;
+        self.y += rhs.y;
+    }
+}
+
+impl<T: Coordinate> SubAssign for Vec2<T> {
+    fn sub_assign(&mut self, rhs: Self) {
+        self.x -= rhs.x;
+        self.y -= rhs.y;
+    }
+}
+
+impl<T: Coordinate> MulAssign<T> for Vec2<T> {
+    fn mul_assign(&mut self, rhs: T) {
+        self.x *= rhs;
+        self.y *= rhs;
+    }
+}
+
+impl<T: Coordinate> DivAssign<T> for Vec2<T> {
+    fn div_assign(&mut self, rhs: T) {
+        self.x /= rhs;
+        self.y /= rhs;
+    }
+}

libk/src/std/maths/mod.rs

@@ -0,0 +1 @@
+pub mod geometry;

libk/src/std/mod.rs

@@ -0,0 +1,2 @@
+pub mod application;
+pub mod maths;