Maybe get simple text drawing ?

Author: commonkestrel

Cargo.lock

@@ -23,6 +23,7 @@ humantime = "2.1"
 lazy-regex = "3.1"
 libloading = "0.8"
 logos = "0.13"
+minifb = "0.27.0"
 modular-bitfield = "0.11"
 once_cell = "1.18"
 serialport = "4.3"

Cargo.toml

@@ -53,6 +53,8 @@ fn main() -> Result<(), Error> {
     println!("cargo:rerun-if-changed=src/microcode.asm");
     println!("cargo:rerun-if-changed=build.rs");
 
+    create_display_multiplier()?;
+
     let file = fs::read_to_string("src/microcode.asm")?;
     let lex = Token::lexer(&file);
     let stream = Stream::parse(lex)?;
@@ -85,6 +87,10 @@ fn main() -> Result<(), Error> {
     Ok(())
 }
 
+fn create_display_multiplier() -> Result<(), Error> {
+    Ok(())
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 enum Instruction {
     Add = 0x0,

build.rs

@@ -19,6 +19,7 @@ use async_std::{
 use bitflags::bitflags;
 use clap::Args;
 use clio::Input;
+use display::TextBuffer;
 use libloading::Library;
 use modular_bitfield::prelude::*;
 use thiserror::Error;
@@ -559,6 +560,7 @@ struct State {
     mem: Box<[u8]>,
     program: Box<[u8]>,
     peripherals: HashMap<u8, Peripheral>,
+    text_buffer: TextBuffer,
 }
 
 impl State {
@@ -578,6 +580,7 @@ impl State {
             mem: vec![0; 1 << 16].into_boxed_slice(),
             program,
             peripherals: HashMap::new(),
+            text_buffer: TextBuffer::spawn(),
         }
     }
 

src/emulator.rs

@@ -1,9 +1,13 @@
 use std::{cell::UnsafeCell, marker::PhantomData, pin::Pin, sync::atomic::{AtomicU16, AtomicU8, Ordering}};
 
 use async_std::task::JoinHandle;
+use minifb::{Scale, ScaleMode, WindowOptions};
 
 const FONT: &[u8; 1 << 12] = include_bytes!("../vga-font.rom");
+const WIDTH: usize = 640;
+const HEIGHT: usize = 400;
 
+#[derive(Debug)]
 pub struct TextBuffer {
     data: Pin<Box<[u8; 1 << 12]>>,
     handle: JoinHandle<()>,
@@ -14,7 +18,8 @@ unsafe impl Send for BufferPtr {}
 
 impl TextBuffer {
     pub fn spawn() -> TextBuffer {
-        let data = Box::pin([0; 1 << 12]);
+        let mut data = Box::pin([0; 1 << 12]);
+        data[0] = 0x12;
 
         let handle = async_std::task::spawn(run_handle(BufferPtr(&*data)));
 
@@ -23,5 +28,34 @@ impl TextBuffer {
 }
 
 async fn run_handle(buffer: BufferPtr) {
-
+    let mut opts = WindowOptions::default();
+    opts.scale = Scale::FitScreen;
+    opts.scale_mode = ScaleMode::Center;
+
+    let mut window = minifb::Window::new("f8ful", WIDTH, HEIGHT, opts).expect("should be able to create window");
+    let mut fb = [0x00000000; WIDTH*HEIGHT];
+
+    while window.is_open() {
+        for y in 0..HEIGHT {
+            for x in 0..WIDTH {
+                let font_x = x % 8;
+                let font_y = y % 16;
+
+                let char_x = x / 8;
+                let char_y = y / 16;
+                let char_idx = char_x + char_y*WIDTH/16;
+                let character = unsafe {
+                    (*buffer.0)[char_idx]
+                };
+
+                let font_addr = (character as usize) << 4 + font_y;
+                let lit = FONT[font_addr] & !(1 << font_x) > 0;
+
+                // This part isn't part of the actual CPU,
+                // the real value will be transmitted via wire instead of stored.
+                fb[x + y*WIDTH] = if lit {0x00FFFFFF} else {0x00000000};
+                window.update_with_buffer(&fb, WIDTH, HEIGHT).expect("should be able to update window");
+            }
+        }
+    }
 }