Rearranged into a cargo workspace

2022-03-06 17:57:20 -06:00
parent 81b805f338
commit 90f2177e5b
16 changed files with 1511 additions and 59 deletions
@@ -0,0 +1,12 @@
+[package]
+name = "vemu"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+vcore = { path = "../vcore" }
+rand = "0.8.0"
+winit = "0.26.1"
+pixels = "0.9.0"
@@ -0,0 +1,311 @@
+use vcore::memory::{PeekPoke, PeekPokeExt};
+use vcore::word::Word;
+use std::convert::TryFrom;
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+struct DisplayRegisters {
+    mode: u8,
+    screen: Word,
+    palette: Word,
+    font: Word,
+    height: Word,
+    width: Word,
+    row_offset: Word,
+    col_offset: Word,
+}
+
+impl Default for DisplayRegisters {
+    fn default() -> Self {
+        Self {
+            mode: 0,
+            screen: Word::from(0x10000),
+            palette: Word::from(0x20000 - 0x100),
+            font: Word::from(0x20000 - 0x100 - 0x2000),
+            height: Word::from(60),
+            width: Word::from(80),
+            row_offset: Word::from(0),
+            col_offset: Word::from(0),
+        }
+    }
+}
+
+fn read_display_registers<P: PeekPoke>(machine: &P, start: Word) -> DisplayRegisters {
+    DisplayRegisters {
+        mode: machine.peek8(start),
+        screen: machine.peek24(start + 1),
+        palette: machine.peek24(start + 4),
+        font: machine.peek24(start + 7),
+        height: machine.peek24(start + 10),
+        width: machine.peek24(start + 13),
+        row_offset: machine.peek24(start + 16),
+        col_offset: machine.peek24(start + 19),
+    }
+}
+
+fn init_display_registers<P: PeekPoke>(machine: &mut P, start: Word) {
+    let dr = DisplayRegisters::default();
+    machine.poke(start, dr.mode);
+    machine.poke24(start + 1, dr.screen);
+    machine.poke24(start + 4, dr.palette);
+    machine.poke24(start + 7, dr.font);
+    machine.poke24(start + 10, dr.height);
+    machine.poke24(start + 13, dr.width);
+    machine.poke24(start + 16, dr.row_offset);
+    machine.poke24(start + 19, dr.col_offset);
+}
+
+fn init_font<P: PeekPoke>(machine: &mut P) {
+    machine.poke_slice(DisplayRegisters::default().font, include_bytes!("font.rom"));
+}
+
+pub fn draw<P: PeekPoke>(machine: &P, frame: &mut [u8]) {
+    let reg = read_display_registers(machine, 16.into());
+    let (gfx, highres, paletted) = (reg.mode & 1 > 0, reg.mode & 2 > 0, reg.mode & 4 > 0);
+
+    match (paletted, highres, gfx) {
+        (true, true, true) => draw_paletted_high_gfx(machine, reg, frame),
+        (false, true, true) => draw_direct_high_gfx(machine, reg, frame),
+        (true, true, false) => draw_paletted_high_text(machine, reg, frame),
+        (false, true, false) => draw_direct_high_text(machine, reg, frame),
+        (false, false, false) => draw_direct_low_text(machine, reg, frame),
+        (true, false, false) => draw_paletted_low_text(machine, reg, frame),
+        (false, false, true) => draw_direct_low_gfx(machine, reg, frame),
+        (true, false, true) => draw_paletted_low_gfx(machine, reg, frame),
+    }
+}
+
+pub fn reset<P: PeekPoke>(machine: &mut P) {
+    init_display_registers(machine, 16.into());
+    init_font(machine);
+    init_palette(machine);
+}
+
+fn init_palette<P: PeekPoke>(machine: &mut P) {
+    let palette_addr = read_display_registers(machine, Word::from(16)).palette;
+    machine.poke_slice(
+        palette_addr,
+        &[
+            0x00, 0x05, 0x65, 0x11, 0xa8, 0x49, 0xeb, 0xff, 0xe1, 0xf4, 0xfc, 0x1c, 0x37, 0x8e,
+            0xee, 0xfa,
+        ],
+    );
+}
+
+fn to_byte_address((x, y): (Word, Word), reg: DisplayRegisters) -> Word {
+    let row_start = (y + reg.row_offset % reg.height) * reg.width + reg.screen;
+    ((x + reg.col_offset) % reg.width) + row_start
+}
+
+fn draw_direct_high_gfx<P: PeekPoke>(machine: &P, reg: DisplayRegisters, frame: &mut [u8]) {
+    for (i, pixel) in frame.chunks_exact_mut(4).enumerate() {
+        let (display_row, display_col) = (i / 640, i % 640);
+        let (vulcan_row, vulcan_col) = (Word::from(display_row >> 2), Word::from(display_col >> 2));
+
+        let vb = machine.peek(to_byte_address((vulcan_col, vulcan_row), reg));
+        paint_pixel(<&mut [u8; 4]>::try_from(pixel).unwrap(), vb)
+    }
+}
+
+fn draw_paletted_high_gfx<P: PeekPoke>(machine: &P, reg: DisplayRegisters, frame: &mut [u8]) {
+    for (i, pixel) in frame.chunks_exact_mut(4).enumerate() {
+        let (display_row, display_col) = (i / 640, i % 640);
+        let (vulcan_row, vulcan_col) = (Word::from(display_row >> 2), Word::from(display_col >> 2));
+
+        let addr = to_byte_address((vulcan_col, vulcan_row), reg);
+        let color_idx = machine.peek(addr);
+        let color = machine.peek(reg.palette + color_idx);
+
+        paint_pixel(<&mut [u8; 4]>::try_from(pixel).unwrap(), color)
+    }
+}
+
+fn draw_paletted_high_text<P: PeekPoke>(machine: &P, reg: DisplayRegisters, frame: &mut [u8]) {
+    for (i, pixel) in frame.chunks_exact_mut(4).enumerate() {
+        let (display_row, display_col) = (i / 640, i % 640);
+        let (vulcan_row, vulcan_col) = (Word::from(display_row >> 3), Word::from(display_col >> 3));
+
+        let addr = to_byte_address((vulcan_col, vulcan_row), reg);
+        let char_idx = machine.peek(addr) as u32;
+        let (char_row, char_col) = (display_row % 8, display_col % 8);
+        let char_byte = machine.peek(reg.font + (char_idx << 3) + char_row);
+
+        let color_addr = addr + (reg.width * reg.height);
+        let color_byte = machine.peek(color_addr);
+        let (fg_color_idx, bg_color_idx) = (color_byte & 0xf, color_byte >> 4);
+
+        let fg_color = machine.peek(reg.palette + fg_color_idx);
+        let bg_color = machine.peek(reg.palette + bg_color_idx);
+
+        draw_text_pixel(
+            <&mut [u8; 4]>::try_from(pixel).unwrap(),
+            char_col as u8,
+            char_byte,
+            fg_color,
+            bg_color,
+        )
+    }
+}
+
+fn draw_text_pixel(pixel: &mut [u8; 4], char_col: u8, char_byte: u8, fg_color: u8, bg_color: u8) {
+    if char_byte & (1 << (7 - char_col)) != 0 {
+        paint_pixel(pixel, fg_color)
+    } else {
+        paint_pixel(pixel, bg_color)
+    }
+}
+
+fn draw_direct_high_text<P: PeekPoke>(machine: &P, reg: DisplayRegisters, frame: &mut [u8]) {
+    for (i, pixel) in frame.chunks_exact_mut(4).enumerate() {
+        let (display_row, display_col) = (i / 640, i % 640);
+        let (vulcan_row, vulcan_col) = (Word::from(display_row >> 3), Word::from(display_col >> 3));
+
+        let addr = to_byte_address((vulcan_col, vulcan_row), reg);
+        let char_idx = machine.peek(addr) as u32;
+        let (char_row, char_col) = (display_row % 8, display_col % 8);
+        let char_byte = machine.peek(reg.font + (char_idx << 3) + char_row);
+
+        let color_addr = addr + (reg.width * reg.height);
+        let color = machine.peek(color_addr);
+
+        draw_text_pixel(
+            <&mut [u8; 4]>::try_from(pixel).unwrap(),
+            char_col as u8,
+            char_byte,
+            color,
+            0,
+        )
+    }
+}
+
+fn draw_direct_low_text<P: PeekPoke>(machine: &P, reg: DisplayRegisters, frame: &mut [u8]) {
+    for (i, pixel) in frame.chunks_exact_mut(4).enumerate() {
+        let (display_row, display_col) = (i / 640, i % 640);
+        let (vulcan_row, vulcan_col) = (Word::from(display_row >> 4), Word::from(display_col >> 4));
+
+        let addr = to_byte_address((vulcan_col, vulcan_row), reg);
+        let char_idx = machine.peek(addr) as u32;
+        let (char_row, char_col) = ((display_row / 2) % 8, (display_col / 2) % 8);
+        let char_byte = machine.peek(reg.font + (char_idx << 3) + char_row);
+
+        let color_addr = addr + (reg.width * reg.height);
+        let color = machine.peek(color_addr);
+
+        draw_text_pixel(
+            <&mut [u8; 4]>::try_from(pixel).unwrap(),
+            char_col as u8,
+            char_byte,
+            color,
+            0,
+        )
+    }
+}
+
+fn draw_paletted_low_text<P: PeekPoke>(machine: &P, reg: DisplayRegisters, frame: &mut [u8]) {
+    for (i, pixel) in frame.chunks_exact_mut(4).enumerate() {
+        let (display_row, display_col) = (i / 640, i % 640);
+        let (vulcan_row, vulcan_col) = (Word::from(display_row >> 4), Word::from(display_col >> 4));
+
+        let addr = to_byte_address((vulcan_col, vulcan_row), reg);
+        let char_idx = machine.peek(addr) as u32;
+        let (char_row, char_col) = ((display_row >> 1) % 8, (display_col >> 1) % 8);
+        let char_byte = machine.peek(reg.font + (char_idx << 3) + char_row);
+
+        let color_addr = addr + (reg.width * reg.height);
+        let color_byte = machine.peek(Word::from(color_addr));
+        let (fg_color_idx, bg_color_idx) = (color_byte & 0xf, color_byte >> 4);
+
+        let fg_color = machine.peek(reg.palette + fg_color_idx);
+        let bg_color = machine.peek(reg.palette + bg_color_idx);
+
+        draw_text_pixel(
+            <&mut [u8; 4]>::try_from(pixel).unwrap(),
+            char_col as u8,
+            char_byte,
+            fg_color,
+            bg_color,
+        )
+    }
+}
+
+fn draw_direct_low_gfx<P: PeekPoke>(machine: &P, reg: DisplayRegisters, frame: &mut [u8]) {
+    for (i, pixel) in frame.chunks_exact_mut(4).enumerate() {
+        let (display_row, display_col) = (i / 640, i % 640);
+
+        if display_row >= (240 - 64 * 3)
+            && display_row < (240 + 64 * 3)
+            && display_col >= (320 - 64 * 3)
+            && display_col < (320 + 64 * 3)
+        {
+            let (vulcan_row, vulcan_col) = (
+                Word::from((display_row - (240 - 64 * 3)) / 3),
+                Word::from((display_col - (320 - 64 * 3)) / 3),
+            );
+
+            let vb = machine.peek(to_byte_address((vulcan_col, vulcan_row), reg));
+            paint_pixel(<&mut [u8; 4]>::try_from(pixel).unwrap(), vb)
+        } else {
+            paint_pixel(<&mut [u8; 4]>::try_from(pixel).unwrap(), 0)
+        }
+    }
+}
+
+fn draw_paletted_low_gfx<P: PeekPoke>(machine: &P, reg: DisplayRegisters, frame: &mut [u8]) {
+    for (i, pixel) in frame.chunks_exact_mut(4).enumerate() {
+        let (display_row, display_col) = (i / 640, i % 640);
+
+        if display_row >= (240 - 64 * 3)
+            && display_row < (240 + 64 * 3)
+            && display_col >= (320 - 64 * 3)
+            && display_col < (320 + 64 * 3)
+        {
+            let (vulcan_row, vulcan_col) = (
+                Word::from((display_row - (240 - 64 * 3)) / 3),
+                Word::from((display_col - (320 - 64 * 3)) / 3),
+            );
+
+            let color_idx =
+                machine.peek(to_byte_address((vulcan_col, vulcan_row), reg));
+            let vb = machine.peek(reg.palette + color_idx);
+            paint_pixel(<&mut [u8; 4]>::try_from(pixel).unwrap(), vb);
+        } else {
+            paint_pixel(<&mut [u8; 4]>::try_from(pixel).unwrap(), 0);
+        }
+    }
+}
+
+fn paint_pixel(pixel: &mut [u8; 4], vb: u8) {
+    let (red, green, blue) = (vb >> 5, (vb >> 2) & 7, vb & 3);
+
+    fn scale(b: u8) -> u8 {
+        let tmp = (b << 3) | b;
+        (tmp << 2) | (b & 3)
+    }
+
+    let blue_shifted2 = (blue << 2) | blue;
+    let blue_shifted = (blue_shifted2 << 4) | blue_shifted2;
+
+    pixel[0] = scale(red);
+    pixel[1] = scale(green);
+    pixel[2] = blue_shifted;
+    pixel[3] = 0xff;
+}
+
+#[test]
+fn test_paint_pixel() {
+    let mut p: [u8; 4] = [0, 0, 0, 0];
+
+    paint_pixel(&mut p, 0b11100000);
+    assert_eq!(p, [0xff, 0, 0, 255]);
+
+    paint_pixel(&mut p, 0b00011100);
+    assert_eq!(p, [0, 0xff, 0, 255]);
+
+    paint_pixel(&mut p, 0b00000011);
+    assert_eq!(p, [0, 0, 0xff, 255]);
+
+    paint_pixel(&mut p, 0xff);
+    assert_eq!(p, [0xff, 0xff, 0xff, 255]);
+
+    paint_pixel(&mut p, 0);
+    assert_eq!(p, [0, 0, 0, 255]);
+}
@@ -0,0 +1,87 @@
+mod display;
+
+use winit::{
+    dpi::LogicalSize,
+    event::{Event, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+    window::WindowBuilder,
+};
+
+use vcore::cpu::CPU;
+use vcore::memory::{Memory, PeekPoke};
+use vcore::word::Word;
+use pixels::{Pixels, SurfaceTexture};
+use std::time::{Instant, Duration};
+use winit::window::Window;
+
+fn main() {
+    let event_loop = EventLoop::new();
+
+    let window = {
+        let size = LogicalSize::new(640, 480);
+        WindowBuilder::new()
+            .with_title("Vulcan")
+            .with_inner_size(size)
+            .with_min_inner_size(size)
+            .build(&event_loop)
+            .unwrap()
+    };
+
+    let pixels = {
+        let surface_texture = SurfaceTexture::new(640, 480, &window);
+        Pixels::new(640, 480, surface_texture).unwrap()
+    };
+
+    let rng = rand::thread_rng();
+
+    let memory = Memory::from(rng);
+    let mut cpu = CPU::new(memory);
+    display::reset(&mut cpu);
+    // for n in 0..128 {
+    //     cpu.poke(Word::from(0x10000 + 128 * n), 0b11100000);
+    //     cpu.poke(Word::from(0x10000 + n), 0xff);
+    //     cpu.poke(Word::from(0x10000 + 128 * n + 127), 0b00000011);
+    //     cpu.poke(Word::from(0x10000 + 128 * 127 + n), 0b00011100);
+    // }
+    cpu.poke_slice(Word::from(0x400), include_bytes!("gfx_test.rom"));
+    cpu.start();
+    window_loop(event_loop, window, pixels, cpu)
+}
+
+fn window_loop(event_loop: EventLoop<()>, window: Window, mut pixels: Pixels, mut cpu: CPU) -> ! {
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Poll;
+
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                window_id,
+            } if window_id == window.id() => *control_flow = ControlFlow::Exit,
+
+            Event::WindowEvent {
+                event: WindowEvent::Resized(newSize),
+                window_id
+            } if window_id == window.id() => {
+                pixels.resize_surface(newSize.width, newSize.height);
+            }
+
+            Event::MainEventsCleared => {
+                let start = Instant::now();
+                draw(pixels.get_frame(), &mut cpu);
+                pixels.render().expect("Problem displaying framebuffer");
+                while Instant::now() < start + Duration::from_millis(25) {
+                    for _ in 1..1000 {
+                        cpu.tick()
+                    }
+                }
+            }
+            _ => {}
+        }
+    })
+}
+
+fn draw(frame: &mut [u8], cpu: &mut CPU) {
+    assert_eq!(frame.len(), 640 * 480 * 4);
+
+    display::draw(cpu, frame);
+}