gboxide 0.2.2

A GameBoy Emulator written in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use num_traits::FromPrimitive;

use crate::gameboy::interrupt::{InterruptHandler, Interrupt};

#[derive(Clone, Copy, Debug, FromPrimitive)]
pub enum Clock {
    Clk4096Hz = 0,
    Clk262144Hz = 1,
    Clk65536Hz = 2,
    Clk16384Hz = 3,
}

impl Clock {
    fn ratio(&self) -> u32 {
        use self::Clock::*;
        match *self {
            Clk4096Hz => 1024,
            Clk262144Hz => 16,
            Clk65536Hz => 64,
            Clk16384Hz => 256,
        }
    }
}
impl From<u8> for Clock {
    fn from(value: u8) -> Clock {
        FromPrimitive::from_u8(value).unwrap_or_else(|| panic!("Invalid clock selection {}", value))
    }
}

pub struct Timer {
    divider: u8,
    counter: u32,
    tima: u8,
    modulo: u8,
    enabled: bool,
    clock: Clock,
}

impl Timer {
    pub fn new() -> Timer {
        Timer {
            divider: 0,
            counter: 0,
            tima: 0,
            modulo: 0,
            enabled: false,
            clock: Clock::Clk4096Hz,
        }
    }

    pub fn read_register(&self, addr: u16) -> u8 {
        match addr {
            0xFF04 => self.get_divider(),
            0xFF05 => self.get_counter(),
            0xFF06 => self.get_modulo(),
            0xFF07 => self.get_control(),
            _ => unreachable!(), // mmu will only send us addresses in 0xFF04 - 0xFF07 range
        }
    }

    pub fn write_register(&mut self, addr: u16, value: u8) {
        match addr {
            0xFF04 => self.reset_divider(),
            0xFF05 => self.set_counter(value),
            0xFF06 => self.set_modulo(value),
            0xFF07 => self.set_control(value),
            _ => unreachable!(), // mmu will only send us addresses in 0xFF04 - 0xFF07 range
        }
    }

    fn get_divider(&self) -> u8 {
        self.divider
    }

    fn reset_divider(&mut self) {
        self.divider = 0;
    }

    fn get_counter(&self) -> u8 {
        self.tima
    }

    fn set_counter(&mut self, value: u8) {
        self.tima = value;
    }

    fn get_modulo(&self) -> u8 {
        self.modulo
    }

    fn set_modulo(&mut self, value: u8) {
        self.modulo = value;
    }

    fn get_control(&self) -> u8 {
        self.clock as u8 | if self.enabled { 1 << 2 } else { 0 }
    }

    fn set_control(&mut self, value: u8) {
        self.enabled = (value >> 2) & 0x1 == 1;
        self.clock = Clock::from(value & 0x3);
    }

    pub fn step(&mut self, ih: &mut InterruptHandler) {
        self.divider = self.divider.wrapping_add(4);

        if self.enabled {
            self.counter = self.counter.wrapping_add(4);

            if self.counter >= self.clock.ratio() {
                self.counter -= self.clock.ratio();
                let (tima, overflow) = self.tima.overflowing_add(1);
                if overflow {
                    self.tima = self.modulo;
                    ih.set_interrupt(Interrupt::Timer);
                } else {
                    self.tima = tima;
                }
            }
        }
    }
}