@tmustier/pi-nes 0.2.4 → 0.2.5

package/extensions/nes/native/nes-core/vendor/nes_rust/src/default_audio.rs

@@ -0,0 +1,49 @@
+use audio::{Audio, BUFFER_CAPACITY};
+
+pub struct DefaultAudio {
+	buffer_index: usize,
+	buffer: [f32; BUFFER_CAPACITY],
+	previous_value: f32
+}
+
+impl DefaultAudio {
+	pub fn new() -> Self {
+		DefaultAudio {
+			buffer_index: 0,
+			buffer: [0.0; BUFFER_CAPACITY],
+			previous_value: 0.0
+		}
+	}
+}
+
+impl Audio for DefaultAudio {
+	fn push(&mut self, value: f32) {
+		if self.buffer_index >= BUFFER_CAPACITY {
+			return;
+		}
+		self.buffer[self.buffer_index] = value;
+		self.buffer_index += 1;
+	}
+
+	fn copy_sample_buffer(&mut self, sample_buffer: &mut [f32]) {
+		// @TODO: Remove side effect?
+
+		// @TODO: Remove magic number
+		let client_sample_buffer_length = 4096;
+
+		for i in 0..client_sample_buffer_length {
+			sample_buffer[i] = match i >= self.buffer_index {
+				true => self.previous_value,
+				false => self.buffer[i]
+			};
+			self.previous_value = sample_buffer[i];
+		}
+		for i in client_sample_buffer_length..self.buffer.len() {
+			self.buffer[i - client_sample_buffer_length] = self.buffer[i];
+		}
+		self.buffer_index = match self.buffer_index < client_sample_buffer_length {
+			true => 0,
+			false => self.buffer_index - client_sample_buffer_length
+		};
+	}
+}

package/extensions/nes/native/nes-core/vendor/nes_rust/src/default_display.rs

@@ -0,0 +1,47 @@
+use display::{
+	Display,
+	PIXEL_BYTES,
+	PIXELS_CAPACITY,
+	SCREEN_HEIGHT,
+	SCREEN_WIDTH
+};
+
+pub struct DefaultDisplay {
+	pixels: Vec<u8>
+}
+
+impl DefaultDisplay {
+	pub fn new() -> Self {
+		DefaultDisplay {
+			pixels: vec![0; PIXELS_CAPACITY]
+		}
+	}
+}
+
+impl Display for DefaultDisplay {
+	fn render_pixel(&mut self, x: u16, y: u16, c: u32) {
+		let r = ((c >> 16) & 0xff) as u8;
+		let g = ((c >> 8) & 0xff) as u8;
+		let b = (c & 0xff) as u8;
+		let base_index = (y as u32 * SCREEN_WIDTH + x as u32) * PIXEL_BYTES;
+		// Is this memory layout, BGR, correct?
+		self.pixels[(base_index + 2) as usize] = r;
+		self.pixels[(base_index + 1) as usize] = g;
+		self.pixels[(base_index + 0) as usize] = b;
+	}
+
+	fn vblank(&mut self) {
+	}
+
+	fn copy_to_rgba_pixels(&self, pixels: &mut [u8]) {
+		for y in 0..SCREEN_HEIGHT {
+			for x in 0..SCREEN_WIDTH {
+				let base_index = (y * SCREEN_WIDTH + x) as usize;
+				pixels[base_index * 4 + 0] = self.pixels[base_index * 3 + 0];
+				pixels[base_index * 4 + 1] = self.pixels[base_index * 3 + 1];
+				pixels[base_index * 4 + 2] = self.pixels[base_index * 3 + 2];
+				pixels[base_index * 4 + 3] = 255;
+			}
+		}
+	}
+}

package/extensions/nes/native/nes-core/vendor/nes_rust/src/default_input.rs

@@ -0,0 +1,33 @@
+use std::collections::VecDeque;
+
+use input::Input;
+use button;
+
+pub struct DefaultInput {
+	events: VecDeque<(button::Button, button::Event)>
+}
+
+impl DefaultInput {
+	pub fn new() -> Self {
+		DefaultInput {
+			events: VecDeque::<(button::Button, button::Event)>::new()
+		}
+	}
+}
+
+impl Input for DefaultInput {
+	fn get_input(&mut self) -> Option<(button::Button, button::Event)> {
+		match self.events.len() > 0 {
+			true => self.events.pop_front(),
+			false => None
+		}
+	}
+
+	fn press(&mut self, button: button::Button) {
+		self.events.push_back((button, button::Event::Press));
+	}
+
+	fn release(&mut self, button: button::Button) {
+		self.events.push_back((button, button::Event::Release));
+	}
+}

package/extensions/nes/native/nes-core/vendor/nes_rust/src/display.rs

@@ -0,0 +1,10 @@
+pub const SCREEN_WIDTH: u32 = 256;
+pub const SCREEN_HEIGHT: u32 = 240;
+pub const PIXEL_BYTES: u32 = 3;
+pub const PIXELS_CAPACITY: usize = SCREEN_WIDTH as usize * SCREEN_HEIGHT as usize * PIXEL_BYTES as usize;
+
+pub trait Display {
+	fn render_pixel(&mut self, x: u16, y: u16, c: u32);
+	fn vblank(&mut self);
+	fn copy_to_rgba_pixels(&self, pixels: &mut [u8]);
+}

package/extensions/nes/native/nes-core/vendor/nes_rust/src/input.rs

@@ -0,0 +1,7 @@
+use button::{Button, Event};
+
+pub trait Input {
+	fn get_input(&mut self) -> Option<(Button, Event)>;
+	fn press(&mut self, button: Button);
+	fn release(&mut self, button: Button);
+}

package/extensions/nes/native/nes-core/vendor/nes_rust/src/joypad.rs

@@ -0,0 +1,86 @@
+use button;
+use register::Register;
+
+const BUTTON_NUM: u8 = 8;
+
+pub enum Button {
+	A,
+	B,
+	Select,
+	Start,
+	Up,
+	Down,
+	Left,
+	Right
+}
+
+fn button_index(button: Button) -> usize {
+	match button {
+		Button::A => 0,
+		Button::B => 1,
+		Button::Select => 2,
+		Button::Start => 3,
+		Button::Up => 4,
+		Button::Down => 5,
+		Button::Left => 6,
+		Button::Right => 7
+	}
+}
+
+pub struct Joypad {
+	register: Register<u8>,
+	latch: u8,
+	current_button: u8,
+	buttons: [bool; BUTTON_NUM as usize]
+}
+
+impl Joypad {
+	pub fn new() -> Self {
+		Joypad {
+			register: Register::<u8>::new(),
+			latch: 0,
+			current_button: 0,
+			buttons: [false; BUTTON_NUM as usize]
+		}
+	}
+
+	pub fn handle_input(&mut self, button: Button, event: button::Event) {
+		match event {
+			button::Event::Press => self.press_button(button),
+			button::Event::Release => self.release_button(button)
+		};
+	}
+
+	pub fn load_register(&mut self) -> u8 {
+		let button = match self.latch == 1 {
+			true => 1,
+			_ => {
+				let value = self.current_button;
+				self.current_button += 1;
+				value
+			}
+		};
+
+		match button >= BUTTON_NUM || self.buttons[button as usize] {
+			true => 1,
+			false => 0
+		}
+	}
+
+	pub fn store_register(&mut self, mut value: u8) {
+		self.register.store(value);
+		value = value & 1;
+		if value == 1 {
+			self.current_button = 0;
+		}
+		self.latch = value;
+	}
+
+	pub fn press_button(&mut self, button: Button) {
+		self.buttons[button_index(button)] = true;
+	}
+
+	pub fn release_button(&mut self, button: Button) {
+		self.buttons[button_index(button)] = false;
+	}
+}

package/extensions/nes/native/nes-core/vendor/nes_rust/src/lib.rs

@@ -0,0 +1,168 @@
+pub mod register;
+pub mod cpu;
+pub mod ppu;
+pub mod apu;
+pub mod rom;
+pub mod memory;
+pub mod mapper;
+pub mod button;
+pub mod joypad;
+pub mod input;
+pub mod audio;
+pub mod display;
+pub mod default_input;
+pub mod default_audio;
+pub mod default_display;
+
+use cpu::Cpu;
+use rom::Rom;
+use button::Button;
+use input::Input;
+use display::Display;
+use audio::Audio;
+
+/// NES emulator.
+///
+/// ```ignore
+/// use std::fs::File;
+/// use std::io::Read;
+/// use std::time::Duration;
+/// use nes_rust::Nes;
+/// use nes_rust::rom::Rom;
+/// use nes_rust::default_input::DefaultInput;
+/// use nes_rust::default_audio::DefaultAudio;
+/// use nes_rust::default_display::DefaultDisplay;
+///
+/// let input = Box::new(DefaultInput::new());
+/// let display = Box::new(DefaultDisplay::new());
+/// let audio = Box::new(DefaultAudio::new());
+/// let mut nes = Nes::new(input, display, audio);
+///
+/// // Load and set Rom from rom image binary
+/// let filename = &args[1];
+/// let mut file = File::open(filename)?;
+/// let mut contents = vec![];
+/// file.read_to_end(&mut contents)?;
+/// let rom = Rom::new(contents);
+/// nes.set_rom(rom);
+///
+/// // Go!
+/// nes.bootup();
+/// let mut rgba_pixels = [256 * 240 * 4];
+/// loop {
+///   nes.step_frame();
+///   nes.copy_pixels(rgba_pixels);
+///   // Render rgba_pixels
+///   // @TODO: Audio buffer sample code is T.B.D.
+///   // Adjust sleep time for your platform
+///   std::thread::sleep(Duration::from_millis(1));
+/// }
+/// ```
+pub struct Nes {
+	cpu: Cpu
+}
+
+impl Nes {
+	/// Creates a new `Nes`.
+    /// You need to pass [`input::Input`](./input/trait.Input.html),
+    /// [`display::Display`](./display/trait.Display.html), and
+    /// [`audio::Audio`](./audio/trait.Audio.html) traits for your platform
+    /// specific Input/Output.
+    ///
+    /// # Arguments
+    /// * `input` For pad input
+    /// * `display` For screen output
+    /// * `audio` For audio output
+	pub fn new(input: Box<dyn Input>, display: Box<dyn Display>,
+		audio: Box<dyn Audio>) -> Self {
+		Nes {
+			cpu: Cpu::new(
+				input,
+				display,
+				audio
+			)
+		}
+	}
+
+	/// Sets up NES rom
+	///
+	/// # Arguments
+	/// * `rom`
+	pub fn set_rom(&mut self, rom: Rom) {
+		self.cpu.set_rom(rom);
+	}
+
+	/// Boots up
+	pub fn bootup(&mut self) {
+		self.cpu.bootup();
+	}
+
+	/// Resets
+	pub fn reset(&mut self) {
+		self.cpu.reset();
+	}
+
+	/// Executes a CPU cycle
+	pub fn step(&mut self) {
+		self.cpu.step();
+	}
+
+	/// Executes a PPU (screen refresh) frame
+	pub fn step_frame(&mut self) {
+		self.cpu.step_frame();
+	}
+
+	/// Copies RGB pixels of screen to passed pixels.
+	/// The length and result should be specific to `display` passed via the constructor.
+	///
+	/// # Arguments
+	/// * `pixels`
+	pub fn copy_pixels(&self, pixels: &mut [u8]) {
+		self.cpu.get_ppu().get_display().copy_to_rgba_pixels(pixels);
+	}
+
+	/// Copies audio buffer to passed buffer.
+	/// The length and result should be specific to `audio` passed via the constructor.
+	///
+	/// # Arguments
+	/// * `buffer`
+	pub fn copy_sample_buffer(&mut self, buffer: &mut [f32]) {
+		self.cpu.get_mut_apu().get_mut_audio().copy_sample_buffer(buffer);
+	}
+
+	/// Presses a pad button
+	///
+	/// # Arguments
+	/// * `button`
+	pub fn press_button(&mut self, button: Button) {
+		self.cpu.get_mut_input().press(button);
+	}
+
+	/// Releases a pad button
+	///
+	/// # Arguments
+	/// * `buffer`
+	pub fn release_button(&mut self, button: Button) {
+		self.cpu.get_mut_input().release(button);
+	}
+
+	pub fn has_battery_backed_ram(&self) -> bool {
+		self.cpu.has_battery_backed_ram()
+	}
+
+	pub fn get_sram(&self) -> Vec<u8> {
+		self.cpu.get_sram()
+	}
+
+	pub fn set_sram(&mut self, data: Vec<u8>) {
+		self.cpu.set_sram(&data);
+	}
+
+	pub fn is_sram_dirty(&self) -> bool {
+		self.cpu.is_sram_dirty()
+	}
+
+	pub fn mark_sram_saved(&mut self) {
+		self.cpu.mark_sram_saved();
+	}
+}