vulcan/src/display.rs

use crate::memory::PeekPoke;
use crate::Word;
use std::convert::TryFrom;

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
struct DisplayRegisters {
    mode: u8,
    screen: u32,
    palette: u32,
    font: u32,
    height: u32,
    width: u32,
    row_offset: u32,
    col_offset: u32,
}

impl Default for DisplayRegisters {
    fn default() -> Self {
        Self {
            mode: 4,
            screen: 0x10000,
            palette: 0x20000 - 0x100,
            font: 0x20000 - 0x100 - 0x2000,
            height: 128,
            width: 128,
            row_offset: 0,
            col_offset: 0,
        }
    }
}

fn read_display_registers<P: PeekPoke>(machine: &P, start: Word) -> DisplayRegisters {
    DisplayRegisters {
        mode: machine.peek(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.into());
    machine.poke24(start + 4, dr.palette.into());
    machine.poke24(start + 7, dr.font.into());
    machine.poke24(start + 10, dr.height.into());
    machine.poke24(start + 13, dr.width.into());
    machine.poke24(start + 16, dr.row_offset.into());
    machine.poke24(start + 19, dr.col_offset.into());
}

fn init_font<P: PeekPoke>(machine: &mut P) {
    let bytes = include_bytes!("font.rom");
    let font_addr = DisplayRegisters::default().font;

    for (offset, byte) in bytes.into_iter().enumerate() {
        machine.poke(Word::from(font_addr + offset as u32), *byte)
    }
}

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;
    let default_palette = [
        0x00, 0x05, 0x65, 0x11, 0xa8, 0x49, 0xeb, 0xff, 0xe1, 0xf4, 0xfc, 0x1c, 0x37, 0x8e, 0xee,
        0xfa,
    ];
    for (i, b) in default_palette.into_iter().enumerate() {
        machine.poke(Word::from(palette_addr + i as u32), b);
    }
}

fn to_byte_address((x, y): (u32, u32), reg: DisplayRegisters) -> u32 {
    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) = ((display_row >> 2) as u32, (display_col >> 2) as u32);

        let vb = machine.peek(Word::from(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) = ((display_row >> 2) as u32, (display_col >> 2) as u32);

        let addr = to_byte_address((vulcan_col, vulcan_row), reg);
        let color_idx = machine.peek(Word::from(addr));
        let color = machine.peek(Word::from(reg.palette + color_idx as u32));
        let (red, green, blue) = (color >> 5, (color >> 2) & 7, (color & 3) << 1);

        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) = ((display_row >> 3) as u32, (display_col >> 3) as u32);

        let addr = to_byte_address((vulcan_col, vulcan_row), reg);
        let char_idx = machine.peek(Word::from(addr));
        let (char_row, char_col) = (display_row % 8, display_col % 8);
        let char_byte = machine.peek(Word::from(
            reg.font + ((char_idx as u32) << 3) + char_row as u32,
        ));

        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(Word::from(reg.palette + fg_color_idx as u32));
        let bg_color = machine.peek(Word::from(reg.palette + bg_color_idx as u32));

        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) = ((display_row >> 3) as u32, (display_col >> 3) as u32);

        let addr = to_byte_address((vulcan_col, vulcan_row), reg);
        let char_idx = machine.peek(Word::from(addr));
        let (char_row, char_col) = (display_row % 8, display_col % 8);
        let char_byte = machine.peek(Word::from(
            reg.font + ((char_idx as u32) << 3) + char_row as u32,
        ));

        let color_addr = addr + (reg.width * reg.height);
        let color = machine.peek(Word::from(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) = ((display_row >> 4) as u32, (display_col >> 4) as u32);

        let addr = to_byte_address((vulcan_col, vulcan_row), reg);
        let char_idx = machine.peek(Word::from(addr));
        let (char_row, char_col) = ((display_row / 2) % 8, (display_col / 2) % 8);
        let char_byte = machine.peek(Word::from(
            reg.font + ((char_idx as u32) << 3) + char_row as u32,
        ));

        let color_addr = addr + (reg.width * reg.height);
        let color = machine.peek(Word::from(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) = ((display_row >> 4) as u32, (display_col >> 4) as u32);

        let addr = to_byte_address((vulcan_col, vulcan_row), reg);
        let char_idx = machine.peek(Word::from(addr));
        let (char_row, char_col) = ((display_row >> 1) % 8, (display_col >> 1) % 8);
        let char_byte = machine.peek(Word::from(
            reg.font + ((char_idx as u32) << 3) + char_row as u32,
        ));

        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(Word::from(reg.palette + fg_color_idx as u32));
        let bg_color = machine.peek(Word::from(reg.palette + bg_color_idx as u32));

        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) = (
                ((display_row - (240 - 64 * 3)) / 3) as u32,
                ((display_col - (320 - 64 * 3)) / 3) as u32,
            );

            let vb = machine.peek(Word::from(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) = (
                ((display_row - (240 - 64 * 3)) / 3) as u32,
                ((display_col - (320 - 64 * 3)) / 3) as u32,
            );

            let color_idx =
                machine.peek(Word::from(to_byte_address((vulcan_col, vulcan_row), reg)));
            let vb = machine.peek(Word::from(reg.palette + color_idx as u32));
            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]);
}