the10thwiz/nes-emu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: the10thwiz:main
Branches Tags
the10thwiz:main
..
compare: the10thwiz:148ab2004d92c19c3fe897ea36267d01cbd7218c
Branches Tags
the10thwiz:main

1 Commits
main ... 148ab2004d

Author SHA1 Message Date
Matthew Pomes
148ab2004d Minor refactors and bug fixes
Some checks failed
Cargo Build & Test / Rust project - latest (stable) (push) Has been cancelled
Details 
- Bit instruction now sets Z flag correctly
- DMA is no longer handled by cpu.rs
 2026-01-26 01:21:37 -06:00
34 changed files with 327 additions and 4887 deletions
Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -1,4 +1,3 @@
/target
*.nes
*.zip
*.dmp

146
Cargo.lock generated
View File

@@ -70,28 +70,6 @@ dependencies = [
"equator",
]
[[package]]
name = "alsa"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c88dbbce13b232b26250e1e2e6ac18b6a891a646b8148285036ebce260ac5c3"
dependencies = [
"alsa-sys",
"bitflags 2.10.0",
"cfg-if",
"libc",
]
[[package]]
name = "alsa-sys"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "db8fee663d06c4e303404ef5f40488a53e062f89ba8bfed81f42325aafad1527"
dependencies = [
"libc",
"pkg-config",
]
[[package]]
name = "android-activity"
version = "0.6.0"
@@ -793,20 +771,6 @@ dependencies = [
"libm",
]
[[package]]
name = "coreaudio-rs"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1aae284fbaf7d27aa0e292f7677dfbe26503b0d555026f702940805a630eac17"
dependencies = [
"bitflags 1.3.2",
"libc",
"objc2-audio-toolbox",
"objc2-core-audio",
"objc2-core-audio-types",
"objc2-core-foundation",
]
[[package]]
name = "cosmic-text"
version = "0.15.0"
@@ -830,36 +794,6 @@ dependencies = [
"unicode-segmentation",
]
[[package]]
name = "cpal"
version = "0.17.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5b1f9c7312f19fc2fa12fd7acaf38de54e8320ba10d1a02dcbe21038def51ccb"
dependencies = [
"alsa",
"coreaudio-rs",
"dasp_sample",
"jni",
"js-sys",
"libc",
"mach2",
"ndk",
"ndk-context",
"num-derive",
"num-traits",
"objc2 0.6.3",
"objc2-audio-toolbox",
"objc2-avf-audio",
"objc2-core-audio",
"objc2-core-audio-types",
"objc2-core-foundation",
"objc2-foundation 0.3.2",
"wasm-bindgen",
"wasm-bindgen-futures",
"web-sys",
"windows 0.62.2",
]
[[package]]
name = "crc32fast"
version = "1.5.0"
@@ -924,12 +858,6 @@ version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f"
[[package]]
name = "dasp_sample"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
[[package]]
name = "dispatch"
version = "0.2.0"
@@ -2078,15 +2006,6 @@ dependencies = [
"num-traits",
]
[[package]]
name = "mach2"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a1b95cd5421ec55b445b5ae102f5ea0e768de1f82bd3001e11f426c269c3aea"
dependencies = [
"libc",
]
[[package]]
name = "malloc_buf"
version = "0.0.6"
@@ -2277,12 +2196,8 @@ name = "nes-emu"
version = "0.1.0"
dependencies = [
"bitfield",
"bytes",
"cpal",
"iced",
"iced_core",
"rfd",
"ringbuf",
"thiserror 2.0.17",
"tokio",
"tracing",
@@ -2486,31 +2401,6 @@ dependencies = [
"objc2-quartz-core 0.3.2",
]
[[package]]
name = "objc2-audio-toolbox"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6948501a91121d6399b79abaa33a8aa4ea7857fe019f341b8c23ad6e81b79b08"
dependencies = [
"bitflags 2.10.0",
"libc",
"objc2 0.6.3",
"objc2-core-audio",
"objc2-core-audio-types",
"objc2-core-foundation",
"objc2-foundation 0.3.2",
]
[[package]]
name = "objc2-avf-audio"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13a380031deed8e99db00065c45937da434ca987c034e13b87e4441f9e4090be"
dependencies = [
"objc2 0.6.3",
"objc2-foundation 0.3.2",
]
[[package]]
name = "objc2-cloud-kit"
version = "0.2.2"
@@ -2546,29 +2436,6 @@ dependencies = [
"objc2-foundation 0.2.2",
]
[[package]]
name = "objc2-core-audio"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e1eebcea8b0dbff5f7c8504f3107c68fc061a3eb44932051c8cf8a68d969c3b2"
dependencies = [
"dispatch2",
"objc2 0.6.3",
"objc2-core-audio-types",
"objc2-core-foundation",
"objc2-foundation 0.3.2",
]
[[package]]
name = "objc2-core-audio-types"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a89f2ec274a0cf4a32642b2991e8b351a404d290da87bb6a9a9d8632490bd1c"
dependencies = [
"bitflags 2.10.0",
"objc2 0.6.3",
]
[[package]]
name = "objc2-core-data"
version = "0.2.2"
@@ -2599,9 +2466,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
dependencies = [
"bitflags 2.10.0",
"block2 0.6.2",
"dispatch2",
"libc",
"objc2 0.6.3",
]
@@ -3349,17 +3214,6 @@ version = "0.8.52"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c6a884d2998352bb4daf0183589aec883f16a6da1f4dde84d8e2e9a5409a1ce"
[[package]]
name = "ringbuf"
version = "0.4.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fe47b720588c8702e34b5979cb3271a8b1842c7cb6f57408efa70c779363488c"
dependencies = [
"crossbeam-utils",
"portable-atomic",
"portable-atomic-util",
]
[[package]]
name = "roxmltree"
version = "0.20.0"

4
Cargo.toml
View File

@@ -7,7 +7,6 @@ edition = "2024"
bitfield = "0.19.3"
# iced = { version = "0.14.0", features = ["debug", "canvas", "tokio", "lazy", "image", "advanced"] }
iced = { path = "../iced", features = ["debug", "canvas", "tokio", "lazy", "image", "advanced"] }
iced_core = { path = "../iced/core", features = ["advanced"] }
rfd = "0.17.2"
# iced_graphics = { version = "0.14.0", features = ["geometry", "image"] }
# iced_widget = { version = "0.13.4", features = ["canvas", "image"] }
@@ -15,6 +14,3 @@ thiserror = "2.0.17"
tokio = { version = "1.48.0", features = ["full"] }
tracing = "0.1.41"
tracing-subscriber = { version = "0.3.20", features = ["ansi", "chrono", "env-filter", "json", "serde"] }
bytes = "*"
cpal = "0.17.1"
ringbuf = "0.4.8"

585
src/apu.rs
View File

@@ -1,70 +1,5 @@
use std::iter::repeat_n;
use iced::{
Element, Font,
widget::{column, text},
};
use tracing::debug;
macro_rules! lut {
($name:ident: [$ty:ty; $len:expr] = |$n:ident| $expr:expr) => {
const $name: [$ty; $len] = {
let mut table = [0; $len];
let mut $n = 0;
while $n < $len {
table[$n] = $expr;
$n += 1;
}
table
};
};
}
bitfield::bitfield! {
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct LengthTimerHigh(u8);
impl Debug;
length, set_length: 7, 3;
u16;
timer_high, set_timer_high: 2, 0;
}
#[derive(Debug, Clone)]
struct LengthCounter {
current: u16,
silenced: bool,
}
impl LengthCounter {
pub fn new() -> Self {
Self {
current: 0,
silenced: true,
}
}
pub fn clock(&mut self) {
if self.current == 0 {
self.silenced = true;
} else {
self.current -= 1;
}
}
pub fn write(&mut self, length: u8) {
// self.reg.0 = val;
self.silenced = false;
const LENGTH_LUT: [u16; 0x20] = [
10, 254, 20, 2, 40, 4, 80, 6, 160, 8, 60, 10, 14, 12, 26, 14, 12, 16, 24, 18, 48, 20,
96, 22, 192, 24, 72, 26, 16, 28, 32, 3,
];
self.current = LENGTH_LUT[length as usize] + 1; // I think?
}
pub fn silenced(&self) -> bool {
self.silenced
}
}
bitfield::bitfield! {
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct DutyVol(u8);
@@ -85,23 +20,24 @@ bitfield::bitfield! {
shift, set_shift: 2, 0;
}
bitfield::bitfield! {
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct LengthTimerHigh(u8);
impl Debug;
length, set_length: 7, 3;
timer_high, set_timer_high: 2, 0;
}
#[derive(Debug, Clone)]
struct PulseChannel {
enabled: bool,
duty_vol: DutyVol,
sweep: Sweep,
sweep_reload: bool,
timer_low: u8,
length_timer_high: LengthTimerHigh,
counter: LengthCounter,
period: u16,
period_timer: u16,
cur: u8,
sample: u8,
envelope_start: bool,
envelope_counter: u8,
envelope_divider: u8,
cur_time: u16,
cur_length: u8,
}
impl PulseChannel {
@@ -110,152 +46,51 @@ impl PulseChannel {
enabled: false,
duty_vol: DutyVol(0),
sweep: Sweep(0),
sweep_reload: false,
counter: LengthCounter::new(),
period: 0,
period_timer: 0,
cur: 0,
sample: 0,
envelope_start: false,
envelope_counter: 0,
envelope_divider: 0,
timer_low: 0,
length_timer_high: LengthTimerHigh(0),
cur_time: 0,
cur_length: 0,
}
}
fn use_envelope(&self) -> bool {
!self.duty_vol.const_vol()
}
fn volume(&self) -> u8 {
self.duty_vol.volume()
}
fn timer(&self) -> u16 {
self.timer_low as u16 | ((self.length_timer_high.timer_high() as u16) << 8)
}
fn length(&self) -> u8 {
self.length_timer_high.length()
}
pub fn write(&mut self, offset: u16, val: u8) {
match offset {
0x00 => {
self.duty_vol.0 = val;
self.envelope_start = true;
}
0x01 => {
self.sweep.0 = val;
self.sweep_reload = true;
},
0x02 => self.period = self.period & 0x700 | (val as u16),
0x03 => {
let reg = LengthTimerHigh(val);
self.counter.write(reg.length());
self.period = (self.period & 0xFF) | (reg.timer_high() << 8);
self.period_timer = self.period;
self.cur = 0;
}
_ => unreachable!(),
}
pub fn reset(&mut self) {
// TODO
self.cur_time = self.timer();
}
fn volume(&self) -> u8 {
if self.duty_vol.const_vol() {
self.duty_vol.volume()
} else {
self.envelope_counter
}
}
pub fn clock(&mut self) {
if !self.enabled {
self.sample = 0;
return;
}
if self.period_timer == 0 {
self.period_timer = self.period;
self.cur = (self.cur + 1) % 8;
const DUTY: [[bool; 8]; 4] = [
[false, true, false, false, false, false, false, false],
[false, true, true, false, false, false, false, false],
[false, true, true, true, true, false, false, false],
[true, false, false, true, true, true, true, true],
];
self.sample = if DUTY[self.duty_vol.duty() as usize][self.cur as usize] {
self.volume()
} else {
0x00
};
if self.cur_time == 0 {
self.cur_time = self.timer();
} else {
self.period_timer -= 1;
self.cur_time -= 1;
}
// TODO
}
pub fn cur_sample(&self) -> u8 {
if self.enabled && !self.counter.silenced() {
self.sample
} else {
0
}
}
pub fn q_frame_clock(&mut self) {
if !self.enabled {
return;
}
if !self.duty_vol.length_counter_halt() {
self.counter.clock();
} else {
self.counter.silenced = false;
}
if !self.duty_vol.const_vol() {
if self.envelope_start || self.envelope_counter == 0 {
self.envelope_counter = 0xF;
self.envelope_divider = self.duty_vol.volume();
self.envelope_start = false;
} else if self.envelope_divider == 0 {
self.envelope_divider = self.duty_vol.volume();
self.envelope_counter -= 1;
} else {
self.envelope_divider -= 1;
}
if !self.duty_vol.length_counter_halt() && self.cur_length > 0 {
self.cur_length -= 1;
}
}
pub fn h_frame_clock(&mut self) {
self.q_frame_clock();
}
pub fn view<T>(&self) -> Element<'_, T> {
text!(
"Square Channel
Evelope Volume: {0:>3} ${0:02X}
Constant Volume: {1}
Length Counter - Halted: {2}
Duty: {3:>3} ${3:02X}
Sweep - Shift: {4:>3} ${4:02X}
Sweep - Negate: {5}
Sweep - Period: {6:>3} ${6:02X}
Sweep - Enabled: {7}
Period: {8:>3} ${8:04X}
Length Counter - Reload Value: {9:>3} ${9:04X}
Enabled: {10}
Timer: {11:>3} ${11:04X}
Duty Position: {12:>3} ${12:02X}
Length Counter - Counter: {13:>3} ${13:02X}
Envelope - Counter: {14:>3} ${14:02X}
Envelope - Divider: {15:>3} ${15:02X}
Output: {16:>3} ${16:02X}
",
self.duty_vol.volume(),
self.duty_vol.const_vol(),
self.duty_vol.length_counter_halt(),
self.duty_vol.duty(),
self.sweep.shift(),
self.sweep.negate(),
self.sweep.period(),
self.sweep.enable(),
self.period,
0,
self.enabled,
self.period_timer,
self.cur, // ?
self.counter.current,
self.envelope_counter,
self.envelope_divider,
self.cur_sample(),
)
.font(Font::MONOSPACE)
.into()
if !self.duty_vol.length_counter_halt() && self.cur_length > 0 {
self.cur_length -= 1;
}
}
}
bitfield::bitfield! {
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct LengthCounterReg(u8);
pub struct CounterLoad(u8);
impl Debug;
halt, set_halt: 7;
value, set_value: 6, 0;
@@ -264,250 +99,20 @@ bitfield::bitfield! {
#[derive(Debug, Clone)]
struct TriangleChannel {
enabled: bool,
length: LengthCounterReg,
reload: bool,
counter: LengthCounter,
length_counter: u16,
cur: u8,
period: u16,
period_timer: u16,
sample: u8,
}
impl TriangleChannel {
pub fn new() -> Self {
Self {
length: LengthCounterReg(0),
counter: LengthCounter::new(),
reload: false,
enabled: false,
sample: 0,
period: 0,
period_timer: 0,
cur: 0,
length_counter: 0,
}
}
pub fn write(&mut self, offset: u16, val: u8) {
match offset {
0x00 => {
self.length.0 = val;
}
0x01 => (),
0x02 => self.period = self.period & 0x700 | (val as u16),
0x03 => {
// self.length_load.0 = val;
// self.reload = true;
let reg = LengthTimerHigh(val);
self.counter.write(reg.length());
self.period = (self.period & 0xFF) | (reg.timer_high() << 8);
self.period_timer = self.period;
self.cur = 0;
}
_ => unreachable!(),
}
}
pub fn cur_sample(&self) -> u8 {
self.sample
}
pub fn clock(&mut self) {
if self.length_counter > 0 && self.period > 0 {
if self.period_timer == 0 {
self.period_timer = self.period;
const SAMPLES: [u8; 32] = [
15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15,
];
self.cur = (self.cur + 1) % SAMPLES.len() as u8;
self.sample = SAMPLES[self.cur as usize];
} else {
self.period_timer -= 1;
}
}
}
pub fn q_frame_clock(&mut self) {
if self.reload {
self.length_counter = self.length.value() as u16;
self.reload = self.length.halt();
} else if self.length_counter == 0 {
} else {
self.length_counter -= 1;
}
}
pub fn h_frame_clock(&mut self) {
self.q_frame_clock();
}
pub fn view<T>(&self) -> Element<'_, T> {
text!(
"Triangle Channel
Linear Counter - Reload: {0:>3} ${0:02X}
Linear Counter - Halted: {1}
Period: {2:>3} ${2:04X}
Length Counter - Reload Value: {3:>3} ${3:04X}
Enabled: {4}
Timer: {5:>3} ${5:02X}
Frequency: ???
Sequence Position: {6:>3} ${6:02X}
Length Counter - Counter: {7:>3} ${7:02X}
Linear Counter - Counter: {8:>3} ${8:02X}
Linear Counter - Reload Flag: {9}
Output: {10:>3} ${10:02X}
",
self.length.value(),
self.length.halt(),
self.period,
0,
self.enabled,
self.period_timer,
self.cur,
0,
self.length_counter,
self.reload,
self.cur_sample(),
)
.font(Font::MONOSPACE)
.into()
}
}
bitfield::bitfield! {
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct NoiseEnvelope(u8);
impl Debug;
length_counter_halt, set_length_counter_halt: 5;
constant_volume, set_constant_volume: 4;
volume, set_volume: 3, 0;
}
bitfield::bitfield! {
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct ModePeriod(u8);
impl Debug;
mode, set_mode: 7;
period, set_period: 3, 0;
}
bitfield::bitfield! {
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct LengthCounterLoad(u8);
impl Debug;
length, set_length: 7, 3;
}
#[derive(Debug, Clone)]
struct NoiseChannel {
enabled: bool,
evelope: NoiseEnvelope,
mode_period: ModePeriod,
length_counter_load: LengthCounterLoad,
shr: u16,
count: u16,
length_counter: u8,
}
impl NoiseChannel {
pub fn new() -> Self {
Self {
enabled: false,
evelope: NoiseEnvelope(0),
mode_period: ModePeriod(0),
length_counter_load: LengthCounterLoad(0),
shr: 1,
count: 0,
length_counter: 0,
}
}
pub fn write(&mut self, offset: u16, val: u8) {
match offset {
0x00 => (),
0x01 => (),
0x02 => (),
0x03 => (),
_ => unreachable!(),
}
}
pub fn cur_sample(&self) -> u8 {
if self.length_counter == 0 || self.shr & 1 == 1 {
0
} else {
self.evelope.volume()
}
}
pub fn clock(&mut self) {
const PERIODS: &[u16] = &[
4, 8, 16, 32, 64, 96, 128, 160, 202, 254, 380, 508, 762, 1016, 2034, 4096,
];
if self.count == PERIODS[self.mode_period.period() as usize] / 2 {
self.count = 0;
let bit_0 = (self.shr & 0b1) << 14;
let other = if self.mode_period.mode() {
(self.shr & 0b100_0000) << 8
} else {
(self.shr & 0b10) << 13
};
self.shr = (self.shr >> 1) | (bit_0 ^ other);
} else {
self.count += 1;
}
}
pub fn q_frame_clock(&mut self) {}
pub fn h_frame_clock(&mut self) {
self.q_frame_clock();
}
pub fn view<T>(&self) -> Element<'_, T> {
text!("").font(Font::MONOSPACE).into()
}
}
#[derive(Debug, Clone)]
struct DeltaChannel {
enabled: bool,
sample: u8,
}
impl DeltaChannel {
pub fn new() -> Self {
Self {
enabled: false,
sample: 0,
}
}
pub fn write(&mut self, offset: u16, val: u8) {
match offset {
0x00 => (),
0x01 => (),
0x02 => (),
0x03 => (),
_ => unreachable!(),
}
}
pub fn cur_sample(&self) -> u8 {
self.sample
}
pub fn clock(&mut self) {}
pub fn q_frame_clock(&mut self) {}
pub fn h_frame_clock(&mut self) {}
pub fn int(&self) -> bool {
false
}
pub fn view<T>(&self) -> Element<'_, T> {
text!("").font(Font::MONOSPACE).into()
}
}
#[derive(Debug, Clone)]
@@ -526,8 +131,6 @@ pub struct APU {
noise: NoiseChannel,
dmc: DeltaChannel,
frame_counter: FrameCounter,
samples: Vec<u8>,
}
impl std::fmt::Debug for APU {
@@ -546,24 +149,17 @@ impl APU {
Self {
pulse_1: PulseChannel::new(),
pulse_2: PulseChannel::new(),
triangle: TriangleChannel::new(),
noise: NoiseChannel::new(),
dmc: DeltaChannel::new(),
triangle: TriangleChannel { enabled: false },
noise: NoiseChannel { enabled: false },
dmc: DeltaChannel { enabled: false },
frame_counter: FrameCounter {
mode_5_step: false,
interrupt_enabled: true,
count: 0,
irq: false,
},
samples: vec![0; 100],
}
}
pub fn reset(&mut self) {
*self = Self::init();
}
pub fn read_reg(&mut self, offset: u16) -> u8 {
// println!("APU read: {offset:02X}");
match offset {
@@ -581,16 +177,44 @@ impl APU {
_ => panic!("No register at {:X}", offset),
}
}
pub fn write_reg(&mut self, offset: u16, val: u8) {
// println!("APU write: {offset:02X} <= {val:02X}");
match offset {
0x00..0x04 => self.pulse_1.write(offset - 0x00, val),
0x04..0x08 => self.pulse_2.write(offset - 0x04, val),
0x08..0x0C => self.triangle.write(offset - 0x08, val),
0x0C..0x10 => self.noise.write(offset - 0x0C, val),
0x10..0x14 => self.dmc.write(offset - 0x10, val),
0x14 => (),
0x00 => self.pulse_1.duty_vol.0 = val,
0x01 => self.pulse_1.sweep.0 = val,
0x02 => self.pulse_1.timer_low = val,
0x03 => {
self.pulse_1.length_timer_high.0 = val;
self.pulse_1.reset();
}
0x04 => self.pulse_2.duty_vol.0 = val,
0x05 => self.pulse_2.sweep.0 = val,
0x06 => self.pulse_2.timer_low = val,
0x07 => {
self.pulse_2.length_timer_high.0 = val;
self.pulse_2.reset();
}
0x09 => (), // Unused, technically noise channel?
0x08 | 0x0A | 0x0B => {
// TODO: Triangle channel
}
0x0D => (), // Unused, technically noise channel?
0x0C | 0x0E | 0x0F => {
// TODO: Noise channel
}
0x10 => {
assert_eq!(val, 0x00);
// TODO: implement this value
}
0x11 => {
// TODO: load dmc counter with (val & 7F)
}
0x12 => {
// TODO: DMC
}
0x13 => {
// TODO: DMC
}
0x15 => {
self.dmc.enabled = val & 0b0001_0000 != 0;
self.noise.enabled = val & 0b0000_1000 != 0;
@@ -612,28 +236,13 @@ impl APU {
fn q_frame_clock(&mut self) {
self.pulse_1.q_frame_clock();
self.pulse_2.q_frame_clock();
self.triangle.q_frame_clock();
self.noise.q_frame_clock();
self.dmc.q_frame_clock();
self.pulse_2.q_frame_clock(); // TODO: clock all
}
fn h_frame_clock(&mut self) {
self.pulse_1.q_frame_clock();
self.pulse_1.h_frame_clock();
self.pulse_2.q_frame_clock();
self.pulse_2.h_frame_clock();
self.triangle.h_frame_clock();
self.noise.h_frame_clock();
self.dmc.h_frame_clock();
}
fn gen_sample(&mut self) {
lut!(P_LUT: [u8; 32] = |n| (95.52 / (8128.0 / n as f64 + 100.0) * 255.0) as u8);
let pulse_out = P_LUT[(self.pulse_1.cur_sample() + self.pulse_2.cur_sample()) as usize];
lut!(TND_LUT: [u8; 204] = |n| (163.67 / (24329.0 / n as f64 + 100.0) * 255.0) as u8);
let tnd_out = TND_LUT[3 * self.triangle.cur_sample() as usize
+ 2 * self.noise.cur_sample() as usize
+ self.dmc.cur_sample() as usize];
self.samples.push(pulse_out + tnd_out);
}
pub fn run_one_clock_cycle(&mut self, ppu_cycle: usize) -> bool {
@@ -659,51 +268,19 @@ impl APU {
self.pulse_1.clock();
self.pulse_2.clock();
self.noise.clock();
self.dmc.clock();
}
if ppu_cycle % 3 == 1 {
self.triangle.clock();
}
if ppu_cycle % (6 * 4) == 1 {
self.gen_sample();
}
false
}
pub fn get_frame_samples(&self) -> &[u8] {
// println!("'Frame' of samples: {}", self.samples.len());
&self.samples
}
pub fn reset_frame_samples(&mut self) {
self.samples.clear();
}
pub fn peek_nmi(&self) -> bool {
false
}
pub fn nmi_waiting(&mut self) -> bool {
false
}
pub fn peek_irq(&self) -> bool {
self.frame_counter.irq
}
pub fn irq_waiting(&mut self) -> bool {
self.frame_counter.irq
}
pub fn view<'s, T: 's>(&'s self) -> Element<'s, T> {
column![
self.pulse_1.view(),
self.pulse_2.view(),
self.triangle.view(),
self.noise.view(),
self.dmc.view(),
]
.into()
}
}

96
src/audio.rs
View File

@@ -1,96 +0,0 @@
use std::{
sync::{
atomic::AtomicBool, mpsc::{channel, Sender, TryRecvError}, Arc
},
time::Instant,
};
use cpal::{
Device, FrameCount, Host, SampleFormat, Stream,
traits::{DeviceTrait, HostTrait, StreamTrait},
};
use ringbuf::{
HeapRb, SharedRb,
traits::{Consumer, Observer, Producer, Split},
wrap::caching::Caching,
};
type SampleTx = Caching<Arc<HeapRb<u8>>, true, false>;
// TODO: Audio should be run through a low-pass filter,
// a high-pass filter, as well as some kind of envelope
// around pause events
pub struct Audio {
_host: Host,
_device: Device,
_stream: Stream,
rb: SampleTx,
last: usize,
max: usize,
paused: Arc<AtomicBool>,
}
impl Audio {
pub fn init() -> Self {
const BUFFER_SIZE: usize = 1 << 10;
let host = cpal::default_host();
let device = host.default_output_device().unwrap();
// let mut configs = device.supported_output_configs().unwrap();
// dbg!(configs.find(|c| c.sample_format() == SampleFormat::U8));
// let v = dbg!(configs.next().unwrap().buffer_size());
// let mut t = 0;
let (prod, mut cons) = SharedRb::new(BUFFER_SIZE * 1024 * 1024).split();
let paused = Arc::new(AtomicBool::new(true));
let paused_inner = Arc::clone(&paused);
let stream = device
.build_output_stream(
&cpal::StreamConfig {
channels: 1,
sample_rate: 60 * 3723,
buffer_size: cpal::BufferSize::Fixed(BUFFER_SIZE as FrameCount),
},
move |a: &mut [u8], _b| {
if !paused_inner.load(std::sync::atomic::Ordering::Acquire) {
let taken = cons.pop_slice(a);
a[taken..].fill(128);
}
},
|e| eprintln!("Audio: {e}"),
None,
)
.unwrap();
stream.play().unwrap();
Self {
_host: host,
_device: device,
_stream: stream,
rb: prod,
paused,
last: 0,
max: 0,
}
}
pub fn pause(&mut self) {
self.paused.store(true, std::sync::atomic::Ordering::Release);
let _ = self._stream.pause();
}
pub fn submit(&mut self, samples: &[u8]) {
let start = self.rb.occupied_len();
self.max = self.max.max(self.last - start);
println!("Buffer size: {:07}, Max: {:07}", start, self.max);
println!(
"Adding: {:07}, Played: {:07}",
samples.len(),
self.last - start
);
self.rb.push_slice(samples);
self.last = self.rb.occupied_len();
if self.last > 9000 {
self.paused.store(false, std::sync::atomic::Ordering::Release);
let _ = self._stream.play();
}
}
}

93
src/controllers.rs
View File

@@ -1,98 +1,15 @@
use bitfield::bitfield;
bitfield! {
#[derive(PartialEq, Eq, Hash, Clone, Copy)]
pub struct ControllerState(u8);
impl Debug;
pub a, set_a: 0;
pub b, set_b: 1;
pub select, set_select: 2;
pub start, set_start: 3;
pub up, set_up: 4;
pub down, set_down: 5;
pub left, set_left: 6;
pub right, set_right: 7;
}
#[derive(Debug, Clone, Copy)]
struct ControllerShiftReg {
state: ControllerState,
shift: u8,
}
impl ControllerShiftReg {
fn new() -> Self {
Self {
state: ControllerState(0),
shift: 0,
}
}
fn read(&mut self) -> u8 {
let val = self.shift & 1;
// Reads after the first 8 are always 1
self.shift = (self.shift >> 1) | 0x80;
val
}
fn load(&mut self) {
self.shift = self.state.0;
}
}
#[derive(Debug, Clone)]
pub struct Controllers {
strobe: bool,
primary: ControllerShiftReg,
secondary: ControllerShiftReg,
}
pub struct Controllers {}
impl Controllers {
pub fn init() -> Self {
Self {
strobe: false,
primary: ControllerShiftReg::new(),
secondary: ControllerShiftReg::new(),
}
Self {}
}
pub fn reset(&mut self) {
*self = Self::init();
}
pub fn read_joy1(&mut self) -> u8 {
if self.strobe {
self.primary.load();
}
// TODO: Technically some kind of open-bus for all but the lowest 3 bits
self.primary.read() | 0x40
0
}
pub fn read_joy2(&mut self) -> u8 {
if self.strobe {
self.secondary.load();
}
self.secondary.read() | 0x40
}
pub fn write_joy_strobe(&mut self, val: u8) {
if val & 1 == 0 {
if self.strobe {
self.primary.load();
self.secondary.load();
}
self.strobe = false;
} else {
self.strobe = true;
self.primary.load();
self.secondary.load();
}
}
pub fn controller_1(&mut self) -> &mut ControllerState {
&mut self.primary.state
}
pub fn controller_2(&mut self) -> &mut ControllerState {
&mut self.secondary.state
0
}
pub fn write_joy_strobe(&mut self, val: u8) { }
}

13
src/cpu.rs
View File

@@ -1955,8 +1955,14 @@ pub enum DmaState {
}
impl DmaState {
pub fn reset(&mut self) {
*self = Self::Passive;
pub fn merge(&mut self, other: DmaState) {
if matches!(other, DmaState::Running { .. }) {
if matches!(self, DmaState::Running { .. }) {
panic!("Merging incompatible dma states");
} else {
*self = other;
}
}
}
pub fn cycle(self, mem: &mut CpuMem<'_>, cpu: &mut Cpu) -> Option<Self> {
@@ -1990,8 +1996,7 @@ impl DmaState {
rem,
read: None,
} => {
if cpu.cycle % 2 == 0 {
writeln!(&mut cpu.debug_log, "DMA: Waiting for cycle").unwrap();
if cpu.cycle % 2 != 1 {
return Some(self);
}
let read = mem.read(cpu_addr);

26
src/debugger.rs
View File

@@ -39,8 +39,8 @@ pub struct DebuggerState {
#[derive(Debug, Clone)]
pub enum DebuggerMessage {
// Run,
// Pause,
Run,
Pause,
SetPPUCycles(usize),
RunPPUCycles,
SetCPUCycles(usize),
@@ -102,6 +102,12 @@ impl DebuggerState {
pub fn view<'s>(&'s self, nes: &'s NES) -> Element<'s, DebuggerMessage> {
column![
row![
button(image("./images/ic_fluent_play_24_filled.png"))
.on_press(DebuggerMessage::Run),
button(image("./images/ic_fluent_pause_24_filled.png"))
.on_press(DebuggerMessage::Pause),
],
iced::widget::rule::horizontal(2.),
row![column![
text("Status"),
@@ -136,7 +142,7 @@ impl DebuggerState {
row![
column![
labelled("Cycle", text(nes.ppu().pixel)),
labelled("Scanline", text(if nes.ppu().scanline == 261 { -1 } else { nes.ppu().scanline as isize })),
labelled("Scanline", text(nes.ppu().scanline)),
labelled("PPU Cycle", text(nes.ppu().cycle)),
labelled("Frame", text(nes.ppu().frame_count)),
labelled("V:", hex16(nes.ppu().background.v)),
@@ -154,13 +160,13 @@ impl DebuggerState {
| ((nes.ppu().background.v >> 2) & 0x07)
)
),
labelled("AT:", hex8(nes.ppu().background.next_attr)),
labelled("AT:", hex8(nes.ppu().background.cur_attr)),
labelled("HI:", bin32(nes.ppu().background.cur_shift_high)),
labelled("LO:", bin32(nes.ppu().background.cur_shift_low)),
],
column![
labelled_box("Sprite 0 Hit", nes.ppu().sprite_zero_hit),
labelled_box("Sprite 0 Overflow", nes.ppu().oam.overflow),
labelled_box("Sprite 0 Hit", false),
labelled_box("Sprite 0 Overflow", false),
labelled_box("Vertical Blank", nes.ppu().vblank),
labelled_box("Write Toggle", nes.ppu().background.w),
text(""),
@@ -332,10 +338,10 @@ impl DebuggerState {
},
|_, nes| nes.cpu.pc as usize == self.breakpoint,
),
// DebuggerMessage::Run => {
// Self::run_until(nes, &Break { ..Break::default() }, |_, nes| nes.halted())
// }
// DebuggerMessage::Pause => todo!(),
DebuggerMessage::Run => {
Self::run_until(nes, &Break { ..Break::default() }, |_, nes| nes.halted())
}
DebuggerMessage::Pause => todo!(),
}
}
}

524
src/hex_view.rs
View File

@@ -1,36 +1,13 @@
use std::{
fmt::{self, Display},
sync::Arc,
};
use std::fmt;
use iced::{
Element, Fill, Font, Padding, Task,
advanced::graphics::text::{
FontSystem,
cosmic_text::{
Attrs, Family, Metrics,
fontdb::{ID, Query},
},
font_system,
},
keyboard::{Key, key::Named},
mouse::{Button, ScrollDelta},
Element, Font,
Length::Fill,
Task,
widget::{column, lazy, row, text},
};
use iced_core::{
Clipboard, Color, Event, Layout, Length, Pixels, Point, Rectangle, Shell, Size, Text, Vector,
Widget,
layout::{Limits, Node},
mouse::{Cursor, Interaction},
overlay,
renderer::{Quad, Style},
widget::{
Operation, Tree,
tree::{State, Tag},
},
};
use crate::{PPU, mem::Mapped, ppu::PPUMMRegisters};
use crate::{mem::Mapped, PPU};
pub trait Memory {
fn peek(&self, val: usize) -> Option<u8>;
@@ -39,7 +16,7 @@ pub trait Memory {
}
#[derive(Debug, Clone, Copy)]
struct Cpu<'a>(&'a Mapped);
pub struct Cpu<'a>(pub &'a Mapped);
impl Memory for Cpu<'_> {
fn peek(&self, val: usize) -> Option<u8> {
@@ -56,19 +33,15 @@ impl Memory for Cpu<'_> {
}
#[derive(Debug, Clone, Copy)]
struct Ppu<'a>(&'a Mapped, &'a PPU);
pub struct Ppu<'a>(pub &'a Mapped);
impl Memory for Ppu<'_> {
fn peek(&self, val: usize) -> Option<u8> {
match self.0.peek_ppu(val as u16) {
Ok(v) => Some(v),
Err(Some((PPUMMRegisters::Palette, off))) => Some(self.1.palette.ram(off as u8)),
Err(None) => None,
}
self.0.peek_ppu(val as u16)
}
fn len(&self) -> usize {
0x4000
0x10000
}
fn edit_ver(&self) -> usize {
@@ -128,477 +101,38 @@ impl HexView {
}
column![
text!("Hex view"),
iced::widget::scrollable(lazy(mem.edit_ver(), move |_| column(
[
text!(" | 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F")
.font(Font::MONOSPACE)
.into()
]
.into_iter()
.chain((0..mem.len()).step_by(16).map(|off| {
text!(" {off:04X} | {}", Row(off, mem))
.font(Font::MONOSPACE)
.into()
}))
)))
iced::widget::scrollable(lazy(
mem.edit_ver(),
move |_| column(
[
text!(" | 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F")
.font(Font::MONOSPACE)
.into()
]
.into_iter()
.chain((0..mem.len()).step_by(16).map(|off| {
text!(" {off:04X} | {}", Row(off, mem))
.font(Font::MONOSPACE)
.into()
}))
)
))
.width(Fill),
]
.width(Fill)
.into()
}
pub fn render_cpu<'a>(&self, mem: &'a Mapped) -> Element<'a, HexEvent> {
// self.render_any(Cpu(mem))
Element::new(
hex_editor::<Cpu<'a>, HexEvent, iced::Renderer>(Cpu(mem)).font(Font::MONOSPACE),
)
self.render_any(Cpu(mem))
}
pub fn render_ppu<'a>(&self, mem: &'a Mapped, ppu: &'a PPU) -> Element<'a, HexEvent> {
// self.render_any(Ppu(mem, ppu))
Element::new(
hex_editor::<Ppu<'a>, HexEvent, iced::Renderer>(Ppu(mem, ppu)).font(Font::MONOSPACE),
)
pub fn render_ppu<'a>(&self, mem: &'a Mapped) -> Element<'a, HexEvent> {
self.render_any(Ppu(mem))
}
pub fn render_oam<'a>(&self, ppu: &'a PPU) -> Element<'a, HexEvent> {
Element::new(
hex_editor::<Oam<'a>, HexEvent, iced::Renderer>(Oam(ppu)).font(Font::MONOSPACE),
)
self.render_any(Oam(ppu))
}
pub fn update(&mut self, ev: HexEvent) -> Task<HexEvent> {
todo!()
}
}
pub trait Buffer {
fn peek(&self, val: usize) -> Option<u8>;
fn len(&self) -> usize;
}
impl Buffer for &[u8] {
fn peek(&self, val: usize) -> Option<u8> {
self.get(val).copied()
}
fn len(&self) -> usize {
self.iter().len()
}
}
impl<M: Memory> Buffer for M {
fn peek(&self, val: usize) -> Option<u8> {
self.peek(val)
}
fn len(&self) -> usize {
self.len()
}
}
pub fn hex_editor<B: Buffer, M, R: iced_core::text::Renderer>(raw: B) -> HexEditor<B, M, R> {
HexEditor {
val: raw,
on_edit: None,
font: None,
font_size: None,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct HexEdit {
position: usize,
old_value: u8,
new_value: u8,
}
pub struct HexEditor<B, M, R: iced_core::text::Renderer> {
val: B,
font_size: Option<Pixels>,
font: Option<R::Font>,
on_edit: Option<Box<dyn Fn(HexEdit) -> M>>,
}
impl<B, M, R> HexEditor<B, M, R>
where
R: iced_core::text::Renderer,
{
pub fn font(mut self, font: R::Font) -> Self {
self.font = Some(font);
self
}
}
impl<B: Buffer, M, R> HexEditor<B, M, R>
where
R: iced_core::text::Renderer,
{
fn value_bounds(&self, renderer: &R, layout: Layout<'_>) -> Rectangle {
let size = self.font_size.unwrap_or(renderer.default_size());
layout
.bounds()
.shrink(Padding::new(0.).top(size.0 * 1.5).right(10.))
}
fn scrollbar_bounds(&self, renderer: &R, layout: Layout<'_>) -> Rectangle {
let size = self.font_size.unwrap_or(renderer.default_size());
layout.bounds().shrink(
Padding::new(0.)
.top(size.0 * 1.5)
.left(layout.bounds().width - 10.),
)
}
fn row_height(&self, renderer: &R) -> f32 {
self.font_size.unwrap_or(renderer.default_size()).0 * LINE_HEIGHT
}
fn scroll_max(&self, renderer: &R, layout: Layout<'_>) -> f32 {
let size = self.font_size.unwrap_or(renderer.default_size());
let bounds = layout.bounds().shrink(Padding::new(0.).top(size.0 * 1.5));
let rows = self.val.len().div_ceil(0x10);
(self.row_height(renderer) * rows as f32 - bounds.height).max(0.)
}
fn scroll(
&self,
state: &mut HexEditorState,
renderer: &R,
layout: Layout<'_>,
delta: &ScrollDelta,
) {
// let size = self.font_size.unwrap_or(renderer.default_size());
// let bounds = layout.bounds().shrink(Padding::new(0.).top(size.0 * 1.5));
// let rows = self.val.len().div_ceil(0x10);
let max = self.scroll_max(renderer, layout);
// println!("max: {max}, rows: {rows}");
match delta {
ScrollDelta::Lines { y, .. } => {
state.offset_y += y * self.row_height(renderer);
}
ScrollDelta::Pixels { y, .. } => {
state.offset_y += y;
}
}
if state.offset_y > 0. {
state.offset_y = 0.;
} else if state.offset_y < -max {
state.offset_y = -max;
}
}
}
#[derive(Default)]
struct HexEditorState {
offset_y: f32,
selected: usize,
dragging: bool,
}
const LINE_HEIGHT: f32 = 1.3;
impl<B: Buffer, M, T, R> Widget<M, T, R> for HexEditor<B, M, R>
where
R: iced_core::text::Renderer,
{
fn tag(&self) -> Tag {
Tag::of::<HexEditorState>()
}
fn state(&self) -> State {
State::new(HexEditorState::default())
}
fn size(&self) -> Size<Length> {
Size::new(Length::Fill, Length::Fill)
}
fn layout(&mut self, _tree: &mut Tree, _renderer: &R, limits: &Limits) -> Node {
Node::new(limits.max())
}
fn draw(
&self,
tree: &Tree,
renderer: &mut R,
theme: &T,
style: &Style,
layout: Layout<'_>,
cursor: Cursor,
viewport: &Rectangle,
) {
let state: &HexEditorState = tree.state.downcast_ref();
let size = self.font_size.unwrap_or(renderer.default_size());
let font = self.font.unwrap_or(renderer.default_font());
// let fonts = font_system();
// let mut font_sys = fonts.write().unwrap();
// let id = font_sys.raw().db().query(&Query {
// families: &[Family::Monospace],
// ..Query::default()
// });
// let f = font_sys.raw().get_font(id.unwrap(), iced::advanced::graphics::text::cosmic_text::Weight(1)).unwrap();
// let width = f.metrics();
// println!("Width: {width:?}");
// iced::advanced::graphics::text::cosmic_text::Buffer::new(
// font_sys.raw(),
// Metrics::new(size.0, size.0),
// ).layout_runs();
// TODO: this needs to be computed from the font
let col_width = 0.6 * size.0;
let rows = self.val.len().div_ceil(0x10);
let row_label_length = rows.ilog2().div_ceil(4) as usize;
let mut draw = |v: &str, pos: Point| {
renderer.fill_text(
Text {
content: format!("{}", v),
bounds: viewport.size(),
size,
line_height: size.into(),
font,
align_x: iced_core::text::Alignment::Left,
align_y: iced_core::alignment::Vertical::Top,
shaping: iced_core::text::Shaping::Basic,
wrapping: iced_core::text::Wrapping::None,
hint_factor: None,
},
pos,
Color::WHITE,
layout.bounds(),
);
};
draw("0", Point::new(0., 0.));
for i in 0..0x10 {
draw(
"0",
layout.position()
+ Vector::new((3 + row_label_length + 3 * i) as f32 * col_width, 0.),
);
draw(
"0",
layout.position()
+ Vector::new((4 + row_label_length + 3 * i) as f32 * col_width, 0.),
);
}
// renderer.fill_text(
// Text {
// content: format!(
// "{:width$} 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F {}",
// "",
// state.offset_y,
// width = row_label_length
// ),
// bounds: viewport.size(),
// size,
// line_height: size.into(),
// font,
// align_x: iced_core::text::Alignment::Left,
// align_y: iced_core::alignment::Vertical::Top,
// shaping: iced_core::text::Shaping::Basic,
// wrapping: iced_core::text::Wrapping::None,
// hint_factor: None,
// },
// layout.position(),
// Color::WHITE,
// layout.bounds(),
// );
struct HexV(Option<u8>);
impl Display for HexV {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.0 {
Some(v) => write!(f, "{:02X}", v),
None => write!(f, "XX"),
}
}
}
// if rows > 0 {
// rows.ilog2()
// }
let bounds = self.value_bounds(renderer, layout);
let mut pos = bounds.position() + Vector::new(0., state.offset_y);
for row in 0..rows {
if bounds.contains(pos) || bounds.contains(pos + Vector::new(0., size.0 * LINE_HEIGHT))
{
renderer.fill_text(
Text {
content: format!(
"{:0width$X}0: {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}",
row,
HexV(self.val.peek(row * 0x10 + 0x0)),
HexV(self.val.peek(row * 0x10 + 0x1)),
HexV(self.val.peek(row * 0x10 + 0x2)),
HexV(self.val.peek(row * 0x10 + 0x3)),
HexV(self.val.peek(row * 0x10 + 0x4)),
HexV(self.val.peek(row * 0x10 + 0x5)),
HexV(self.val.peek(row * 0x10 + 0x6)),
HexV(self.val.peek(row * 0x10 + 0x7)),
HexV(self.val.peek(row * 0x10 + 0x8)),
HexV(self.val.peek(row * 0x10 + 0x9)),
HexV(self.val.peek(row * 0x10 + 0xA)),
HexV(self.val.peek(row * 0x10 + 0xB)),
HexV(self.val.peek(row * 0x10 + 0xC)),
HexV(self.val.peek(row * 0x10 + 0xD)),
HexV(self.val.peek(row * 0x10 + 0xE)),
HexV(self.val.peek(row * 0x10 + 0xF)),
width = row_label_length,
),
bounds: viewport.size(),
size,
line_height: size.into(),
font,
align_x: iced_core::text::Alignment::Left,
align_y: iced_core::alignment::Vertical::Top,
shaping: iced_core::text::Shaping::Basic,
wrapping: iced_core::text::Wrapping::None,
hint_factor: None,
},
pos,
Color::WHITE,
bounds,
);
}
pos += Vector::new(0., size.0 * LINE_HEIGHT);
}
let scrollbar = self.scrollbar_bounds(renderer, layout);
renderer.fill_quad(
Quad {
bounds: scrollbar,
..Quad::default()
},
Color::BLACK,
);
let pos = state.offset_y / self.scroll_max(renderer, layout);
renderer.fill_quad(
Quad {
bounds: Rectangle::new(
Point::new(scrollbar.x, scrollbar.y - pos * (scrollbar.height - 20.)),
Size::new(10., 20.),
),
..Quad::default()
},
Color::WHITE,
);
}
fn operate(
&mut self,
_tree: &mut Tree,
_layout: Layout<'_>,
_renderer: &R,
_operation: &mut dyn Operation,
) {
}
fn update(
&mut self,
tree: &mut Tree,
event: &Event,
layout: Layout<'_>,
cursor: Cursor,
renderer: &R,
_clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, M>,
_viewport: &Rectangle,
) {
// if !matches!(event, Event::Window(_)) {
// println!("Event: {:#?}", event);
// }
match event {
Event::Keyboard(iced::keyboard::Event::KeyPressed {
key: Key::Named(Named::PageUp),
..
}) => {
let state: &mut HexEditorState = tree.state.downcast_mut();
self.scroll(
state,
renderer,
layout,
&ScrollDelta::Pixels {
x: 0.,
y: self.value_bounds(renderer, layout).height,
},
);
shell.request_redraw();
shell.capture_event();
}
Event::Keyboard(iced::keyboard::Event::KeyPressed {
key: Key::Named(Named::PageDown),
..
}) => {
let state: &mut HexEditorState = tree.state.downcast_mut();
self.scroll(
state,
renderer,
layout,
&ScrollDelta::Pixels {
x: 0.,
y: -self.value_bounds(renderer, layout).height,
},
);
shell.request_redraw();
shell.capture_event();
}
Event::Mouse(iced::mouse::Event::WheelScrolled { delta }) => {
let state: &mut HexEditorState = tree.state.downcast_mut();
let bounds = self.value_bounds(renderer, layout);
if cursor.is_over(bounds) {
self.scroll(state, renderer, layout, delta);
shell.request_redraw();
shell.capture_event();
}
}
Event::Mouse(iced::mouse::Event::ButtonPressed(Button::Left)) => {
let state: &mut HexEditorState = tree.state.downcast_mut();
let bounds = self.scrollbar_bounds(renderer, layout);
if let Some(pos) = cursor.position_in(bounds) {
state.offset_y = -(pos.y / bounds.height * self.scroll_max(renderer, layout));
state.dragging = true;
shell.request_redraw();
shell.capture_event();
}
}
Event::Mouse(iced::mouse::Event::ButtonReleased(Button::Left)) => {
let state: &mut HexEditorState = tree.state.downcast_mut();
state.dragging = false;
}
// Event::Mouse(iced::mouse::Event::CursorLeft) => {
// let state: &mut HexEditorState = tree.state.downcast_mut();
// state.dragging = false;
// }
Event::Mouse(iced::mouse::Event::CursorMoved { .. }) => {
let state: &mut HexEditorState = tree.state.downcast_mut();
if state.dragging {
let bounds = self.scrollbar_bounds(renderer, layout);
if let Some(pos) = cursor.position_in(bounds) {
state.offset_y =
-(pos.y / bounds.height * self.scroll_max(renderer, layout));
shell.request_redraw();
shell.capture_event();
}
}
}
_ => (),
}
}
fn mouse_interaction(
&self,
_tree: &Tree,
_layout: Layout<'_>,
_cursor: Cursor,
_viewport: &Rectangle,
_renderer: &R,
) -> Interaction {
Interaction::None
}
fn overlay<'a>(
&'a mut self,
_tree: &'a mut Tree,
_layout: Layout<'a>,
_renderer: &R,
_viewport: &Rectangle,
_translation: Vector,
) -> Option<overlay::Element<'a, M, T, R>> {
None
}
}

62
src/lib.rs
View File

@@ -10,7 +10,6 @@ mod ppu;
pub mod resize_watcher;
#[cfg(test)]
mod test_roms;
pub mod audio;
pub use ppu::{Color, PPU, RenderBuffer};
use tokio::io::AsyncReadExt as _;
@@ -21,7 +20,7 @@ use thiserror::Error;
use crate::{
apu::APU,
controllers::{ControllerState, Controllers},
controllers::Controllers,
cpu::{CPUMMRegisters, ClockState, Cpu, CycleResult, DmaState},
debug::DebugLog,
mem::{CpuMem, Mapped, PpuMem},
@@ -173,14 +172,14 @@ impl NES {
br: &Break,
) -> bool {
if let Some(dma) = self.dma.cycle(
&mut CpuMem::new(
&mut self.mapped,
&mut self.ppu,
&mut self.apu,
&mut self.dma,
&mut self.controller,
),
&mut self.cpu,
&mut CpuMem::new(
&mut self.mapped,
&mut self.ppu,
&mut self.apu,
&mut self.dma,
&mut self.controller,
),
&mut self.cpu
) {
self.dma = dma;
false
@@ -212,7 +211,22 @@ impl NES {
};
}
let cpu_exec = if self.clock_count % 3 == 0 && self.clock_count > 0 {
if self.run_cpu_cycle(br) {
let nmi = self.ppu.nmi_waiting() || self.apu.nmi_waiting();
let irq = self.ppu.irq_waiting() || self.apu.irq_waiting();
let mut dma = DmaState::Passive;
if self.run_cpu_cycle(
// &mut CpuMem::new(
// &mut self.mapped,
// &mut self.ppu,
// &mut self.apu,
// &mut dma,
// &mut self.controller,
// ),
// &mut self.dma,
// nmi,
// irq,
br,
) {
println!("Returning early from clock_cycle");
return CycleResult {
cpu_exec: true,
@@ -221,6 +235,7 @@ impl NES {
dbg_int: true,
};
}
self.dma.merge(dma);
self.cpu.cpu_cycle_update();
self.cpu.executed()
} else if self.clock_count == 0 {
@@ -253,17 +268,6 @@ impl NES {
}
pub fn reset(&mut self) {
self.clock_count = 0;
// dbg_int: false,
// clock_count: 0,
// mapped,
// cpu: Cpu::init(),
// dma: DmaState::Passive,
// // ppu: PPU::with_chr_rom(chr_rom, mapper),
// ppu: PPU::init(),
// apu: APU::init(),
// controller: Controllers::init(),
self.cpu.reset(&mut CpuMem::new(
&mut self.mapped,
&mut self.ppu,
@@ -271,10 +275,7 @@ impl NES {
&mut self.dma,
&mut self.controller,
));
self.dma.reset();
self.ppu.reset();
self.apu.reset();
self.controller.reset();
}
pub fn power_cycle(&mut self) {
@@ -350,10 +351,6 @@ impl NES {
&self.apu
}
pub fn apu_mut(&mut self) -> &mut APU {
&mut self.apu
}
pub fn debug_log(&self) -> &DebugLog {
&self.cpu.debug_log
}
@@ -376,13 +373,6 @@ impl NES {
pub fn cpu_cycle(&self) -> usize {
self.cpu.cycle
}
pub fn controller_1(&mut self) -> &mut ControllerState {
self.controller.controller_1()
}
pub fn controller_2(&mut self) -> &mut ControllerState {
self.controller.controller_2()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]

221
src/main.rs
View File

@@ -1,25 +1,20 @@
use std::{
collections::HashMap,
fmt,
time::{Duration, Instant},
};
use std::{collections::HashMap, fmt, time::Duration};
use iced::{
Element,
Color, Element,
Length::{Fill, Shrink},
Point, Rectangle, Renderer, Size, Subscription, Task, Theme,
keyboard::{self, Key, Modifiers, key::Named},
mouse, time,
Point, Renderer, Size, Subscription, Task, Theme,
advanced::graphics::compositor::Display,
mouse,
widget::{
self, Canvas, button,
Canvas,
canvas::{Frame, Program},
column, container, image, row,
column, container, row,
},
window::{self, Id, Settings},
};
use nes_emu::{
Break, NES,
audio::Audio,
NES,
debugger::{DbgImage, DebuggerMessage, DebuggerState, dbg_image},
header_menu::header_menu,
hex_view::{HexEvent, HexView},
@@ -33,17 +28,7 @@ use tracing_subscriber::EnvFilter;
// const ROM_FILE: &str = concat!(env!("ROM_DIR"), "/", "ppu_fill_red.nes");
// const ROM_FILE: &str = concat!(env!("ROM_DIR"), "/", "ppu_fill_name_table.nes");
// const ROM_FILE: &str = concat!(env!("ROM_DIR"), "/", "int_nmi_exit_timing.nes");
// const ROM_FILE: &str = concat!(env!("ROM_DIR"), "/", "render-updating.nes");
// const ROM_FILE: &str = concat!(env!("ROM_DIR"), "/", "ppu_palette_shared.nes");
// const ROM_FILE: &str = concat!(env!("ROM_DIR"), "/", "input_test.nes");
// const ROM_FILE: &str = concat!(env!("ROM_DIR"), "/", "scrolling.nes");
// const ROM_FILE: &str = concat!(env!("ROM_DIR"), "/", "scrolling_colors.nes");
// const ROM_FILE: &str = concat!(env!("ROM_DIR"), "/", "sprites.nes");
// const ROM_FILE: &str = concat!(env!("ROM_DIR"), "/", "apu_pulse_channel_1.nes");
// const ROM_FILE: &str = concat!(env!("ROM_DIR"), "/", "apu_pulse_channel_1_evelope.nes");
const ROM_FILE: &str = concat!(env!("ROM_DIR"), "/", "apu_pulse_1.nes");
// const ROM_FILE: &str = concat!(env!("ROM_DIR"), "/", "apu_triangle.nes");
// const ROM_FILE: &str = "./Super Mario Bros. (World).nes";
const ROM_FILE: &str = "./Super Mario Bros. (World).nes";
// const ROM_FILE: &str = "./cpu_timing_test.nes";
// const ROM_FILE: &str = "../nes-test-roms/instr_test-v5/official_only.nes";
@@ -83,7 +68,6 @@ enum WindowType {
TileViewer,
Palette,
Debugger,
Apu,
}
#[derive(Debug, Clone, PartialEq, Eq)]
@@ -109,7 +93,6 @@ impl fmt::Display for HeaderButton {
Self::Open(WindowType::Debugger) => write!(f, "Open Debugger"),
Self::Open(WindowType::Palette) => write!(f, "Open Palette"),
Self::Open(WindowType::Main) => write!(f, "Create new Main window"),
Self::Open(WindowType::Apu) => write!(f, "Open APU info"),
Self::Reset => write!(f, "Reset"),
Self::PowerCycle => write!(f, "Power Cycle"),
Self::OpenRom => write!(f, "Open ROM file"),
@@ -118,13 +101,10 @@ impl fmt::Display for HeaderButton {
}
struct Emulator {
running: bool,
nes: NES,
windows: HashMap<Id, WindowType>,
debugger: DebuggerState,
main_win_size: Size,
prev: [Instant; 2],
audio: Audio,
}
#[derive(Debug, Clone)]
@@ -137,9 +117,6 @@ enum Message {
// DebugInt,
WindowClosed(Id),
WindowOpened(Id),
Key(keyboard::Event),
Periodic(Instant),
SetRunning(bool),
Header(HeaderButton),
Hex(Id, HexEvent),
Debugger(DebuggerMessage),
@@ -151,43 +128,38 @@ impl Emulator {
fn new() -> (Self, Task<Message>) {
let mut nes = nes_emu::NES::load_nes_file(ROM_FILE).expect("Failed to load nes file");
nes.reset();
// TODO: remove
// let mut count = 10;
// while !nes.halted() {
// if nes.run_one_clock_cycle().ppu_frame {
// count -= 1;
// if count <= 0 {
// break;
// }
// }
// }
let (win, task) = iced::window::open(Settings {
min_size: None,
..Settings::default()
});
// let (win_2, task_2) = iced::window::open(Settings {
// min_size: None,
// ..Settings::default()
// });
(
Self {
nes,
windows: HashMap::from_iter([
(win, WindowType::Main),
// (win_2, WindowType::Debugger),
]),
windows: HashMap::from_iter([(win, WindowType::Main)]),
debugger: DebuggerState::new(),
main_win_size: Size::new(0., 0.),
running: false,
prev: [Instant::now(); 2],
audio: Audio::init(),
},
Task::batch([
task,
// task_2
])
.discard(), // task.discard(),
task.discard(),
)
}
fn title(&self, win: Id) -> String {
match self.windows.get(&win) {
Some(WindowType::Main) => "NES emu".into(),
Some(WindowType::Memory(ty, _)) => format!("NES {ty:?} Memory"),
Some(WindowType::Memory(_, _)) => "NES MemoryView".into(),
Some(WindowType::TileMap) => "NES TileMap".into(),
Some(WindowType::TileViewer) => "NES Tile Viewer".into(),
Some(WindowType::Palette) => "NES Palette Viewer".into(),
Some(WindowType::Debugger) => "NES Debugger".into(),
Some(WindowType::Apu) => "NES APU Debugger".into(),
None => todo!(),
}
}
@@ -294,101 +266,6 @@ impl Emulator {
})
.discard();
}
Message::Key(key) => match key {
keyboard::Event::KeyPressed {
key: Key::Character(val),
modifiers: Modifiers::CTRL,
repeat: false,
..
} => {
if val == "t" {
self.nes.reset();
}
}
keyboard::Event::KeyPressed {
key,
modifiers: Modifiers::NONE,
repeat: false,
..
} => {
if key == Key::Character("z".into()) {
self.nes.controller_1().set_a(true);
} else if key == Key::Character("x".into()) {
self.nes.controller_1().set_b(true);
} else if key == Key::Character("a".into()) {
self.nes.controller_1().set_select(true);
} else if key == Key::Character("s".into()) {
self.nes.controller_1().set_start(true);
} else if key == Key::Named(Named::ArrowDown) {
self.nes.controller_1().set_down(true);
} else if key == Key::Named(Named::ArrowUp) {
self.nes.controller_1().set_up(true);
} else if key == Key::Named(Named::ArrowLeft) {
self.nes.controller_1().set_left(true);
} else if key == Key::Named(Named::ArrowRight) {
self.nes.controller_1().set_right(true);
} else if key == Key::Named(Named::Play) || key == Key::Named(Named::MediaPlay)
{
self.running = true;
} else if key == Key::Named(Named::Pause)
|| key == Key::Named(Named::MediaPause)
{
self.running = false;
} else if key == Key::Named(Named::MediaPlayPause)
|| key == Key::Named(Named::Space)
{
self.running = !self.running;
}
}
keyboard::Event::KeyReleased {
key,
modifiers: Modifiers::NONE,
..
} => {
if key == Key::Character("z".into()) {
self.nes.controller_1().set_a(false);
} else if key == Key::Character("x".into()) {
self.nes.controller_1().set_b(false);
} else if key == Key::Character("a".into()) {
self.nes.controller_1().set_select(false);
} else if key == Key::Character("s".into()) {
self.nes.controller_1().set_start(false);
} else if key == Key::Named(Named::ArrowDown) {
self.nes.controller_1().set_down(false);
} else if key == Key::Named(Named::ArrowUp) {
self.nes.controller_1().set_up(false);
} else if key == Key::Named(Named::ArrowLeft) {
self.nes.controller_1().set_left(false);
} else if key == Key::Named(Named::ArrowRight) {
self.nes.controller_1().set_right(false);
}
}
_ => (),
},
Message::Periodic(_i) => {
if self.running {
// TODO: Smarter frame skip
if self.prev[0].elapsed() >= Duration::from_millis(2) {
self.nes.run_one_clock_cycle(&Break::default());
let mut count = 0;
while !self.nes.run_one_clock_cycle(&Break::default()).ppu_frame
&& !self.nes.halted()
{
count += 1;
if count > 100000 {
println!("Loop overran...");
break;
}
}
self.prev[0] = Instant::now();
self.audio.submit(self.nes.apu().get_frame_samples());
self.nes.apu_mut().reset_frame_samples();
}
} else {
self.audio.pause();
}
}
Message::SetRunning(running) => self.running = running,
}
// self.image.0.clone_from(self.nes.image());
Task::none()
@@ -398,13 +275,10 @@ impl Emulator {
Subscription::batch([
window::close_events().map(Message::WindowClosed),
window::open_events().map(Message::WindowOpened),
keyboard::listen().map(Message::Key),
time::every(Duration::from_secs_f64(1./60.)).map(Message::Periodic),
])
}
fn view(&self, win: Id) -> Element<'_, Message> {
// println!("Running view");
match self.windows.get(&win) {
Some(WindowType::Main) => {
let content = column![
@@ -426,7 +300,7 @@ impl Emulator {
.render_cpu(self.nes.mem())
.map(move |e| Message::Hex(win, e)),
MemoryTy::PPU => view
.render_ppu(self.nes.mem(), self.nes.ppu())
.render_ppu(self.nes.mem())
.map(move |e| Message::Hex(win, e)),
MemoryTy::OAM => view
.render_oam(self.nes.ppu())
@@ -446,20 +320,11 @@ impl Emulator {
Some(WindowType::Palette) => {
dbg_image(DbgImage::Palette(self.nes.mem(), self.nes.ppu())).into()
}
Some(WindowType::Debugger) => column![
row![
button(image("./images/ic_fluent_play_24_filled.png"))
.on_press(Message::SetRunning(true)),
button(image("./images/ic_fluent_pause_24_filled.png"))
.on_press(Message::SetRunning(false)),
],
self.debugger.view(&self.nes).map(Message::Debugger)
]
.width(Fill)
.height(Fill)
.into(),
Some(WindowType::Apu) => {
self.nes.apu().view()
Some(WindowType::Debugger) => {
container(self.debugger.view(&self.nes).map(Message::Debugger))
.width(Fill)
.height(Fill)
.into()
}
None => panic!("Window not found"),
// _ => todo!(),
@@ -487,7 +352,6 @@ impl Emulator {
HeaderButton::Open(WindowType::TileMap),
HeaderButton::Open(WindowType::TileViewer),
HeaderButton::Open(WindowType::Palette),
HeaderButton::Open(WindowType::Apu),
],
Message::Header
)
@@ -508,18 +372,25 @@ impl Program<Message> for Emulator {
bounds: iced::Rectangle,
_cursor: mouse::Cursor,
) -> Vec<iced::widget::canvas::Geometry<Renderer>> {
let mut frame = Frame::new(renderer, bounds.size());
frame.scale(2.);
frame.draw_image(
Rectangle::new(Point::new(0., 0.), Size::new(256., 240.)),
widget::canvas::Image::new(widget::image::Handle::from_rgba(
256,
240,
self.nes.image().image(),
))
.filter_method(image::FilterMethod::Nearest)
.snap(true),
// const SIZE: f32 = 2.;
let mut frame = Frame::new(
renderer,
bounds.size(), // iced::Size {
// width: 256. * 2.,
// height: 240. * 2.,
// },
);
frame.scale(2.);
for y in 0..240 {
for x in 0..256 {
let c = self.nes.image().read(y, x);
frame.fill_rectangle(
Point::new(x as f32, y as f32),
Size::new(1., 1.),
Color::from_rgb8(c.r, c.g, c.b),
);
}
}
vec![frame.into_geometry()]
}
}

32
src/mem.rs
View File

@@ -6,13 +6,13 @@ use crate::{
};
#[derive(Debug, Clone)]
pub enum Value<R> {
pub enum Value<'a, R> {
Value(u8),
Register { reg: R, offset: u16 },
Register { reg: &'a R, offset: u16 },
}
impl<R> Value<R> {
pub fn reg_map(self, f: impl FnOnce(R, u16) -> u8) -> u8 {
impl<R> Value<'_, R> {
pub fn reg_map(self, f: impl FnOnce(&R, u16) -> u8) -> u8 {
match self {
Value::Value(v) => v,
Value::Register { reg, offset } => f(reg, offset),
@@ -117,7 +117,7 @@ pub struct MemoryMap<R> {
}
impl<R: Copy> MemoryMap<R> {
pub fn read(&self, addr: u16) -> Value<R> {
pub fn read(&self, addr: u16) -> Value<'_, R> {
// self.edit_ver += 1;
for segment in &self.segments {
if segment.position <= addr && addr - segment.position < segment.size {
@@ -125,7 +125,7 @@ impl<R: Copy> MemoryMap<R> {
Data::RAM(items) => Value::Value(items[(addr - segment.position) as usize]),
Data::ROM(items) => Value::Value(items[(addr - segment.position) as usize]),
Data::Reg(reg) => Value::Register {
reg: *reg,
reg,
offset: addr - segment.position,
},
Data::Mirror(pos) => {
@@ -201,28 +201,28 @@ impl<R: Copy> MemoryMap<R> {
None
}
fn peek_val(&self, addr: u16) -> Result<u8, Option<(R, u16)>> {
fn peek_val(&self, addr: u16) -> Option<u8> {
for segment in &self.segments {
if segment.position <= addr && addr - segment.position < segment.size {
return match &segment.mem {
Data::RAM(items) => Ok(items[(addr - segment.position) as usize]),
Data::ROM(items) => Ok(items[(addr - segment.position) as usize]),
Data::Reg(r) => Err(Some((*r, addr - segment.position))),
Data::RAM(items) => Some(items[(addr - segment.position) as usize]),
Data::ROM(items) => Some(items[(addr - segment.position) as usize]),
Data::Reg(_) => None,
Data::Mirror(pos) => {
let offset = addr - segment.position;
self.peek_val(pos + offset)
}
Data::Disabled => Err(None),
Data::Disabled => None,
};
}
}
Err(None)
None
}
}
impl<R: Copy> Memory for MemoryMap<R> {
fn peek(&self, addr: usize) -> Option<u8> {
self.peek_val(addr as u16).ok()
self.peek_val(addr as u16)
}
fn len(&self) -> usize {
@@ -455,14 +455,14 @@ impl Mapped {
}
}
pub fn peek_ppu(&self, addr: u16) -> Result<u8, Option<(PPUMMRegisters, u16)>> {
pub fn peek_ppu(&self, addr: u16) -> Option<u8> {
self.ppu.peek_val(addr)
}
pub fn ppu_edit_ver(&self) -> usize {
self.ppu.edit_ver
}
pub fn peek_cpu(&self, addr: u16) -> Option<u8> {
self.cpu.peek_val(addr).ok()
self.cpu.peek_val(addr)
}
pub fn cpu_edit_ver(&self) -> usize {
self.cpu.edit_ver
@@ -638,7 +638,7 @@ impl<'a> PpuMem<'a> {
pub fn new(mem: &'a mut Mapped) -> Self {
Self(mem)
}
pub fn read(&mut self, addr: u16) -> Value<PPUMMRegisters> {
pub fn read(&mut self, addr: u16) -> Value<'_, PPUMMRegisters> {
self.0.ppu.read(addr)
}
pub fn write(&mut self, addr: u16, val: u8, reg_fn: impl FnOnce(&PPUMMRegisters, u16, u8)) {

433
src/ppu.rs
View File

@@ -1,13 +1,15 @@
use std::fmt;
use bytes::{Bytes, BytesMut};
use iced::{
Point, Size,
advanced::graphics::geometry::Renderer,
widget::canvas::{Fill, Frame},
};
use crate::mem::{Mapped, PpuMem, Value};
use crate::{
hex_view::Memory,
mem::{Mapped, PpuMem},
};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Color {
@@ -31,25 +33,18 @@ impl fmt::Display for Color {
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct RenderBuffer<const W: usize, const H: usize> {
buffer: Box<[Color]>,
raw_rgba: BytesMut,
}
impl<const W: usize, const H: usize> RenderBuffer<W, H> {
pub fn empty() -> Self {
Self {
buffer: vec![Color { r: 0, g: 0, b: 0 }; W * H].into_boxed_slice(),
raw_rgba: BytesMut::from_iter(vec![0; W * H * 4]),
}
}
pub fn write(&mut self, line: usize, pixel: usize, color: Color) {
assert!(line < H && pixel < W);
self.buffer[line * W + pixel] = color;
let pos = (line * W + pixel) * 4;
self.raw_rgba[pos] = color.r;
self.raw_rgba[pos + 1] = color.g;
self.raw_rgba[pos + 2] = color.b;
self.raw_rgba[pos + 3] = 0xFF;
}
pub fn read(&self, line: usize, pixel: usize) -> Color {
assert!(line < H && pixel < W);
@@ -58,12 +53,6 @@ impl<const W: usize, const H: usize> RenderBuffer<W, H> {
pub fn clone_from(&mut self, other: &Self) {
self.buffer.copy_from_slice(&other.buffer);
// self.raw_rgba.fr
self.raw_rgba.copy_from_slice(&other.raw_rgba);
}
pub fn image(&self) -> Bytes {
Bytes::copy_from_slice(&self.raw_rgba)
}
pub fn assert_eq(&self, other: &Self) {
@@ -83,221 +72,35 @@ impl<const W: usize, const H: usize> RenderBuffer<W, H> {
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[derive(Debug, Clone, Copy)]
pub enum PPUMMRegisters {
Palette,
}
bitfield::bitfield! {
#[derive(Default, Clone, Copy, PartialEq, Eq, Hash)]
pub struct SpriteAttrs(u8);
impl Debug;
vflip, set_vflip: 7;
hflip, set_hflip: 6;
priority, set_priority: 5;
palette, set_palette: 1, 0;
}
#[derive(Debug, Clone, Default)]
struct SpriteOutputUnit {
high: u8,
low: u8,
x_pos: u8,
y_pos: u8,
tile: u8,
attrs: SpriteAttrs,
}
#[derive(Debug, Clone)]
enum OamState {
ReadY,
ReadTile,
ReadAttrs,
ReadX,
OverflowScan,
Wait,
}
#[derive(Debug, Clone)]
pub struct OAM {
mem: Vec<u8>,
secondary: Vec<u8>,
addr: u8,
count: u8,
state: OamState,
oam_read_buffer: u8,
edit_ver: usize,
sprite_output_units: Vec<SpriteOutputUnit>,
large_sprites: bool,
pub overflow: bool,
sprite_offset_0x1000: bool,
}
impl OAM {
fn new() -> Self {
Self {
mem: vec![0u8; 256],
addr: 0,
count: 0,
edit_ver: 0,
secondary: vec![0xFF; 32],
sprite_output_units: vec![SpriteOutputUnit::default(); 8],
state: OamState::ReadY,
oam_read_buffer: 0,
overflow: false,
sprite_offset_0x1000: false,
large_sprites: false,
}
}
fn ppu_cycle(&mut self, pixel: usize, line: usize, mem: &mut PpuMem<'_>) {
if pixel < 64 {
} else if pixel == 64 {
self.secondary.fill(0xFF);
self.state = OamState::ReadY;
self.addr = 0;
self.count = 0;
} else if pixel <= 256 {
// Fetch/evalute sprites for next line
if pixel % 2 == 1 && !matches!(self.state, OamState::Wait) {
self.oam_read_buffer = self.mem[self.addr as usize];
if self.addr == 255 {
self.addr = 0;
} else {
self.addr += 1;
}
} else {
match self.state {
OamState::ReadY => {
let l = self.oam_read_buffer as usize;
if self.count < 8 {
if l <= line && line < l + 8 {
self.secondary[self.count as usize * 4] = self.oam_read_buffer;
self.state = OamState::ReadTile;
} else {
if self.addr < 0xFD {
self.addr += 3;
} else {
self.state = OamState::Wait; // Should be Overflow scan...
}
}
} else {
self.state = OamState::Wait; // Should be Overflow scan...
}
}
OamState::ReadTile => {
self.secondary[self.count as usize * 4 + 1] = self.oam_read_buffer;
self.state = OamState::ReadAttrs;
}
OamState::ReadAttrs => {
self.secondary[self.count as usize * 4 + 2] = self.oam_read_buffer;
self.state = OamState::ReadX;
}
OamState::ReadX => {
self.secondary[self.count as usize * 4 + 3] = self.oam_read_buffer;
self.state = OamState::ReadY;
self.count += 1;
if self.count == 8 {
self.state = OamState::Wait; // Should be Overflow scan...
}
}
OamState::OverflowScan => todo!(),
OamState::Wait => (),
}
}
} else if pixel <= 320 {
if pixel == 257 {
// Reset output units
self.sprite_output_units.fill(SpriteOutputUnit::default());
}
let run = pixel - 257;
if run / 8 < self.count as usize {
if run % 8 == 0 {
self.sprite_output_units[run / 8].y_pos = self.secondary[(run / 8) * 4];
} else if run % 8 == 1 {
self.sprite_output_units[run / 8].tile = self.secondary[(run / 8) * 4 + 1];
} else if run % 8 == 2 {
self.sprite_output_units[run / 8].attrs.0 = self.secondary[(run / 8) * 4 + 2];
} else if run % 8 == 3 {
self.sprite_output_units[run / 8].x_pos = self.secondary[(run / 8) * 4 + 3];
} else if run % 8 == 4 {
} else if run % 8 == 5 {
let off = line - self.sprite_output_units[run / 8].y_pos as usize;
let off = if self.sprite_output_units[run / 8].attrs.vflip() {
7 - off
} else {
off
};
let addr = if self.sprite_offset_0x1000 {
0x1000
} else {
0x0000
} + 16 * self.sprite_output_units[run / 8].tile as u16
+ off as u16;
self.sprite_output_units[run / 8].low = mem.read(addr).reg_map(|_, _| todo!());
} else if run % 8 == 6 {
} else if run % 8 == 7 {
let off = line - self.sprite_output_units[run / 8].y_pos as usize;
let off = if self.sprite_output_units[run / 8].attrs.vflip() {
7 - off
} else {
off
};
let addr = if self.sprite_offset_0x1000 {
0x1000
} else {
0x0000
} + 16 * self.sprite_output_units[run / 8].tile as u16
+ off as u16
+ 8;
self.sprite_output_units[run / 8].high = mem.read(addr).reg_map(|_, _| todo!());
}
}
}
}
/// Returns Some((palette index, above background))
fn pixel(&mut self, pixel: usize, _line: usize) -> Option<(u8, bool, bool)> {
self.sprite_output_units
.iter()
.enumerate()
.filter_map(|(i, s)| {
if pixel >= s.x_pos as usize && pixel < s.x_pos as usize + 8 && s.x_pos < 0xFF {
let bit_pos = pixel - s.x_pos as usize;
let bit_pos = if s.attrs.hflip() {
bit_pos
} else {
7 - bit_pos
};
// println!("Shifting: 0b{:08b} by {}", s.high, 8 - bit_pos);
let hi = (s.high >> bit_pos) & 1;
// println!("Shifting: 0b{:08b} by {}", s.low, bit_pos);
let lo = (s.low >> bit_pos) & 1;
let idx = (hi << 1) | lo;
if idx != 0 {
Some((
idx + s.attrs.palette() * 4 + 0x10,
!s.attrs.priority(),
i == 0,
))
} else {
None
}
} else {
None
}
})
.next()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum BackgroundState {
NameTableBytePre,
NameTableByte,
AttrTableBytePre,
AttrTableByte,
PatternTableTileLowPre,
PatternTableTileLow,
PatternTableTileHighPre,
PatternTableTileHigh,
}
#[derive(Debug, Clone)]
pub struct Background {
/// Current vram address, 15 bits
/// yyy NN YYYYY XXXXX (0yyy NNYY YYYX XXXX)
pub v: u16,
/// Temp vram address, 15 bits
/// yyy NN YYYYY XXXXX
pub t: u16,
/// Fine X control, 3 bits
pub x: u8,
@@ -305,20 +108,20 @@ pub struct Background {
/// When false, writes to x
pub w: bool,
copy_v: u8,
/// When true, v is incremented by 32 after each read
pub vram_column: bool,
pub second_pattern: bool,
state: BackgroundState,
pub cur_nametable: u8,
pub cur_attr: u8,
pub next_attr: u8,
pub next_attr_2: u8,
pub cur_high: u8,
pub cur_low: u8,
pub cur_shift_high: u32,
pub cur_shift_low: u32,
pub cur_attr_shift_high: u32,
pub cur_attr_shift_low: u32,
}
#[derive(Debug, Clone, Copy)]
@@ -663,13 +466,9 @@ pub struct Palette {
}
impl Palette {
pub fn color(&self, idx: u8) -> Color {
pub fn color(&self, idx: u8, palette: u8) -> Color {
debug_assert!(idx < 0x20, "Palette index out of range");
self.colors[(self.ram[idx as usize] & 0x3F) as usize]
}
pub fn ram(&self, offset: u8) -> u8 {
self.ram[offset as usize]
self.colors[(self.ram[idx as usize + palette as usize * 4] & 0x3F) as usize]
}
}
@@ -683,15 +482,12 @@ pub struct PPU {
pub scanline: usize,
pub pixel: usize,
vram_buffer: u8,
pub mask: Mask,
pub vblank: bool,
pub sprite_zero_hit: bool,
pub palette: Palette,
palette: Palette,
pub background: Background,
pub oam: OAM,
oam: OAM,
pub render_buffer: RenderBuffer<256, 240>,
pub dbg_int: bool,
pub cycle: usize,
@@ -743,9 +539,9 @@ impl PPU {
],
},
vblank: false,
sprite_zero_hit: false,
frame_count: 0,
nmi_enabled: false,
// nmi_waiting: false,
even: false,
scanline: 0,
pixel: 25,
@@ -755,20 +551,23 @@ impl PPU {
t: 0,
x: 0,
w: false,
copy_v: 0,
vram_column: false,
second_pattern: false,
state: BackgroundState::NameTableBytePre,
cur_high: 0,
cur_low: 0,
cur_shift_high: 0,
cur_shift_low: 0,
cur_attr_shift_high: 0,
cur_attr_shift_low: 0,
cur_nametable: 0,
cur_attr: 0,
next_attr: 0,
next_attr_2: 0,
},
oam: OAM {
mem: vec![0u8; 256],
addr: 0,
edit_ver: 0,
},
oam: OAM::new(),
vram_buffer: 0,
}
}
pub fn reset(&mut self) {
@@ -784,9 +583,7 @@ impl PPU {
0 => panic!("ppuctrl is write-only"),
1 => panic!("ppumask is write-only"),
2 => {
let tmp = if self.vblank { 0b1000_0000 } else { 0 }
| if self.sprite_zero_hit { 0b0100_0000 } else { 0 }
| if self.oam.overflow { 0b0010_0000 } else { 0 };
let tmp = if self.vblank { 0b1000_0000 } else { 0 };
self.vblank = false;
self.background.w = false;
tmp
@@ -796,17 +593,11 @@ impl PPU {
5 => panic!("ppuscroll is write-only"),
6 => panic!("ppuaddr is write-only"),
7 => {
let val = match mem.read(self.background.v) {
Value::Value(v) => {
let val = self.vram_buffer;
self.vram_buffer = v;
val
}
Value::Register {
reg: PPUMMRegisters::Palette,
offset,
} => self.palette.ram[offset as usize],
};
// println!("Updating v for ppudata read");
let val = mem.read(self.background.v).reg_map(|a, off| match a {
PPUMMRegisters::Palette => self.palette.ram[off as usize],
});
// if self.background
self.increment_v();
val
}
@@ -817,18 +608,12 @@ impl PPU {
pub fn write_reg(&mut self, mem: &mut PpuMem, offset: u16, mut val: u8) {
match offset {
0x00 => {
self.background.t =
(self.background.t & !0b0000_1100_0000_0000) | (((val & 0b11) as u16) << 10);
self.background.vram_column = val & 0b0000_0100 != 0;
self.oam.sprite_offset_0x1000 = val & 0b0000_1000 != 0;
self.background.second_pattern = val & 0b0001_0000 != 0;
self.oam.large_sprites = val & 0b0010_0000 != 0;
if val & 0b0100_0000 != 0 {
println!(
"WARNING: Bit 6 set in PPUCTRL - may cause damage on physical hardware"
);
}
self.nmi_enabled = val & 0b1000_0000 != 0;
self.background.t =
(self.background.t & 0b0001_1000_0000_0000) | (((val & 0b11) as u16) << 10);
self.background.vram_column = val & 0b0000_0100 != 0;
self.background.second_pattern = val & 0b0001_0000 != 0;
// TODO: other control fields
}
0x01 => {
// self.dbg_int = true;
@@ -844,6 +629,7 @@ impl PPU {
}
0x02 => {
todo!("Unable to write to PPU status")
// TODO: ppu status
}
0x03 => self.oam.addr = val,
0x04 => {
@@ -870,32 +656,30 @@ impl PPU {
}
}
0x06 => {
// TODO: ppu addr
if self.background.w {
self.background.t =
u16::from_le_bytes([val, self.background.t.to_le_bytes()[1]]);
self.background.v =
u16::from_le_bytes([val, self.background.v.to_le_bytes()[1]]);
self.background.w = false;
self.background.copy_v = 2; // Set t to be copied to v in a pixel or so
} else {
self.background.t =
u16::from_le_bytes([self.background.t.to_le_bytes()[0], val & 0b0011_1111]);
self.background.v =
u16::from_le_bytes([self.background.v.to_le_bytes()[0], val & 0b0011_1111]);
self.background.w = true;
}
// println!("Updating v for ppuaddr write: to {:04X}", self.background.v);
// self.dbg_int = true;
// todo!("PPUADDR write")
}
0x07 => {
// println!("Writing: {:02X}, @{:04X}", val, self.background.v);
mem.write(self.background.v, val, |r, mut o, v| match r {
mem.write(self.background.v, val, |r, o, v| match r {
PPUMMRegisters::Palette => {
// println!("Writing {:02X} to {:02X}", v & 0x3F, o);
if o % 4 == 0 {
o = o & !0b1_0000;
self.palette.ram[o as usize] = v & 0x3F;
self.palette.ram[(o | 0b1_0000) as usize] = v & 0x3F;
} else {
self.palette.ram[o as usize] = v & 0x3F;
}
self.palette.ram[o as usize] = v & 0x3F;
}
});
self.increment_v();
// self.background.v += 1; // TODO: implement inc behavior
}
_ => panic!("No register at {:02X}", offset),
}
@@ -908,24 +692,24 @@ impl PPU {
} else {
self.background.v += 1;
}
// self.background.v = self
// .background
// .v
// .wrapping_add(if self.background.vram_column { 32 } else { 1 });
}
// pub fn write_oamdma(&mut self, val: u8) {
// // TODO: OAM high addr
// }
pub fn run_one_clock_cycle(&mut self, mem: &mut PpuMem<'_>) -> bool {
self.cycle += 1;
self.pixel += 1;
if self.background.copy_v > 0 {
self.background.copy_v -= 1;
if self.background.copy_v == 0 {
self.background.v = self.background.t;
}
}
if self.scanline == 261
&& (self.pixel == 341 || (self.pixel == 340 && self.even && self.rendering_enabled()))
{
self.scanline = 0;
self.pixel = 0;
self.even = !self.even;
self.frame_count += 1;
}
if self.pixel == 341 {
self.pixel = 0;
@@ -941,68 +725,40 @@ impl PPU {
self.background.v = (self.background.v & 0b0000_0100_0001_1111)
| (self.background.t & 0b0111_1011_1110_0000);
}
if self.scanline != 261 {
self.oam.ppu_cycle(self.pixel, self.scanline, mem);
if self.pixel > 280 && self.pixel < 320 {
self.background.cur_shift_high <<= 1;
self.background.cur_shift_low <<= 1;
}
// TODO
if self.pixel == 0 {
if self.scanline == 1 {
// let h_scroll_offset = self.background.x as usize + ((self.background.t as usize & 0b11) << 3);
// dbg!(h_scroll_offset);
// dbg!((self.scanline, &self.oam.sprite_output_units[0]));
// dbg!(&self.oam.secondary);
}
// self.dbg_int = true;
// idle cycle
} else if self.pixel < 257 || self.pixel > 320 {
// self.dbg_int = true;
// const POS: u32 = 1 << 15;
let bg_color = if self.mask.enable_background {
let bit_pos = 15 - self.background.x;
// Determine background color
let a = (self.background.cur_shift_high >> bit_pos) & 1;
let b = (self.background.cur_shift_low >> bit_pos) & 1;
let val = (a << 1) | b;
debug_assert!(val < 4);
const POS: u32 = 1 << 15;
// Determine background color
let a = self.background.cur_shift_high & POS;
let b = self.background.cur_shift_low & POS;
let val = (a >> 14) | (b >> 15);
debug_assert!(val < 4);
let a = (self.background.cur_attr_shift_high >> bit_pos) & 1;
let b = (self.background.cur_attr_shift_low >> bit_pos) & 1;
let palette = ((a << 1) | b) as u8;
debug_assert!(palette < 4);
val as u8 + if val != 0 { palette * 4 } else { 0 }
} else {
0
};
let h_off = ((self.pixel - 1) / 16) % 2;
let v_off = (self.scanline / 16) % 2;
let off = v_off * 4 + h_off * 2;
let palette = (self.background.cur_attr >> off) & 0x3;
if self.scanline < 240 && self.pixel < 257 {
let color = if let Some((sp_color, above, is_sprite_zero)) = self
.mask
.enable_sprites
.then_some(())
.and(self.oam.pixel(self.pixel, self.scanline))
{
if is_sprite_zero && sp_color != 0 && bg_color != 0 {
self.sprite_zero_hit = true;
}
if sp_color == 0 || (bg_color != 0 && !above) {
bg_color
} else {
sp_color
}
} else {
bg_color
};
// Write to screen
self.render_buffer.write(
self.scanline,
self.pixel - 1,
self.palette.color(color),
);
self.palette
.color(val as u8, if val != 0 { palette } else { 0 }), // self.palette.colors[val as usize],
); // TODO: this should come from shift registers
}
if self.pixel < 337 {
self.background.cur_shift_high <<= 1;
self.background.cur_shift_low <<= 1;
self.background.cur_attr_shift_high <<= 1;
self.background.cur_attr_shift_low <<= 1;
}
if self.scanline < 240 || self.scanline == 261 {
@@ -1023,10 +779,8 @@ impl PPU {
| ((self.background.v >> 2) & 0x07);
// println!("Cur: {:04X}, comp: {:04X}", addr, addr_2);
// assert_eq!(addr, addr_2);
let val = mem
.read(addr)
.reg_map(|_, offset| self.palette.ram(offset as u8));
self.background.next_attr = val;
let val = mem.read(addr).reg_map(|_, _| 0); // TODO: handle reg reads
self.background.next_attr_2 = val;
} else if self.pixel % 8 == 6 {
// BG pattern low
let addr = self.background.cur_nametable as u16 * 16
@@ -1053,14 +807,8 @@ impl PPU {
self.background.cur_high = val;
self.background.cur_shift_low |= self.background.cur_low as u32;
self.background.cur_shift_high |= self.background.cur_high as u32;
let h_off = (self.background.v >> 1) % 2;
let v_off = (self.background.v >> 6) % 2;
let off = h_off * 2 + v_off * 4;
let palette = (self.background.next_attr >> off) & 0b11;
self.background.cur_attr_shift_low |=
if palette & 0b01 == 0 { 0 } else { 0xFF };
self.background.cur_attr_shift_high |=
if palette & 0b10 == 0 { 0 } else { 0xFF };
self.background.cur_attr = self.background.next_attr;
self.background.next_attr = self.background.next_attr_2;
// Inc horizontal
if self.background.v & 0x1F == 31 {
self.background.v = (self.background.v & !0x1F) ^ 0x400;
@@ -1090,16 +838,19 @@ impl PPU {
}
}
}
} else {
// TODO: Sprite fetches
}
}
}
if self.scanline == 261 && self.pixel == 1 {
self.vblank = false;
self.sprite_zero_hit = false;
self.oam.overflow = false;
// TODO: clear sprite 0 & sprite overflow
}
if self.scanline == 241 && self.pixel == 1 {
self.vblank = true;
self.frame_count += 1;
self.background.state = BackgroundState::NameTableBytePre;
return true;
}
return false;
@@ -1158,10 +909,10 @@ impl PPU {
),
Size::new(1., 1.),
match (low & (1 << bit) != 0, high & (1 << bit) != 0) {
(false, false) => self.palette.color(0),
(true, false) => self.palette.color(1 + 4 * palette),
(false, true) => self.palette.color(2 + 4 * palette),
(true, true) => self.palette.color(3 + 4 * palette),
(false, false) => self.palette.color(0, 0),
(true, false) => self.palette.color(1, palette),
(false, true) => self.palette.color(2, palette),
(true, true) => self.palette.color(3, palette),
// (false, false) => Color { r: 0, g: 0, b: 0 },
// (true, false) => Color {
// r: 64,

8
src/test_roms/alu_bit.s
View File

@@ -19,14 +19,6 @@ reset:
pla
sta RAM+0
lda #$F0
sta $400
lda #$0F
bit $400
php
pla
sta RAM+1
stp
nmi:

97
src/test_roms/apu_pulse_1.s
View File

@@ -1,97 +0,0 @@
.include "testing.s"
.include "audio_inp.s"
zp_res TIMER_LOW
; zp_res TIMER_LOW
; zp_res TIMER_LOW
; zp_res TIMER_LOW
reset:
sei
cld
ldx #$FF
txs
lda #$01
sta SNDCHN
lda #$AF ; Duty 2, LC halted, evelope enabled, volume = F
sta PULSE_CH1_DLCV
lda #$7F ;
sta PULSE_CH1_SWEEP
lda #$6F
sta PULSE_CH1_TLOW
sta TIMER_LOW
lda #$F0
sta PULSE_CH1_LCTH
; PULSE_CH1_DLCV = $4000
; PULSE_CH1_SWEEP = $4001
; PULSE_CH1_TLOW = $4002
; PULSE_CH1_LCTH = $4003
jsr init_view
load_ppu_addr $2041
write_char_x 't'
write_char_x 'i'
write_char_x 'm'
write_char_x 'e'
write_char_x 'r'
write_char_x ' '
write_char_x 'l'
write_char_x 'o'
write_char_x 'w'
write_char_x ':'
load_ppu_addr $2061
; write_char_x 't'
; write_char_x 'i'
; write_char_x 'm'
; write_char_x 'e'
; write_char_x 'r'
; write_char_x ' '
; write_char_x 'h'
; write_char_x 'o'
; write_char_x 'w'
; write_char_x ':'
load_ppu_addr $204C
lda TIMER_LOW
jsr write_hex_a
jsr enable_rendering
loop:
jmp loop
; Joystick is in A and JOYTEMP
zp_res JOY_PREV
audio_nmi:
EOR JOY_PREV
STA JOY_PREV
lda JOYTEMP
and #JOY_UP_MASK
and JOY_PREV
beq next_1
load_ppu_addr $204C
lda #$01
adc TIMER_LOW
sta TIMER_LOW
sta PULSE_CH1_TLOW
jsr write_hex_a
next_1:
lda JOYTEMP
and #JOY_DOWN_MASK
and JOY_PREV
beq next_2
load_ppu_addr $204C
lda #$FF
adc TIMER_LOW
sta TIMER_LOW
sta PULSE_CH1_TLOW
jsr write_hex_a
next_2:
lda JOYTEMP
STA JOY_PREV
rts
irq:
rti

104
src/test_roms/apu_pulse_channel_1.s
View File

@@ -1,104 +0,0 @@
.include "testing.s"
.include "minimal_ppu.s"
reset:
sei
cld
ldx #$FF
txs
lda #$01
sta SNDCHN
lda #$BF ; Duty 2, LC halted, Constant volume, volume = F
sta PULSE_CH1_DLCV
lda #$7F ;
sta PULSE_CH1_SWEEP
lda #$6F
sta PULSE_CH1_TLOW
sta TIMER_LOW
lda #$00
sta PULSE_CH1_LCTH
; PULSE_CH1_DLCV = $4000
; PULSE_CH1_SWEEP = $4001
; PULSE_CH1_TLOW = $4002
; PULSE_CH1_LCTH = $4003
jmp init_ppu_and_wait
; zp_res
zp_res TIMER_LOW
update_audio:
; adc TIMER_LOW
; sta PULSE_CH1_TLOW
; sta TIMER_LOW
rts
zp_res PRESSED_A
zp_res PRESSED_B
nmi:
pha
txa
pha
tya
pha
lda PPUSTATUS
lda #%00000110
sta PPUMASK ; Force blank
lda #$01
sta JOY1
lda #$00
sta JOY1
lda JOY1 ; A
and #$01
tax
eor PRESSED_A
beq done
stx PRESSED_A
txa
and #$01
beq done
lda #$08
jsr update_audio
done:
bit JOY1 ; B
and #$01
tax
eor PRESSED_B
beq done_b
stx PRESSED_B
txa
and #$01
beq done_b
lda #$F7
jsr update_audio
done_b:
bit JOY1 ; Select
bit JOY1 ; Start
bit JOY1 ; Up
bit JOY1 ; Down
bit JOY1 ; Left
bit JOY1 ; Right
lda #$00
sta PPUSCROLL
sta PPUSCROLL
lda #%00001110
sta PPUMASK ; Enable rendering
pla
tay
pla
tax
pla
rti
irq:
rti

60
src/test_roms/apu_pulse_channel_1_evelope.s
View File

@@ -1,60 +0,0 @@
.include "testing.s"
.include "joysticks.s"
.include "minimal_ppu.s"
reset:
sei
cld
ldx #$FF
txs
lda #$01
sta SNDCHN
lda #$AF ; Duty 2, LC halted, evelope enabled, volume = F
sta PULSE_CH1_DLCV
lda #$7F ;
sta PULSE_CH1_SWEEP
lda #$6F
sta PULSE_CH1_TLOW
sta TIMER_LOW
lda #$F0
sta PULSE_CH1_LCTH
; PULSE_CH1_DLCV = $4000
; PULSE_CH1_SWEEP = $4001
; PULSE_CH1_TLOW = $4002
; PULSE_CH1_LCTH = $4003
jmp init_ppu_and_wait
; zp_res
zp_res TIMER_LOW
update_audio:
adc TIMER_LOW
sta PULSE_CH1_TLOW
sta TIMER_LOW
rts
zp_res PRESSED_A
zp_res PRESSED_B
nmi:
nmi_start
jsr read_joy1
and #$80
beq not_a
lda #$08
jsr update_audio
not_a:
lda JOYTEMP
and #$40
beq not_b
lda #$01
jsr update_audio
not_b:
nmi_end
irq:
rti

135
src/test_roms/apu_triangle.s
View File

@@ -1,135 +0,0 @@
.include "testing.s"
reset:
sei
cld
ldx #$FF
txs
; Init PPU
bit PPUSTATUS
vwait1:
bit PPUSTATUS
bpl vwait1
vwait2:
bit PPUSTATUS
bpl vwait2
lda #$04
sta SNDCHN
lda #$FF
sta TRIANGLE_LINEAR_C
lda #$37
sta TRIANGLE_TIMER_LOW
lda #$00
sta TRIANGLE_LEN_T_HIGH
; TRIANGLE_LINEAR_C = $4008
; TRIANGLE_TIMER_LOW = $400A
; TRIANGLE_LEN_T_HIGH = $400B
lda #$80
sta PPUCTRL ; NMI on, PPU slave, Small sprites, 0 addresses
lda #$00
loop:
; sta SNDMODE
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
; nop
jmp loop
; zp_res
zp_res TIMER_LOW
update_audio:
; adc TIMER_LOW
; sta PULSE_CH1_TLOW
; sta TIMER_LOW
rts
zp_res PRESSED_A
zp_res PRESSED_B
nmi:
pha
txa
pha
tya
pha
lda PPUSTATUS
lda #%00000110
sta PPUMASK ; Force blank
lda #$01
sta JOY1
lda #$00
sta JOY1
lda JOY1 ; A
and #$01
tax
eor PRESSED_A
beq done
stx PRESSED_A
txa
and #$01
beq done
lda #$08
jsr update_audio
done:
bit JOY1 ; B
and #$01
tax
eor PRESSED_B
beq done_b
stx PRESSED_B
txa
and #$01
beq done_b
lda #$F7
jsr update_audio
done_b:
bit JOY1 ; Select
bit JOY1 ; Start
bit JOY1 ; Up
bit JOY1 ; Down
bit JOY1 ; Left
bit JOY1 ; Right
lda #$00
sta PPUSCROLL
sta PPUSCROLL
lda #%00001110
sta PPUMASK ; Enable rendering
pla
tay
pla
tax
pla
rti
irq:
rti

109
src/test_roms/common/audio_inp.s
View File

@@ -1,109 +0,0 @@
.include "joysticks.s"
; Characters for view
.include "bitmap_font.s"
zp_res TEMP
.macro load_ppu_addr addr
lda #.hibyte(addr)
sta PPUADDR
lda #.lobyte(addr)
sta PPUADDR ; Load $2000
.endmacro
init_view:
; Init PPU
bit PPUSTATUS
vwait1:
bit PPUSTATUS
bpl vwait1
vwait2:
bit PPUSTATUS
bpl vwait2
lda #$00
sta PPUCTRL ; NMI off, PPU slave, Small sprites, 0 addresses
; Fill NT0
load_ppu_addr $2000
ldx #$00
ldy #$04
lda #EMPTY
fill_loop:
sta PPUDATA
dex
bne fill_loop
dey
bne fill_loop
load_ppu_addr $23C0
ldx #$C0
lda #$00
palette_loop:
sta PPUDATA
dex
bne palette_loop
load_ppu_addr $3F00
lda #$0f
sta PPUDATA
lda #$20
sta PPUDATA
sta PPUDATA
sta PPUDATA
lda #$0f
sta PPUDATA
lda #$09
sta PPUDATA
sta PPUDATA
sta PPUDATA
rts
enable_rendering:
lda #$00
sta PPUSCROLL
sta PPUSCROLL
lda #%00001110
sta PPUMASK
lda #$80
sta PPUCTRL ; NMI on, PPU slave, Small sprites, 0 addresses
rts
nmi:
lda PPUSTATUS
lda #%00000110
sta PPUMASK ; Force blank
jsr read_joy1
jsr audio_nmi
.macro bit_lsr val
.scope
lsr
bcs carry_set
ldx #EMPTY
jmp carry_clear
carry_set:
ldx val
carry_clear:
stx PPUDATA
.endscope
.endmacro
load_ppu_addr $2008
lda JOYTEMP
bit_lsr #RIGHT
bit_lsr #LEFT
bit_lsr #DOWN
bit_lsr #UP
bit_lsr #PILL
bit_lsr #PILL
bit_lsr #$0B
bit_lsr #$0A
lda #$00
sta PPUSCROLL
sta PPUSCROLL
lda #%00001110
sta PPUMASK ; Enable rendering
rti

530
src/test_roms/common/bitmap_font.s
View File

@@ -1,530 +0,0 @@
.pushseg
.segment "CHARS"
.repeat 2 ; 0
.byte %00000000
.byte %00111000
.byte %01000100
.byte %01001100
.byte %01010100
.byte %01100100
.byte %01000100
.byte %00111000
.endrepeat
.repeat 2 ; 1
.byte %00000000
.byte %00010000
.byte %00110000
.byte %01010000
.byte %00010000
.byte %00010000
.byte %00010000
.byte %01111000
.endrepeat
.repeat 2 ; 2
.byte %00000000
.byte %00111000
.byte %01000100
.byte %00000100
.byte %00001000
.byte %00010000
.byte %00100000
.byte %01111100
.endrepeat
.repeat 2 ; 3
.byte %00000000
.byte %00111000
.byte %01000100
.byte %00000100
.byte %00011000
.byte %00000100
.byte %01000100
.byte %00111000
.endrepeat
.repeat 2 ; 4
.byte %00000000
.byte %00001000
.byte %00011000
.byte %00101000
.byte %01001000
.byte %11111100
.byte %00001000
.byte %00001000
.endrepeat
.repeat 2 ; 5
.byte %00000000
.byte %01111110
.byte %01000000
.byte %01000000
.byte %01111100
.byte %00000010
.byte %01000010
.byte %00111100
.endrepeat
.repeat 2 ; 6
.byte %00000000
.byte %00111100
.byte %01000010
.byte %01000000
.byte %01111100
.byte %01000010
.byte %01000010
.byte %00111100
.endrepeat
.repeat 2 ; 7
.byte %00000000
.byte %01111110
.byte %00000100
.byte %00000100
.byte %00001000
.byte %00001000
.byte %00010000
.byte %00010000
.endrepeat
.repeat 2 ; 8
.byte %00000000
.byte %00111000
.byte %01000100
.byte %01000100
.byte %00111000
.byte %01000100
.byte %01000100
.byte %00111000
.endrepeat
.repeat 2 ; 9
.byte %00000000
.byte %00111000
.byte %01000100
.byte %01000100
.byte %00111100
.byte %00000100
.byte %00000100
.byte %00000100
.endrepeat
.repeat 2 ; A
.byte %00000000
.byte %01111000
.byte %10000100
.byte %10000100
.byte %11111100
.byte %10000100
.byte %10000100
.byte %10000100
.endrepeat
.repeat 2 ; B
.byte %00000000
.byte %11111000
.byte %10000100
.byte %10000100
.byte %11111000
.byte %10000100
.byte %10000100
.byte %11111000
.endrepeat
.repeat 2 ; C
.byte %00000000
.byte %01111000
.byte %10000100
.byte %10000000
.byte %10000000
.byte %10000000
.byte %10000100
.byte %01111000
.endrepeat
.repeat 2 ; D
.byte %00000000
.byte %11111000
.byte %10000100
.byte %10000100
.byte %10000100
.byte %10000100
.byte %10000100
.byte %11111000
.endrepeat
.repeat 2 ; E
.byte %00000000
.byte %11111100
.byte %10000000
.byte %10000000
.byte %11111000
.byte %10000000
.byte %10000000
.byte %11111100
.endrepeat
.repeat 2 ; F
.byte %00000000
.byte %11111100
.byte %10000000
.byte %10000000
.byte %11110000
.byte %10000000
.byte %10000000
.byte %10000000
.endrepeat
.repeat 2 ; G
.byte %00000000
.byte %01111100
.byte %10000010
.byte %10000000
.byte %10001110
.byte %10000010
.byte %10000010
.byte %01111110
.endrepeat
.repeat 2 ; H
.byte %00000000
.byte %01000010
.byte %01000010
.byte %01000010
.byte %01111110
.byte %01000010
.byte %01000010
.byte %01000010
.endrepeat
.repeat 2 ; I
.byte %00000000
.byte %01111100
.byte %00010000
.byte %00010000
.byte %00010000
.byte %00010000
.byte %00010000
.byte %01111100
.endrepeat
.repeat 2 ; J
.byte %00000000
.byte %01111100
.byte %00001000
.byte %00001000
.byte %00001000
.byte %00001000
.byte %01001000
.byte %00110000
.endrepeat
.repeat 2 ; K
.byte %00000000
.byte %01000100
.byte %01001000
.byte %01010000
.byte %01100000
.byte %01010000
.byte %01001000
.byte %01000100
.endrepeat
.repeat 2 ; L
.byte %00000000
.byte %01000000
.byte %01000000
.byte %01000000
.byte %01000000
.byte %01000000
.byte %01000000
.byte %01111100
.endrepeat
.repeat 2 ; M
.byte %00000000
.byte %01000010
.byte %01100110
.byte %01011010
.byte %01000010
.byte %01000010
.byte %01000010
.byte %01000010
.endrepeat
.repeat 2 ; N
.byte %00000000
.byte %01000010
.byte %01100010
.byte %01010010
.byte %01001010
.byte %01000110
.byte %01000010
.byte %01000010
.endrepeat
.repeat 2 ; O
.byte %00000000
.byte %00111000
.byte %01000100
.byte %01000100
.byte %01000100
.byte %01000100
.byte %01000100
.byte %00111000
.endrepeat
.repeat 2 ; P
.byte %00000000
.byte %01111100
.byte %01000010
.byte %01000010
.byte %01111100
.byte %01000000
.byte %01000000
.byte %01000000
.endrepeat
.repeat 2 ; Q
.byte %00000000
.byte %00111000
.byte %01000100
.byte %01000100
.byte %01000100
.byte %01000100
.byte %01001100
.byte %00111100
.endrepeat
.repeat 2 ; R
.byte %00000000
.byte %01111100
.byte %01000010
.byte %01000010
.byte %01111100
.byte %01010000
.byte %01001000
.byte %01000100
.endrepeat
.repeat 2 ; S
.byte %00000000
.byte %00111100
.byte %01000010
.byte %00100000
.byte %00011000
.byte %00000100
.byte %01000100
.byte %00111000
.endrepeat
.repeat 2 ; T
.byte %00000000
.byte %01111100
.byte %00010000
.byte %00010000
.byte %00010000
.byte %00010000
.byte %00010000
.byte %00010000
.endrepeat
.repeat 2 ; U
.byte %00000000
.byte %01000010
.byte %01000010
.byte %01000010
.byte %01000010
.byte %01000010
.byte %01000010
.byte %00111100
.endrepeat
.repeat 2 ; V
.byte %00000000
.byte %01000100
.byte %01000100
.byte %01000100
.byte %00101000
.byte %00101000
.byte %00101000
.byte %00010000
.endrepeat
.repeat 2 ; W
.byte %00000000
.byte %01000100
.byte %01000100
.byte %01000100
.byte %01000100
.byte %01010100
.byte %01101100
.byte %01000100
.endrepeat
.repeat 2 ; X
.byte %00000000
.byte %01000100
.byte %01000100
.byte %00101000
.byte %00010000
.byte %00101000
.byte %01000100
.byte %01000100
.endrepeat
.repeat 2 ; Y
.byte %00000000
.byte %01000100
.byte %01000100
.byte %00101000
.byte %00010000
.byte %00010000
.byte %00010000
.byte %00010000
.endrepeat
.repeat 2 ; Z
.byte %00000000
.byte %01111110
.byte %00000010
.byte %00000100
.byte %00001000
.byte %00010000
.byte %00100000
.byte %01111110
.endrepeat
HEX = $24
.repeat 2 ; $
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00010100
.byte %00001000
.byte %00010100
.byte %00000000
.endrepeat
COLON = $25
.repeat 2 ; $
.byte %00000000
.byte %00011000
.byte %00011000
.byte %00000000
.byte %00000000
.byte %00011000
.byte %00011000
.byte %00000000
.endrepeat
UP = $26
.repeat 2 ; $
.byte %00000000
.byte %00010000
.byte %00111000
.byte %01010100
.byte %00010000
.byte %00010000
.byte %00010000
.byte %00000000
.endrepeat
DOWN = $27
.repeat 2 ; $
.byte %00000000
.byte %00010000
.byte %00010000
.byte %00010000
.byte %01010100
.byte %00111000
.byte %00010000
.byte %00000000
.endrepeat
LEFT = $28
.repeat 2 ; $
.byte %00000000
.byte %00000000
.byte %00010000
.byte %00100000
.byte %01111110
.byte %00100000
.byte %00010000
.byte %00000000
.endrepeat
RIGHT = $29
.repeat 2 ; $
.byte %00000000
.byte %00000000
.byte %00001000
.byte %00000100
.byte %01111110
.byte %00000100
.byte %00001000
.byte %00000000
.endrepeat
PILL = $2A
.repeat 2 ; $
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00111100
.byte %01111110
.byte %00111100
.byte %00000000
.endrepeat
EMPTY = $2B
.repeat 2 ; $
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.endrepeat
FONT_END = $2C
.popseg
.macro write_char_x chr
.if chr >= 'a' && chr <= 'z'
ldx #(chr - 'a' + 10)
.elseif chr >= 'A' && chr <= 'Z'
ldx #(chr - 'A' + 10)
.elseif chr >= '0' && chr <= '9'
ldx #(chr - '0')
.elseif chr = ' '
ldx #EMPTY
.elseif chr = ':'
ldx #COLON
.elseif chr = '$'
ldx #HEX
.else
.error "Unhandled character chr: " chr
.endif
stx PPUDATA
.endmacro
zp_res HEX_TEMP
write_hex_a:
sta HEX_TEMP
lsr
lsr
lsr
lsr
and #$F
sta PPUDATA
lda HEX_TEMP
and #$F
sta PPUDATA
rts

30
src/test_roms/common/joysticks.s
View File

@@ -1,30 +0,0 @@
JOY_RIGHT_MASK = %00000001
JOY_LEFT_MASK = %00000010
JOY_DOWN_MASK = %00000100
JOY_UP_MASK = %00001000
JOY_START_MASK = %00010000
JOY_SELECT_MASK = %00100000
JOY_B_MASK = %01000000
JOY_A_MASK = %10000000
zp_res JOYTEMP
; Reads joy_stick 1 into a (and JOYTEMP)
read_joy1:
; Init joysticks for reading
lda #$01
sta JOY1
lda #$00
sta JOY1
; Read JOY1
.repeat 8
asl A
sta JOYTEMP
lda JOY1
and #$01
ora JOYTEMP
.endrepeat
sta JOYTEMP
rts

37
src/test_roms/common/minimal_ppu.s
View File

@@ -1,37 +0,0 @@
init_ppu_and_wait:
; Init PPU
bit PPUSTATUS
vwait1:
bit PPUSTATUS
bpl vwait1
vwait2:
bit PPUSTATUS
bpl vwait2
lda #$80
sta PPUCTRL ; NMI on, PPU slave, Small sprites, 0 addresses
lda #$00
infinite_loop:
jmp infinite_loop
.macro nmi_start
pha
txa
pha
tya
pha
lda PPUSTATUS
lda #%00000110
sta PPUMASK ; Force blank
.endmacro
.macro nmi_end
lda #%00001110
sta PPUMASK ; Enable rendering
pla
tay
pla
tax
pla
rti
.endmacro

12
src/test_roms/common/neshw.inc
View File

@@ -34,18 +34,6 @@ JOY1 = $4016
JOY2 = $4017
SNDMODE = $4017
PULSE_CH1_DLCV = $4000
PULSE_CH1_SWEEP = $4001
PULSE_CH1_TLOW = $4002
PULSE_CH1_LCTH = $4003
PULSE_CH2_DLCV = $4004
PULSE_CH2_SWEEP = $4005
PULSE_CH2_TLOW = $4006
PULSE_CH2_LCTH = $4007
TRIANGLE_LINEAR_C = $4008
TRIANGLE_TIMER_LOW = $400A
TRIANGLE_LEN_T_HIGH = $400B
SNDMODE_NOIRQ = $40
.if CLOCK_RATE = 1789773

2
src/test_roms/even_odd.s
View File

@@ -11,7 +11,7 @@ reset:
stx $2000 ; Disable NMI (by writing zero)
stx $4010 ; Disable DMC IRQs
ldx #$08
stx $2001 ; Enable rendering
stx $2001 ; Disable rendering
bit $2002 ; Clear vblank flag by reading ppu status
VBLANKWAIT1:

335
src/test_roms/input_test.s
View File

@@ -1,335 +0,0 @@
; Verifies that reset doesn't alter any RAM.
.include "testing.s"
; patterns_bin "pat.bin"
.macro chr b,s
.repeat s
.byte b
.endrepeat
.endmacro
.pushseg
.segment "CHARS"
T_EMPTY = 0
.repeat 2 ; Empty 0
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.endrepeat
T_TOP_LEFT = 1
.repeat 2 ; Top Left 1
.byte %11111111
.byte %11111111
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.endrepeat
T_TOP_RIGHT = 2
.repeat 2 ; Top Right 2
.byte %11111111
.byte %11111111
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.endrepeat
T_BOTTOM_RIGHT = 3
.repeat 2 ; Bottom Right 3
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %11111111
.byte %11111111
.endrepeat
T_BOTTOM_LEFT = 4
.repeat 2 ; Bottom Left 4
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11111111
.byte %11111111
.endrepeat
T_FORWARD = 5
.repeat 2 ; FW 5
.byte %00000011
.byte %00000111
.byte %00001110
.byte %00011100
.byte %00111000
.byte %01110000
.byte %11100000
.byte %11000000
.endrepeat
T_BACKWARD = 6
.repeat 2 ; BW 6
.byte %11000000
.byte %11100000
.byte %01110000
.byte %00111000
.byte %00011100
.byte %00001110
.byte %00000111
.byte %00000011
.endrepeat
T_PILL_L = 7
.repeat 2 ; Pill L 7
.byte %00111111
.byte %01111111
.byte %11100000
.byte %11000000
.byte %11000000
.byte %11100000
.byte %01111111
.byte %00111111
.endrepeat
T_PILL_R = 8
.repeat 2 ; Pill R 8
.byte %11111100
.byte %11111110
.byte %00000111
.byte %00000011
.byte %00000011
.byte %00000111
.byte %11111110
.byte %11111100
.endrepeat
.popseg
zp_res TEMP
.macro load_ppu_addr addr
lda #.hibyte(addr)
sta PPUADDR
lda #.lobyte(addr)
sta PPUADDR ; Load $2000
.endmacro
reset:
sei
cld
ldx #$FF
txs
; Init PPU
bit PPUSTATUS
vwait1:
bit PPUSTATUS
bpl vwait1
vwait2:
bit PPUSTATUS
bpl vwait2
lda #$00
sta PPUCTRL ; NMI off, PPU slave, Small sprites, 0 addresses
; Fill NT0
load_ppu_addr $2000
ldx #$00
ldy #$04
lda #$00
fill_loop:
sta PPUDATA
dex
bne fill_loop
dey
bne fill_loop
; Set specific tiles
load_ppu_addr $2184
lda #T_TOP_LEFT
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21A4
lda #T_BACKWARD
sta PPUDATA
lda #T_FORWARD
sta PPUDATA
load_ppu_addr $21C2
lda #T_TOP_LEFT
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $21E2
lda #T_BOTTOM_LEFT
sta PPUDATA
lda #T_FORWARD
sta PPUDATA
load_ppu_addr $21C6
lda #T_FORWARD
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21E6
lda #T_BACKWARD
sta PPUDATA
lda #T_BOTTOM_RIGHT
sta PPUDATA
load_ppu_addr $2204
lda #T_FORWARD
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $2224
lda #T_BOTTOM_LEFT
sta PPUDATA
lda #T_BOTTOM_RIGHT
sta PPUDATA
load_ppu_addr $21EA
lda #T_PILL_L
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
lda #$00
sta PPUDATA
sta PPUDATA
lda #T_PILL_L
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $21D2
lda #T_FORWARD
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $21F2
lda #T_TOP_LEFT
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21D6
lda #T_TOP_LEFT
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $21F6
lda #T_TOP_LEFT
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $3F00
lda #$0f
sta PPUDATA
lda #$20
sta PPUDATA
sta PPUDATA
sta PPUDATA
lda #$0f
sta PPUDATA
lda #$09
sta PPUDATA
sta PPUDATA
sta PPUDATA
lda #$00
sta PPUSCROLL
sta PPUSCROLL
lda #%00001110
sta PPUMASK
lda #$80
sta PPUCTRL ; NMI on, PPU slave, Small sprites, 0 addresses
loop:
jmp loop
.macro shl_a count
.scope
ldx #count
a_l:asl A
dex
bne a_l
.endscope
.endmacro
nmi:
lda PPUSTATUS
lda #%00000110
sta PPUMASK ; Force blank
lda #$01
sta JOY1
lda #$00
sta JOY1
load_ppu_addr $23DC ; A
lda JOY1
and #$01
shl_a 6
sta PPUDATA
load_ppu_addr $23DD ; B
lda JOY1
and #$01
shl_a 6
sta PPUDATA
load_ppu_addr $23DA ; Select
lda JOY1
and #$01
shl_a 6
sta PPUDATA
load_ppu_addr $23DB ; Start
lda JOY1
and #$01
shl_a 6
sta PPUDATA
lda JOY1 ; Up
and #$01
sta TEMP
load_ppu_addr $23E1 ; Down
lda JOY1
and #$01
sta PPUDATA
load_ppu_addr $23D8 ; Left
lda JOY1
and #$01
shl_a 6
sta PPUDATA
load_ppu_addr $23D9 ; Right
lda JOY1
and #$01
shl_a 6
ora TEMP
sta PPUDATA
lda #$00
sta PPUSCROLL
sta PPUSCROLL
lda #%00001110
sta PPUMASK ; Enable rendering
rti
exit:
stp
irq:
stp

4
src/test_roms/instructions.rs
View File

@@ -63,6 +63,6 @@ rom_test!(implied_instructions, "implied_instrs.nes", |nes| {
});
rom_test!(bit, "alu_bit.nes", |nes| {
assert_eq!(nes.last_instruction(), "0x8021 HLT :2 []");
mem_cmp(&nes, 0x300, &[0xF6, 0xF6]);
assert_eq!(nes.last_instruction(), "0x8012 HLT :2 []");
mem_cmp(&nes, 0x300, &[0xF6]);
});

63
src/test_roms/mod.rs
View File

@@ -36,8 +36,6 @@ macro_rules! rom_test {
pub(crate) use rom_test;
use crate::{Break, NES};
rom_test!(basic_cpu, "basic-cpu.nes", |nes| {
assert_eq!(nes.last_instruction(), "0x8001 HLT :2 []");
assert_eq!(nes.cpu_cycle(), 10);
@@ -138,67 +136,6 @@ rom_test!(even_odd, "even_odd.nes", |nes| {
assert_eq!(nes.cpu.y, 0x00);
});
fn run_frame(nes: &mut NES) {
nes.run_one_clock_cycle(&Break::default());
while nes.ppu().scanline != 241 || nes.ppu().pixel != 0 {
nes.run_one_clock_cycle(&Break::default());
}
}
rom_test!(input_test, "input_test.nes", timeout = 86964*3, |nes| {
const A: u16 = 0x23DC; // 0 || 0b01000000
const B: u16 = 0x23DD; // 0 || 0b01000000
const SELECT: u16 = 0x23DA; // 0 || 0b01000000
const START: u16 = 0x23DB; // 0 || 0b01000000
const DOWN: u16 = 0x23E1; // 0 || 1
const LEFT: u16 = 0x23D8; // 0 || 0b01000000
const UP_RIGHT: u16 = 0x23D9; // 0 || 0b01000000 | 1
run_frame(&mut nes);
assert_eq!(nes.mapped.peek_ppu(A).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(B).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(SELECT).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(START).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(DOWN).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(LEFT).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(UP_RIGHT).unwrap(), 0);
nes.controller_1().set_a(true);
run_frame(&mut nes);
assert_eq!(nes.mapped.peek_ppu(A).unwrap(), 0x40);
assert_eq!(nes.mapped.peek_ppu(B).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(SELECT).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(START).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(DOWN).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(LEFT).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(UP_RIGHT).unwrap(), 0);
nes.controller_1().set_b(true);
run_frame(&mut nes);
assert_eq!(nes.mapped.peek_ppu(A).unwrap(), 0x40);
assert_eq!(nes.mapped.peek_ppu(B).unwrap(), 0x40);
assert_eq!(nes.mapped.peek_ppu(SELECT).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(START).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(DOWN).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(LEFT).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(UP_RIGHT).unwrap(), 0);
nes.controller_1().0 = 0xFF;
run_frame(&mut nes);
assert_eq!(nes.mapped.peek_ppu(A).unwrap(), 0x40);
assert_eq!(nes.mapped.peek_ppu(B).unwrap(), 0x40);
assert_eq!(nes.mapped.peek_ppu(SELECT).unwrap(), 0x40);
assert_eq!(nes.mapped.peek_ppu(START).unwrap(), 0x40);
assert_eq!(nes.mapped.peek_ppu(DOWN).unwrap(), 0x01);
assert_eq!(nes.mapped.peek_ppu(LEFT).unwrap(), 0x40);
assert_eq!(nes.mapped.peek_ppu(UP_RIGHT).unwrap(), 0x41);
nes.controller_1().0 = 0;
run_frame(&mut nes);
assert_eq!(nes.mapped.peek_ppu(A).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(B).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(SELECT).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(START).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(DOWN).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(LEFT).unwrap(), 0);
assert_eq!(nes.mapped.peek_ppu(UP_RIGHT).unwrap(), 0);
});
// rom_test!(even_odd, "even_odd.nes", |nes| {
// assert_eq!(nes.last_instruction(), "0x8023 HLT :2 []");
// assert_eq!(nes.cpu_cycle(), 57182);

19
src/test_roms/ppu.rs
View File

@@ -83,19 +83,8 @@ rom_test!(ppu_fill_name_table, "ppu_fill_name_table.nes", |nes| {
rom_test!(ppu_vertical_write, "ppu_vertical_write.nes", |nes| {
assert_eq!(nes.last_instruction(), "0x8040 HLT :2 []");
assert_eq!(nes.mem().peek_ppu(0x2000), Ok(1));
assert_eq!(nes.mem().peek_ppu(0x2020), Ok(1));
assert_eq!(nes.mem().peek_ppu(0x2400), Ok(2));
assert_eq!(nes.mem().peek_ppu(0x2401), Ok(2));
});
rom_test!(ppu_palette_shared, "ppu_palette_shared.nes", |nes| {
assert_eq!(nes.last_instruction(), "0x8078 HLT :2 []");
});
// Sets up an image, and scrolls a specific number of pixels over
rom_test!(ppu_scrolling, "ppu_fine_x_scrolling.nes", timeout = 86964*4, |nes| {
assert_eq!(nes.image().read(0, 0), Color { r: 0xFF, g: 0xFE, b: 0xFF });
assert_eq!(nes.mem().peek_ppu(0x2000), Some(1));
assert_eq!(nes.mem().peek_ppu(0x2020), Some(1));
assert_eq!(nes.mem().peek_ppu(0x2400), Some(2));
assert_eq!(nes.mem().peek_ppu(0x2401), Some(2));
});

306
src/test_roms/ppu_fine_x_scrolling.s
View File

@@ -1,306 +0,0 @@
.include "testing.s"
; patterns_bin "pat.bin"
.macro chr b,s
.repeat s
.byte b
.endrepeat
.endmacro
.pushseg
.segment "CHARS"
T_EMPTY = 0
.repeat 2 ; Empty 0
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.endrepeat
T_TOP_LEFT = 1
.repeat 2 ; Top Left 1
.byte %11111111
.byte %11111111
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.endrepeat
T_TOP_RIGHT = 2
.repeat 2 ; Top Right 2
.byte %11111111
.byte %11111111
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.endrepeat
T_BOTTOM_RIGHT = 3
.repeat 2 ; Bottom Right 3
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %11111111
.byte %11111111
.endrepeat
T_BOTTOM_LEFT = 4
.repeat 2 ; Bottom Left 4
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11111111
.byte %11111111
.endrepeat
T_FORWARD = 5
.repeat 2 ; FW 5
.byte %00000011
.byte %00000111
.byte %00001110
.byte %00011100
.byte %00111000
.byte %01110000
.byte %11100000
.byte %11000000
.endrepeat
T_BACKWARD = 6
.repeat 2 ; BW 6
.byte %11000000
.byte %11100000
.byte %01110000
.byte %00111000
.byte %00011100
.byte %00001110
.byte %00000111
.byte %00000011
.endrepeat
T_PILL_L = 7
.repeat 2 ; Pill L 7
.byte %00111111
.byte %01111111
.byte %11100000
.byte %11000000
.byte %11000000
.byte %11100000
.byte %01111111
.byte %00111111
.endrepeat
T_PILL_R = 8
.repeat 2 ; Pill R 8
.byte %11111100
.byte %11111110
.byte %00000111
.byte %00000011
.byte %00000011
.byte %00000111
.byte %11111110
.byte %11111100
.endrepeat
T_LINE = 9
.repeat 2 ; Empty 0
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.endrepeat
.popseg
zp_res Y_SCROLL
zp_res X_SCROLL
zp_res CTRL_BYTE
.macro load_ppu_addr addr
lda #.hibyte(addr)
sta PPUADDR
lda #.lobyte(addr)
sta PPUADDR ; Load $2000
.endmacro
reset:
sei
cld
ldx #$FF
txs
; Init PPU
bit PPUSTATUS
vwait1:
bit PPUSTATUS
bpl vwait1
vwait2:
bit PPUSTATUS
bpl vwait2
lda #$00
sta PPUCTRL ; NMI off, PPU slave, Small sprites, 0 addresses
; Fill NT0
load_ppu_addr $2000
ldx #$00
ldy #$04
lda #$00
fill_loop:
sta PPUDATA
dex
bne fill_loop
dey
bne fill_loop
; Set specific tiles
load_ppu_addr $2184
lda #T_TOP_LEFT
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21A4
lda #T_BACKWARD
sta PPUDATA
lda #T_FORWARD
sta PPUDATA
load_ppu_addr $21C2
lda #T_TOP_LEFT
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $21E2
lda #T_BOTTOM_LEFT
sta PPUDATA
lda #T_FORWARD
sta PPUDATA
load_ppu_addr $21C6
lda #T_FORWARD
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21E6
lda #T_BACKWARD
sta PPUDATA
lda #T_BOTTOM_RIGHT
sta PPUDATA
load_ppu_addr $2204
lda #T_FORWARD
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $2224
lda #T_BOTTOM_LEFT
sta PPUDATA
lda #T_BOTTOM_RIGHT
sta PPUDATA
load_ppu_addr $21EA
lda #T_PILL_L
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
lda #$00
sta PPUDATA
sta PPUDATA
lda #T_PILL_L
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $21D2
lda #T_FORWARD
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $21F2
lda #T_TOP_LEFT
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21D6
lda #T_TOP_LEFT
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $21F6
lda #T_TOP_LEFT
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $3F00
lda #$0f
sta PPUDATA
lda #$20
sta PPUDATA
sta PPUDATA
sta PPUDATA
lda #$0f
sta PPUDATA
lda #$09
sta PPUDATA
sta PPUDATA
sta PPUDATA
load_ppu_addr $2001
lda #T_LINE
sta PPUDATA
lda #$00
sta PPUSCROLL
sta PPUSCROLL
lda #%00001110
sta PPUMASK
lda #$80
sta PPUCTRL ; NMI on, PPU slave, Small sprites, 0 addresses
sta CTRL_BYTE
loop:
jmp loop
nmi:
lda PPUSTATUS
lda #%00000110
sta PPUMASK ; Force blank
lda #$0A
; adc X_SCROLL
; sta X_SCROLL
sta PPUSCROLL
; bcc y_scroll
; lda #$01
; eor CTRL_BYTE
; sta CTRL_BYTE
; sta PPUCTRL
; y_scroll:
; clc
lda #$00
; adc Y_SCROLL
; sta Y_SCROLL
sta PPUSCROLL
lda CTRL_BYTE
sta PPUCTRL
lda #%00001110
sta PPUMASK ; Enable rendering
rti
exit:
stp
irq:
stp

70
src/test_roms/ppu_palette_shared.s
View File

@@ -1,70 +0,0 @@
.include "testing.s"
reset:
sei ; Ignore IRQs while starting up
cld ; disabled decimal mode (iirc it doesn't work properly on NES anyway)
ldx #$40
stx $4017 ; Disable APU frame IRQ
ldx #$ff
txs ; Set stack pointer to 0x1ff
inx ; Set x to zero
stx $2000 ; Disable NMI (by writing zero)
stx $4010 ; Disable DMC IRQs
ldx #$08
stx $2001 ; Disable rendering
bit $2002 ; Clear vblank flag by reading ppu status
VBLANKWAIT1:
bit $2002
bpl VBLANKWAIT1
VBLANKWAIT2:
bit $2002
bpl VBLANKWAIT2
lda #$3F
sta PPUADDR
lda #$00
sta PPUADDR
lda #$01
ldx #$10
fill_loop:
sta PPUDATA
dex
bne fill_loop
lda #$3F
sta PPUADDR
lda #$10
sta PPUADDR
lda PPUDATA
cmp #$01
bne fail
lda PPUDATA
lda PPUDATA
lda PPUDATA
lda PPUDATA
cmp #$01
bne fail
lda PPUDATA
lda PPUDATA
lda PPUDATA
lda PPUDATA
cmp #$01
bne fail
lda PPUDATA
lda PPUDATA
lda PPUDATA
lda PPUDATA
cmp #$01
bne fail
stp
jmp $8000
fail:
stp
nmi:
stp
irq:
stp

96
src/test_roms/render-updating.s
View File

@@ -1,96 +0,0 @@
.include "testing.s"
.macro chr b,s
.repeat s
.byte b
.endrepeat
.endmacro
.pushseg
.segment "CHARS"
chr $FF,16 ; Full
chr $00,8
chr $FF,8 ; Gray
chr $55,16 ; Vertical stripes
chr $AA,16 ; Vertical stripes - reverse
.repeat 8
.byte $FF
.byte $00
.endrepeat ; Horizontal stripes
.repeat 8
.byte $00
.byte $FF
.endrepeat ; Horizontal stripes - reverse
.repeat 8
.byte $55
.byte $AA
.endrepeat ; Checkerboard
.repeat 8
.byte $AA
.byte $55
.endrepeat ; Checkerboard - reverse
.popseg
zp_res CUR
zp_res POS
reset:
sei ; Ignore IRQs while starting up
cld ; disabled decimal mode (iirc it doesn't work properly on NES anyway)
ldx #$40
stx $4017 ; Disable APU frame IRQ
ldx #$ff
txs ; Set stack pointer to 0x1ff
inx ; Set x to zero
stx $2000 ; Disable NMI (by writing zero)
stx $4010 ; Disable DMC IRQs
ldx #$0A
stx $2001 ; Disable rendering
bit $2002 ; Clear vblank flag by reading ppu status
VBLANKWAIT1:
bit $2002
bpl VBLANKWAIT1
VBLANKWAIT2:
bit $2002
bpl VBLANKWAIT2
lda #$1
sta CUR
lda #$0
sta POS
lda #$80
sta PPUCTRL
loop:
jmp loop
nmi:
lda #$20
sta PPUADDR ; MSB
lda POS
adc #$1
sta POS
sta PPUADDR
bne update
clc
lda CUR
adc #$1
sta CUR
cmp #$7
bne update
lda #$0
sta CUR
update:
lda CUR
sta PPUDATA
lda #$0
sta PPUSCROLL
sta PPUSCROLL
lda #$80
sta PPUCTRL
rti
irq:
stp

306
src/test_roms/scrolling.s
View File

@@ -1,306 +0,0 @@
.include "testing.s"
; patterns_bin "pat.bin"
.macro chr b,s
.repeat s
.byte b
.endrepeat
.endmacro
.pushseg
.segment "CHARS"
T_EMPTY = 0
.repeat 2 ; Empty 0
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.endrepeat
T_TOP_LEFT = 1
.repeat 2 ; Top Left 1
.byte %11111111
.byte %11111111
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.endrepeat
T_TOP_RIGHT = 2
.repeat 2 ; Top Right 2
.byte %11111111
.byte %11111111
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.endrepeat
T_BOTTOM_RIGHT = 3
.repeat 2 ; Bottom Right 3
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %11111111
.byte %11111111
.endrepeat
T_BOTTOM_LEFT = 4
.repeat 2 ; Bottom Left 4
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11111111
.byte %11111111
.endrepeat
T_FORWARD = 5
.repeat 2 ; FW 5
.byte %00000011
.byte %00000111
.byte %00001110
.byte %00011100
.byte %00111000
.byte %01110000
.byte %11100000
.byte %11000000
.endrepeat
T_BACKWARD = 6
.repeat 2 ; BW 6
.byte %11000000
.byte %11100000
.byte %01110000
.byte %00111000
.byte %00011100
.byte %00001110
.byte %00000111
.byte %00000011
.endrepeat
T_PILL_L = 7
.repeat 2 ; Pill L 7
.byte %00111111
.byte %01111111
.byte %11100000
.byte %11000000
.byte %11000000
.byte %11100000
.byte %01111111
.byte %00111111
.endrepeat
T_PILL_R = 8
.repeat 2 ; Pill R 8
.byte %11111100
.byte %11111110
.byte %00000111
.byte %00000011
.byte %00000011
.byte %00000111
.byte %11111110
.byte %11111100
.endrepeat
T_LINE = 9
.repeat 2 ; Empty 0
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.endrepeat
.popseg
zp_res Y_SCROLL
zp_res X_SCROLL
zp_res CTRL_BYTE
.macro load_ppu_addr addr
lda #.hibyte(addr)
sta PPUADDR
lda #.lobyte(addr)
sta PPUADDR ; Load $2000
.endmacro
reset:
sei
cld
ldx #$FF
txs
; Init PPU
bit PPUSTATUS
vwait1:
bit PPUSTATUS
bpl vwait1
vwait2:
bit PPUSTATUS
bpl vwait2
lda #$00
sta PPUCTRL ; NMI off, PPU slave, Small sprites, 0 addresses
; Fill NT0
load_ppu_addr $2000
ldx #$00
ldy #$04
lda #$00
fill_loop:
sta PPUDATA
dex
bne fill_loop
dey
bne fill_loop
; Set specific tiles
load_ppu_addr $2184
lda #T_TOP_LEFT
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21A4
lda #T_BACKWARD
sta PPUDATA
lda #T_FORWARD
sta PPUDATA
load_ppu_addr $21C2
lda #T_TOP_LEFT
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $21E2
lda #T_BOTTOM_LEFT
sta PPUDATA
lda #T_FORWARD
sta PPUDATA
load_ppu_addr $21C6
lda #T_FORWARD
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21E6
lda #T_BACKWARD
sta PPUDATA
lda #T_BOTTOM_RIGHT
sta PPUDATA
load_ppu_addr $2204
lda #T_FORWARD
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $2224
lda #T_BOTTOM_LEFT
sta PPUDATA
lda #T_BOTTOM_RIGHT
sta PPUDATA
load_ppu_addr $21EA
lda #T_PILL_L
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
lda #$00
sta PPUDATA
sta PPUDATA
lda #T_PILL_L
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $21D2
lda #T_FORWARD
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $21F2
lda #T_TOP_LEFT
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21D6
lda #T_TOP_LEFT
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $21F6
lda #T_TOP_LEFT
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $3F00
lda #$0f
sta PPUDATA
lda #$20
sta PPUDATA
sta PPUDATA
sta PPUDATA
lda #$0f
sta PPUDATA
lda #$09
sta PPUDATA
sta PPUDATA
sta PPUDATA
load_ppu_addr $2001
lda #T_LINE
sta PPUDATA
lda #$00
sta PPUSCROLL
sta PPUSCROLL
lda #%00001110
sta PPUMASK
lda #$80
sta PPUCTRL ; NMI on, PPU slave, Small sprites, 0 addresses
sta CTRL_BYTE
loop:
jmp loop
nmi:
lda PPUSTATUS
lda #%00000110
sta PPUMASK ; Force blank
lda #$0A
adc X_SCROLL
sta X_SCROLL
sta PPUSCROLL
bcc y_scroll
lda #$01
eor CTRL_BYTE
sta CTRL_BYTE
sta PPUCTRL
y_scroll:
clc
lda #$00
adc Y_SCROLL
sta Y_SCROLL
sta PPUSCROLL
lda CTRL_BYTE
sta PPUCTRL
lda #%00001110
sta PPUMASK ; Enable rendering
rti
exit:
stp
irq:
stp

334
src/test_roms/scrolling_colors.s
View File

@@ -1,334 +0,0 @@
.include "testing.s"
; patterns_bin "pat.bin"
.macro chr b,s
.repeat s
.byte b
.endrepeat
.endmacro
.pushseg
.segment "CHARS"
T_EMPTY = 0
.repeat 2 ; Empty 0
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.endrepeat
T_TOP_LEFT = 1
.repeat 2 ; Top Left 1
.byte %11111111
.byte %11111111
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.endrepeat
T_TOP_RIGHT = 2
.repeat 2 ; Top Right 2
.byte %11111111
.byte %11111111
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.endrepeat
T_BOTTOM_RIGHT = 3
.repeat 2 ; Bottom Right 3
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %11111111
.byte %11111111
.endrepeat
T_BOTTOM_LEFT = 4
.repeat 2 ; Bottom Left 4
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11111111
.byte %11111111
.endrepeat
T_FORWARD = 5
.repeat 2 ; FW 5
.byte %00000011
.byte %00000111
.byte %00001110
.byte %00011100
.byte %00111000
.byte %01110000
.byte %11100000
.byte %11000000
.endrepeat
T_BACKWARD = 6
.repeat 2 ; BW 6
.byte %11000000
.byte %11100000
.byte %01110000
.byte %00111000
.byte %00011100
.byte %00001110
.byte %00000111
.byte %00000011
.endrepeat
T_PILL_L = 7
.repeat 2 ; Pill L 7
.byte %00111111
.byte %01111111
.byte %11100000
.byte %11000000
.byte %11000000
.byte %11100000
.byte %01111111
.byte %00111111
.endrepeat
T_PILL_R = 8
.repeat 2 ; Pill R 8
.byte %11111100
.byte %11111110
.byte %00000111
.byte %00000011
.byte %00000011
.byte %00000111
.byte %11111110
.byte %11111100
.endrepeat
T_LINE = 9
.repeat 2 ; Line
.byte %00000000
.byte %11111111
.byte %11111111
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.endrepeat
.popseg
zp_res Y_SCROLL
zp_res X_SCROLL
zp_res CTRL_BYTE
.macro load_ppu_addr addr
lda #.hibyte(addr)
sta PPUADDR
lda #.lobyte(addr)
sta PPUADDR ; Load $2000
.endmacro
reset:
sei
cld
ldx #$FF
txs
; Init PPU
bit PPUSTATUS
vwait1:
bit PPUSTATUS
bpl vwait1
vwait2:
bit PPUSTATUS
bpl vwait2
lda #$00
sta PPUCTRL ; NMI off, PPU slave, Small sprites, 0 addresses
; Fill NT0
load_ppu_addr $2000
ldx #$00
ldy #$04
lda #$00
fill_loop:
sta PPUDATA
dex
bne fill_loop
dey
bne fill_loop
; Set specific tiles
load_ppu_addr $2184
lda #T_TOP_LEFT
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21A4
lda #T_BACKWARD
sta PPUDATA
lda #T_FORWARD
sta PPUDATA
load_ppu_addr $21C2
lda #T_TOP_LEFT
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $21E2
lda #T_BOTTOM_LEFT
sta PPUDATA
lda #T_FORWARD
sta PPUDATA
load_ppu_addr $21C6
lda #T_FORWARD
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21E6
lda #T_BACKWARD
sta PPUDATA
lda #T_BOTTOM_RIGHT
sta PPUDATA
load_ppu_addr $2204
lda #T_FORWARD
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $2224
lda #T_BOTTOM_LEFT
sta PPUDATA
lda #T_BOTTOM_RIGHT
sta PPUDATA
load_ppu_addr $21EA
lda #T_PILL_L
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
lda #$00
sta PPUDATA
sta PPUDATA
lda #T_PILL_L
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $21D2
lda #T_FORWARD
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $21F2
lda #T_TOP_LEFT
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21D6
lda #T_TOP_LEFT
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $21F6
lda #T_TOP_LEFT
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $3F00
lda #$0f
sta PPUDATA
lda #$20
sta PPUDATA
sta PPUDATA
sta PPUDATA
lda #$0f
sta PPUDATA
lda #$09
sta PPUDATA
sta PPUDATA
sta PPUDATA
lda #$0f
sta PPUDATA
lda #$1A
sta PPUDATA
sta PPUDATA
sta PPUDATA
lda #$0f
sta PPUDATA
lda #$21
sta PPUDATA
sta PPUDATA
sta PPUDATA
load_ppu_addr $2000
lda #T_TOP_LEFT
ldx #$1F
line_loop:
sta PPUDATA
dex
bne line_loop
load_ppu_addr $23C0
ldx #$7
line_color_loop:
lda #%00000000
sta PPUDATA
lda #%00001111
sta PPUDATA
dex
bne line_color_loop
lda #$00
sta PPUSCROLL
sta PPUSCROLL
lda #%00001110
sta PPUMASK
lda #$80
sta PPUCTRL ; NMI on, PPU slave, Small sprites, 0 addresses
sta CTRL_BYTE
loop:
jmp loop
nmi:
lda PPUSTATUS
lda #%00000110
sta PPUMASK ; Force blank
lda #$01
adc X_SCROLL
sta X_SCROLL
sta PPUSCROLL
bcc y_scroll
lda #$01
eor CTRL_BYTE
sta CTRL_BYTE
sta PPUCTRL
y_scroll:
clc
lda #$00
adc Y_SCROLL
sta Y_SCROLL
sta PPUSCROLL
lda CTRL_BYTE
sta PPUCTRL
lda #%00001110
sta PPUMASK ; Enable rendering
rti
exit:
stp
irq:
stp

321
src/test_roms/sprites.s
View File

@@ -1,321 +0,0 @@
.include "testing.s"
.pushseg
.segment "CHARS"
T_EMPTY = 0
.repeat 2 ; Empty 0
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.byte %00000000
.endrepeat
T_TOP_LEFT = 1
.repeat 2 ; Top Left 1
.byte %11111111
.byte %11111111
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.endrepeat
T_TOP_RIGHT = 2
.repeat 2 ; Top Right 2
.byte %11111111
.byte %11111111
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.endrepeat
T_BOTTOM_RIGHT = 3
.repeat 2 ; Bottom Right 3
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %00000011
.byte %11111111
.byte %11111111
.endrepeat
T_BOTTOM_LEFT = 4
.repeat 2 ; Bottom Left 4
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11000000
.byte %11111111
.byte %11111111
.endrepeat
T_FORWARD = 5
.repeat 2 ; FW 5
.byte %00000011
.byte %00000111
.byte %00001110
.byte %00011100
.byte %00111000
.byte %01110000
.byte %11100000
.byte %11000000
.endrepeat
T_BACKWARD = 6
.repeat 2 ; BW 6
.byte %11000000
.byte %11100000
.byte %01110000
.byte %00111000
.byte %00011100
.byte %00001110
.byte %00000111
.byte %00000011
.endrepeat
T_PILL_L = 7
.repeat 2 ; Pill L 7
.byte %00111111
.byte %01111111
.byte %11100000
.byte %11000000
.byte %11000000
.byte %11100000
.byte %01111111
.byte %00111111
.endrepeat
T_PILL_R = 8
.repeat 2 ; Pill R 8
.byte %11111100
.byte %11111110
.byte %00000111
.byte %00000011
.byte %00000011
.byte %00000111
.byte %11111110
.byte %11111100
.endrepeat
T_LINE = 9
.repeat 2 ; Empty 0
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.byte %00100000
.endrepeat
.popseg
zp_res Y_SCROLL
zp_res X_SCROLL
zp_res CTRL_BYTE
.macro load_ppu_addr addr
lda #.hibyte(addr)
sta PPUADDR
lda #.lobyte(addr)
sta PPUADDR ; Load $2000
.endmacro
reset:
sei
cld
ldx #$FF
txs
; Init PPU
bit PPUSTATUS
vwait1:
bit PPUSTATUS
bpl vwait1
vwait2:
bit PPUSTATUS
bpl vwait2
lda #$00
sta PPUCTRL ; NMI off, PPU slave, Small sprites, 0 addresses
; Fill NT0
load_ppu_addr $2000
ldx #$00
ldy #$04
lda #$00
fill_loop:
sta PPUDATA
dex
bne fill_loop
dey
bne fill_loop
; Set specific tiles
load_ppu_addr $2184
lda #T_TOP_LEFT
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21A4
lda #T_BACKWARD
sta PPUDATA
lda #T_FORWARD
sta PPUDATA
load_ppu_addr $21C2
lda #T_TOP_LEFT
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $21E2
lda #T_BOTTOM_LEFT
sta PPUDATA
lda #T_FORWARD
sta PPUDATA
load_ppu_addr $21C6
lda #T_FORWARD
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21E6
lda #T_BACKWARD
sta PPUDATA
lda #T_BOTTOM_RIGHT
sta PPUDATA
load_ppu_addr $2204
lda #T_FORWARD
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $2224
lda #T_BOTTOM_LEFT
sta PPUDATA
lda #T_BOTTOM_RIGHT
sta PPUDATA
load_ppu_addr $21EA
lda #T_PILL_L
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
lda #$00
sta PPUDATA
sta PPUDATA
lda #T_PILL_L
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $21D2
lda #T_FORWARD
sta PPUDATA
lda #T_BACKWARD
sta PPUDATA
load_ppu_addr $21F2
lda #T_TOP_LEFT
sta PPUDATA
lda #T_TOP_RIGHT
sta PPUDATA
load_ppu_addr $21D6
lda #T_TOP_LEFT
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $21F6
lda #T_TOP_LEFT
sta PPUDATA
lda #T_PILL_R
sta PPUDATA
load_ppu_addr $3F00
lda #$0f
sta PPUDATA
lda #$20
sta PPUDATA
sta PPUDATA
sta PPUDATA
lda #$0f
sta PPUDATA
lda #$09
sta PPUDATA
sta PPUDATA
sta PPUDATA
load_ppu_addr $2001
lda #T_LINE
sta PPUDATA
ldx #$00
sprite_loop:
lda sprite_data,x
sta $300,x
inx
cpx #(sprite_data_end - sprite_data)
bne sprite_loop
lda #$00
sta PPUSCROLL
sta PPUSCROLL
lda #%00001110
sta PPUMASK
lda #$80
sta PPUCTRL ; NMI on, PPU slave, Small sprites, 0 addresses
sta CTRL_BYTE
loop:
jmp loop
nmi:
lda PPUSTATUS
lda #%00000110
sta PPUMASK ; Force blank
lda #$01
adc X_SCROLL
sta X_SCROLL
sta PPUSCROLL
bcc y_scroll
lda #$01
eor CTRL_BYTE
sta CTRL_BYTE
sta PPUCTRL
y_scroll:
clc
lda #$00
adc Y_SCROLL
sta Y_SCROLL
sta PPUSCROLL
lda #$00
sta SPRADDR
lda #$03
sta SPRDMA
lda CTRL_BYTE
sta PPUCTRL
lda #%00011110
sta PPUMASK ; Enable rendering
rti
exit:
stp
irq:
stp
sprite_data:
.byte $00
.byte T_PILL_R
.byte $00
.byte $00
sprite_data_end: