Build aarch64 for Linux (#129)

* linux aarch

* more

* more

* more

* more

* more

* more

* more

* more

* more

* more

* more

.cargo/config.toml

@@ -1,2 +1,8 @@
 [target.'cfg(target_arch = "x86_64")']
 rustflags = ["-C", "target-cpu=x86-64-v3"]
+
+[target.'cfg(target_arch = "aarch64")']
+rustflags = ["-C", "target-cpu=cortex-a76"]
+
+[target.aarch64-unknown-linux-gnu]
+linker = "aarch64-linux-gnu-gcc"

.github/workflows/build.yml

@@ -12,64 +12,110 @@ env:
 jobs:
   build-linux:
     runs-on: ubuntu-latest
-    env:
-      TARGET: x86_64-unknown-linux-gnu
+    strategy:
+      matrix:
+        target: [x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu]
     steps:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      - name: Install sdl2 headers
-        run: |
-          sudo apt -y install libsdl2-dev
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
+          target: ${{ matrix.target }}
           rustflags: ""
+      - name: Install SDL2
+        if: matrix.target == 'aarch64-unknown-linux-gnu'
+        run: |
+          cat <<EOF > deb822sources
+          Types: deb
+          URIs: http://archive.ubuntu.com/ubuntu/
+          Suites: noble
+          Components: main restricted universe
+          Architectures: amd64
+
+          Types: deb
+          URIs: http://security.ubuntu.com/ubuntu/
+          Suites: noble-security
+          Components: main restricted universe
+          Architectures: amd64
+
+          Types: deb
+          URIs: http://archive.ubuntu.com/ubuntu/
+          Suites: noble-updates
+          Components: main restricted universe
+          Architectures: amd64
+
+          Types: deb
+          URIs: http://azure.ports.ubuntu.com/ubuntu-ports/
+          Suites: noble
+          Components: main restricted multiverse universe
+          Architectures: arm64
+
+          Types: deb
+          URIs: http://azure.ports.ubuntu.com/ubuntu-ports/
+          Suites: noble-updates
+          Components: main restricted multiverse universe
+          Architectures: arm64
+          EOF
+
+          sudo mv deb822sources /etc/apt/sources.list.d/ubuntu.sources
+          sudo dpkg --add-architecture arm64
+          sudo apt update
+          sudo apt -y install libsdl2-dev:arm64 g++-aarch64-linux-gnu
+      - name: Install SDL2
+        if: matrix.target == 'x86_64-unknown-linux-gnu'
+        run: |
+          sudo apt update
+          sudo apt -y install libsdl2-dev
       - name: Build
         run: |
-          cargo build --release -v --target=${{ env.TARGET }}
+          cargo build --release -v --target=${{ matrix.target }}
       - name: Upload file
         uses: actions/upload-artifact@v4
         with:
-          name: gopher64-linux
-          path: target/${{ env.TARGET }}/release/gopher64
+          name: gopher64-${{ matrix.target }}
+          path: target/${{ matrix.target }}/release/gopher64
 
   build-windows:
     runs-on: windows-latest
-    env:
-      TARGET: x86_64-pc-windows-msvc
+    strategy:
+      matrix:
+        target: [x86_64-pc-windows-msvc]
     steps:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
+          target: ${{ matrix.target }}
           rustflags: ""
       - name: Build
         run: |
-          cargo build --release -v --target=${{ env.TARGET }}
+          cargo build --release -v --target=${{ matrix.target }}
       - name: Upload file
         uses: actions/upload-artifact@v4
         with:
-          name: gopher64-windows
-          path: target/${{ env.TARGET }}/release/gopher64.exe
+          name: gopher64-${{ matrix.target }}
+          path: target/${{ matrix.target }}/release/gopher64.exe
 
   build-macos:
     runs-on: macos-latest
-    env:
-      TARGET: x86_64-apple-darwin
+    strategy:
+      matrix:
+        target: [x86_64-apple-darwin, aarch64-apple-darwin]
     steps:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          target: ${{ env.TARGET }}
+          target: ${{ matrix.target }}
           rustflags: ""
       - name: Build
         run: |
-          cargo build --release -v --target=${{ env.TARGET }}
+          cargo build --release -v --target=${{ matrix.target }}
       - name: Upload file
         uses: actions/upload-artifact@v4
         with:
-          name: gopher64-mac
-          path: target/${{ env.TARGET }}/release/gopher64
+          name: gopher64-${{ matrix.target }}
+          path: target/${{ matrix.target }}/release/gopher64

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gopher64"
-version = "0.1.13"
+version = "0.1.16"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -20,6 +20,7 @@ rusttype = "0.9"
 futures = "0.3"
 sdl2-sys = "0.37"
 spin_sleep = "1.3"
+encoding_rs = "0.8"
 clap = { version = "4.4", features = ["derive"] }
 
 [dependencies.sdl2]
@@ -29,7 +30,8 @@ features = ["static-link","bundled"]
 
 [build-dependencies]
 winres = "0.1"
-cc = { version = "1.0", features = ["parallel"] }
+bindgen = "0.71"
+cc = { version = "1.2", features = ["parallel"] }
 
 [profile.release]
 lto = true

README.md

@@ -46,6 +46,10 @@ You can create you own mappings by running `./gopher64 --configure-input-profile
 
 In order to use a controller (for example, an Xbox controller), run `./gopher64 --list-controllers` to get a list of attached controllers, and then assign it by doing `./gopher64 --assign-controller <controller_number> --port 1`
 
+## portable mode
+
+If you would like to keep all the game data in the same folder as executable, you just need to create a file called "portable.txt" in the same directory as the executable.
+
 ## contributing
 
 I am very open to contributions! Please reach out to me via a GitHub issue, or via discord (loganmc10) before doing substantial work on a PR.

build.rs

@@ -1,6 +1,7 @@
 fn main() {
     println!("cargo::rerun-if-changed=parallel-rdp");
 
+    let mut simd_build = cc::Build::new();
     let mut build = cc::Build::new();
     build
         .cpp(true)
@@ -52,11 +53,16 @@ fn main() {
         .include("parallel-rdp/parallel-rdp-standalone/util")
         .includes(std::env::var("DEP_SDL2_INCLUDE"));
 
-    #[cfg(target_os = "windows")]
-    {
-        #[cfg(target_arch = "x86_64")]
-        {
+    let os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
+    let arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap();
+    let mut simd_header = "";
+    if os == "windows" {
+        if arch == "x86_64" {
             build.flag("/arch:AVX2");
+        } else if arch == "aarch64" {
+            panic!("unsupported platform")
+        } else {
+            panic!("unknown arch")
         }
         build.flag("-DVK_USE_PLATFORM_WIN32_KHR");
 
@@ -64,14 +70,91 @@ fn main() {
             .set_icon("data/icon.ico")
             .compile()
             .unwrap();
-    }
-    #[cfg(any(target_os = "linux", target_os = "macos"))]
-    {
-        #[cfg(target_arch = "x86_64")]
-        {
+    } else if os == "linux" || os == "macos" {
+        if arch == "x86_64" {
             build.flag("-march=x86-64-v3");
+        } else if arch == "aarch64" {
+            build.flag("-march=armv8.2-a");
+            simd_build.flag("-march=armv8.2-a");
+            simd_build.file("src/compat/aarch64.c");
+            simd_header = "src/compat/sse2neon.h";
+        } else {
+            panic!("unknown arch")
         }
+    } else {
+        panic!("unknown OS")
     }
 
     build.compile("parallel-rdp");
+
+    let out_path = std::path::PathBuf::from(std::env::var("OUT_DIR").unwrap());
+
+    let parallel_bindings = bindgen::Builder::default()
+        .header("parallel-rdp/interface.hpp")
+        .allowlist_function("rdp_init")
+        .allowlist_function("rdp_close")
+        .allowlist_function("rdp_set_vi_register")
+        .allowlist_function("rdp_update_screen")
+        .allowlist_function("rdp_process_commands")
+        .allowlist_function("rdp_full_sync")
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .generate()
+        .expect("Unable to generate bindings");
+
+    parallel_bindings
+        .write_to_file(out_path.join("parallel_bindings.rs"))
+        .expect("Couldn't write bindings!");
+
+    if arch == "aarch64" {
+        let simd_bindings = bindgen::Builder::default()
+            .header(simd_header)
+            .allowlist_function("_mm_setzero_si128")
+            .allowlist_function("_mm_set_epi8")
+            .allowlist_function("_mm_movemask_epi8")
+            .allowlist_function("_mm_shuffle_epi8")
+            .allowlist_function("_mm_packs_epi16")
+            .allowlist_function("_mm_set_epi16")
+            .allowlist_function("_mm_cmpeq_epi8")
+            .allowlist_function("_mm_and_si128")
+            .allowlist_function("_mm_set1_epi8")
+            .allowlist_function("_mm_mullo_epi16")
+            .allowlist_function("_mm_cmpeq_epi16")
+            .allowlist_function("_mm_srli_epi16")
+            .allowlist_function("_mm_add_epi16")
+            .allowlist_function("_mm_slli_epi16")
+            .allowlist_function("_mm_mulhi_epi16")
+            .allowlist_function("_mm_srai_epi16")
+            .allowlist_function("_mm_andnot_si128")
+            .allowlist_function("_mm_or_si128")
+            .allowlist_function("_mm_mulhi_epu16")
+            .allowlist_function("_mm_sub_epi16")
+            .allowlist_function("_mm_unpacklo_epi16")
+            .allowlist_function("_mm_unpackhi_epi16")
+            .allowlist_function("_mm_packs_epi32")
+            .allowlist_function("_mm_adds_epu16")
+            .allowlist_function("_mm_cmpgt_epi16")
+            .allowlist_function("_mm_blendv_epi8")
+            .allowlist_function("_mm_min_epi16")
+            .allowlist_function("_mm_max_epi16")
+            .allowlist_function("_mm_subs_epi16")
+            .allowlist_function("_mm_adds_epi16")
+            .allowlist_function("_mm_xor_si128")
+            .allowlist_function("_mm_cmplt_epi16")
+            .allowlist_function("_mm_subs_epu16")
+            .allowlist_function("_mm_set1_epi32")
+            .blocklist_type("__m128i")
+            .blocklist_type("int64x2_t")
+            .wrap_static_fns(true)
+            .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+            .generate()
+            .expect("Unable to generate bindings");
+
+        simd_bindings
+            .write_to_file(out_path.join("simd_bindings.rs"))
+            .expect("Couldn't write bindings!");
+
+        simd_build.file(std::env::temp_dir().join("bindgen").join("extern.c"));
+        simd_build.include(".");
+        simd_build.compile("simd");
+    }
 }

parallel-rdp/interface.cpp

@@ -132,7 +132,38 @@ static const unsigned cmd_len_lut[64] = {
 	1,
 };
 
-void rdp_init(void *_window, GFX_INFO _gfx_info, bool _fullscreen)
+int sdl_event_filter(void *userdata, SDL_Event *event)
+{
+	if (event->type == SDL_WINDOWEVENT)
+	{
+		switch (event->window.event)
+		{
+		case SDL_WINDOWEVENT_CLOSE:
+			emu_running = false;
+			break;
+		case SDL_WINDOWEVENT_RESIZED:
+			wsi_platform->do_resize();
+			break;
+		default:
+			break;
+		}
+	}
+	else if (fullscreen && event->type == SDL_KEYDOWN)
+	{
+		switch (event->key.keysym.scancode)
+		{
+		case SDL_SCANCODE_ESCAPE:
+			emu_running = false;
+			break;
+		default:
+			break;
+		}
+	}
+
+	return 0;
+}
+
+void rdp_init(void *_window, GFX_INFO _gfx_info, bool _fullscreen, bool _upscale)
 {
 	window = (SDL_Window *)_window;
 	SDL_SetEventFilter(sdl_event_filter, nullptr);
@@ -156,6 +187,11 @@ void rdp_init(void *_window, GFX_INFO _gfx_info, bool _fullscreen)
 		rdp_close();
 	}
 	RDP::CommandProcessorFlags flags = 0;
+	if (_upscale)
+	{
+		flags |= RDP::COMMAND_PROCESSOR_FLAG_UPSCALING_2X_BIT;
+		flags |= RDP::COMMAND_PROCESSOR_FLAG_SUPER_SAMPLED_DITHER_BIT;
+	}
 	processor = new RDP::CommandProcessor(wsi->get_device(), gfx_info.RDRAM, 0, gfx_info.RDRAM_SIZE, gfx_info.RDRAM_SIZE / 2, flags);
 
 	if (!processor->device_is_supported())
@@ -193,37 +229,6 @@ void rdp_close()
 	}
 }
 
-int sdl_event_filter(void *userdata, SDL_Event *event)
-{
-	if (event->type == SDL_WINDOWEVENT)
-	{
-		switch (event->window.event)
-		{
-		case SDL_WINDOWEVENT_CLOSE:
-			emu_running = false;
-			break;
-		case SDL_WINDOWEVENT_RESIZED:
-			wsi_platform->do_resize();
-			break;
-		default:
-			break;
-		}
-	}
-	else if (fullscreen && event->type == SDL_KEYDOWN)
-	{
-		switch (event->key.keysym.scancode)
-		{
-		case SDL_SCANCODE_ESCAPE:
-			emu_running = false;
-			break;
-		default:
-			break;
-		}
-	}
-
-	return 0;
-}
-
 static void calculate_viewport(float *x, float *y, float *width, float *height)
 {
 	bool window_widescreen = false;

parallel-rdp/interface.hpp

@@ -23,13 +23,12 @@ extern "C"
 		uint32_t *VI_WIDTH_REG;
 	} GFX_INFO;
 
-	void rdp_init(void *_window, GFX_INFO _gfx_info, bool fullscreen);
+	void rdp_init(void *_window, GFX_INFO _gfx_info, bool fullscreen, bool _upscale);
 	void rdp_close();
 	void rdp_set_vi_register(uint32_t reg, uint32_t value);
 	bool rdp_update_screen();
 	uint64_t rdp_process_commands();
 	void rdp_full_sync();
-	int sdl_event_filter(void *userdata, SDL_Event *event);
 
 #ifdef __cplusplus
 }

src/compat/aarch64.c

@@ -0,0 +1,5 @@
+#include "src/compat/sse2neon.h"
+
+// Static wrappers
+
+__m128i _mm_srli_epi16__extern(__m128i __a, int __imm8) { return _mm_srli_epi16(__a, __imm8); }

src/compat/aarch64.rs

@@ -0,0 +1,4 @@
+unsafe extern "C" {
+    #[link_name = "_mm_srli_epi16__extern"]
+    pub fn _mm_srli_epi16(__a: __m128i, __imm8: ::std::os::raw::c_int) -> __m128i;
+}

src/device.rs

@@ -1,4 +1,17 @@
+#![allow(non_camel_case_types)]
+#![allow(improper_ctypes)]
+
+#[cfg(target_arch = "aarch64")]
+#[derive(Copy, Clone)]
+#[allow(dead_code)]
+pub struct __m128i(std::arch::aarch64::int64x2_t);
+#[cfg(target_arch = "aarch64")]
+include!(concat!(env!("OUT_DIR"), "/simd_bindings.rs"));
+#[cfg(target_arch = "x86_64")]
+use std::arch::x86_64::*;
+
 use crate::ui;
+use std::collections::HashMap;
 use std::fs;
 use std::io::Read;
 
@@ -33,8 +46,14 @@ pub mod sram;
 pub mod tlb;
 pub mod unmapped;
 pub mod vi;
+pub mod vru;
 
-pub fn run_game(file_path: &std::path::Path, device: &mut Device, fullscreen: bool) {
+pub fn run_game(
+    file_path: &std::path::Path,
+    data_dir: std::path::PathBuf,
+    device: &mut Device,
+    fullscreen: bool,
+) {
     let rom_contents = get_rom_contents(file_path);
 
     cart_rom::init(device, rom_contents); // cart needs to come before rdram
@@ -48,13 +67,16 @@ pub fn run_game(file_path: &std::path::Path, device: &mut Device, fullscreen: bo
 
     mi::init(device);
     pif::init(device);
+    if device.ui.config.input.emulate_vru {
+        vru::init(device);
+    }
     memory::init(device);
     rsp_interface::init(device);
     rdp::init(device);
     vi::init(device);
     cpu::init(device);
 
-    ui::storage::init(&mut device.ui);
+    ui::storage::init(&mut device.ui, data_dir);
     ui::storage::load_saves(&mut device.ui);
     cart_rom::load_rom_save(device);
 
@@ -157,10 +179,11 @@ pub struct Device {
     si: si::Si,
     ri: ri::Ri,
     flashram: sram::Flashram,
+    pub vru: vru::Vru,
 }
 
 impl Device {
-    pub fn new() -> Device {
+    pub fn new(config_dir: std::path::PathBuf) -> Device {
         let mut byte_swap: usize = 0;
         let test: [u8; 4] = [1, 2, 3, 4];
         // if the host computer is little endian, that means the RDRAM will be stored as little endian
@@ -169,7 +192,7 @@ impl Device {
             byte_swap = 3;
         }
         Device {
-            ui: ui::Ui::new(),
+            ui: ui::Ui::new(config_dir),
             byte_swap,
             cpu: cpu::Cpu {
                 cop0: cop0::Cop0 {
@@ -217,6 +240,7 @@ impl Device {
                 cop1: cop1::Cop1 {
                     fcr0: 0,
                     fcr31: 0,
+                    #[cfg(target_arch = "x86_64")]
                     flush_mode: 0,
                     fgr32: [[0; 4]; 32],
                     fgr64: [[0; 8]; 32],
@@ -323,15 +347,15 @@ impl Device {
                     divdp: false,
                     divin: 0,
                     divout: 0,
-                    shuffle: unsafe { [std::arch::x86_64::_mm_setzero_si128(); 16] },
-                    vcol: unsafe { std::arch::x86_64::_mm_setzero_si128() },
-                    vcoh: unsafe { std::arch::x86_64::_mm_setzero_si128() },
-                    vccl: unsafe { std::arch::x86_64::_mm_setzero_si128() },
-                    vcch: unsafe { std::arch::x86_64::_mm_setzero_si128() },
-                    vce: unsafe { std::arch::x86_64::_mm_setzero_si128() },
-                    accl: unsafe { std::arch::x86_64::_mm_setzero_si128() },
-                    accm: unsafe { std::arch::x86_64::_mm_setzero_si128() },
-                    acch: unsafe { std::arch::x86_64::_mm_setzero_si128() },
+                    shuffle: unsafe { [_mm_setzero_si128(); 16] },
+                    vcol: unsafe { _mm_setzero_si128() },
+                    vcoh: unsafe { _mm_setzero_si128() },
+                    vccl: unsafe { _mm_setzero_si128() },
+                    vcch: unsafe { _mm_setzero_si128() },
+                    vce: unsafe { _mm_setzero_si128() },
+                    accl: unsafe { _mm_setzero_si128() },
+                    accm: unsafe { _mm_setzero_si128() },
+                    acch: unsafe { _mm_setzero_si128() },
                     special_instrs: [rsp_su_instructions::reserved; 64],
                     regimm_instrs: [rsp_su_instructions::reserved; 32],
                     cop0_instrs: [rsp_su_instructions::reserved; 32],
@@ -395,6 +419,19 @@ impl Device {
                 silicon_id: [sram::FLASHRAM_TYPE_ID, sram::MX29L1100_ID],
                 mode: sram::FlashramMode::ReadArray,
             },
+            vru: vru::Vru {
+                status: 0,
+                voice_state: 0,
+                load_offset: 0,
+                voice_init: 0,
+                word_buffer: [0; 40],
+                words: Vec::new(),
+                talking: false,
+                word_mappings: HashMap::new(),
+                window_notifier: None,
+                word_receiver: None,
+                gui_ctx: None,
+            },
         }
     }
 }

src/device/ai.rs

@@ -1,16 +1,16 @@
 use crate::device;
 use crate::ui;
 
-pub const AI_DRAM_ADDR_REG: u32 = 0;
-pub const AI_LEN_REG: u32 = 1;
-//pub const AI_CONTROL_REG: u32 = 2;
-pub const AI_STATUS_REG: u32 = 3;
-pub const AI_DACRATE_REG: u32 = 4;
-//pub const AI_BITRATE_REG: u32 = 5;
+const AI_DRAM_ADDR_REG: u32 = 0;
+const AI_LEN_REG: u32 = 1;
+// const AI_CONTROL_REG: u32 = 2;
+const AI_STATUS_REG: u32 = 3;
+const AI_DACRATE_REG: u32 = 4;
+// const AI_BITRATE_REG: u32 = 5;
 pub const AI_REGS_COUNT: u32 = 6;
 
-pub const AI_STATUS_BUSY: u32 = 0x40000000;
-pub const AI_STATUS_FULL: u32 = 0x80000000;
+const AI_STATUS_BUSY: u32 = 0x40000000;
+const AI_STATUS_FULL: u32 = 0x80000000;
 
 pub struct Ai {
     pub regs: [u32; AI_REGS_COUNT as usize],

src/device/cart.rs

@@ -4,19 +4,19 @@ use chrono::Timelike;
 use crate::device;
 use crate::ui;
 
-pub const JCMD_STATUS: u8 = 0x00;
-pub const JCMD_EEPROM_READ: u8 = 0x04;
-pub const JCMD_EEPROM_WRITE: u8 = 0x05;
-pub const JCMD_AF_RTC_STATUS: u8 = 0x06;
-pub const JCMD_AF_RTC_READ: u8 = 0x07;
-pub const JCMD_AF_RTC_WRITE: u8 = 0x08;
-pub const JCMD_RESET: u8 = 0xff;
+const JCMD_STATUS: u8 = 0x00;
+const JCMD_EEPROM_READ: u8 = 0x04;
+const JCMD_EEPROM_WRITE: u8 = 0x05;
+const JCMD_AF_RTC_STATUS: u8 = 0x06;
+const JCMD_AF_RTC_READ: u8 = 0x07;
+const JCMD_AF_RTC_WRITE: u8 = 0x08;
+const JCMD_RESET: u8 = 0xff;
 
-pub const JDT_AF_RTC: u16 = 0x1000; /* RTC */
-pub const JDT_EEPROM_4K: u16 = 0x8000; /* 4k EEPROM */
-pub const JDT_EEPROM_16K: u16 = 0xc000; /* 16k EEPROM */
-pub const EEPROM_BLOCK_SIZE: usize = 8;
-pub const EEPROM_MAX_SIZE: usize = 0x800;
+const JDT_AF_RTC: u16 = 0x1000; /* RTC */
+const JDT_EEPROM_4K: u16 = 0x8000; /* 4k EEPROM */
+const JDT_EEPROM_16K: u16 = 0xc000; /* 16k EEPROM */
+const EEPROM_BLOCK_SIZE: usize = 8;
+const EEPROM_MAX_SIZE: usize = 0x800;
 
 pub struct AfRtc {
     pub control: u16,

src/device/cart_rom.rs

@@ -10,7 +10,7 @@ pub enum CicType {
     CicNus5167,
 }
 
-pub const CART_MASK: usize = 0xFFFFFFF;
+const CART_MASK: usize = 0xFFFFFFF;
 pub struct Cart {
     pub rom: Vec<u8>,
     pub is_viewer_buffer: [u8; 0xFFFF],

src/device/controller.rs

@@ -3,24 +3,18 @@ use crate::ui;
 
 pub const JCMD_STATUS: u8 = 0x00;
 pub const JCMD_CONTROLLER_READ: u8 = 0x01;
-pub const JCMD_PAK_READ: u8 = 0x02;
-pub const JCMD_PAK_WRITE: u8 = 0x03;
-//pub const JCMD_VRU_READ: u8 = 0x09;
-//pub const JCMD_VRU_WRITE: u8 = 0x0A;
-//pub const JCMD_VRU_READ_STATUS: u8 = 0x0B;
-//pub const JCMD_VRU_WRITE_CONFIG: u8 = 0x0C;
-//pub const JCMD_VRU_WRITE_INIT: u8 = 0x0D;
+const JCMD_PAK_READ: u8 = 0x02;
+const JCMD_PAK_WRITE: u8 = 0x03;
 pub const JCMD_RESET: u8 = 0xff;
 
-//pub const JDT_NONE: u16 = 0x0000;
-pub const JDT_JOY_ABS_COUNTERS: u16 = 0x0001; /* joystick with absolute coordinates */
-//pub const JDT_JOY_REL_COUNTERS: u16 = 0x0002; /* joystick with relative coordinates (= mouse) */
-pub const JDT_JOY_PORT: u16 = 0x0004; /* has port for external paks */
-//pub const JDT_VRU: u16 = 0x0100; /* VRU */
-pub const PAK_CHUNK_SIZE: usize = 0x20;
-pub const CONT_STATUS_PAK_NOT_PRESENT: u8 = 0;
-pub const CONT_STATUS_PAK_PRESENT: u8 = 1;
-pub const CONT_FLAVOR: u16 = JDT_JOY_ABS_COUNTERS | JDT_JOY_PORT;
+//const JDT_NONE: u16 = 0x0000;
+const JDT_JOY_ABS_COUNTERS: u16 = 0x0001; /* joystick with absolute coordinates */
+//const JDT_JOY_REL_COUNTERS: u16 = 0x0002; /* joystick with relative coordinates (= mouse) */
+const JDT_JOY_PORT: u16 = 0x0004; /* has port for external paks */
+const PAK_CHUNK_SIZE: usize = 0x20;
+const CONT_STATUS_PAK_NOT_PRESENT: u8 = 0;
+const CONT_STATUS_PAK_PRESENT: u8 = 1;
+const CONT_FLAVOR: u16 = JDT_JOY_ABS_COUNTERS | JDT_JOY_PORT;
 
 #[derive(Copy, Clone)]
 pub struct PakHandler {
@@ -80,9 +74,9 @@ pub fn pak_read_block(
 
     if handler.is_some() {
         (handler.unwrap().read)(device, channel, address, data, PAK_CHUNK_SIZE);
-        device.pif.ram[dcrc] = pak_data_crc(device, data, PAK_CHUNK_SIZE)
+        device.pif.ram[dcrc] = data_crc(device, data, PAK_CHUNK_SIZE)
     } else {
-        device.pif.ram[dcrc] = !pak_data_crc(device, data, PAK_CHUNK_SIZE)
+        device.pif.ram[dcrc] = !data_crc(device, data, PAK_CHUNK_SIZE)
     }
 }
 
@@ -99,13 +93,13 @@ pub fn pak_write_block(
 
     if handler.is_some() {
         (handler.unwrap().write)(device, channel, address, data, PAK_CHUNK_SIZE);
-        device.pif.ram[dcrc] = pak_data_crc(device, data, PAK_CHUNK_SIZE)
+        device.pif.ram[dcrc] = data_crc(device, data, PAK_CHUNK_SIZE)
     } else {
-        device.pif.ram[dcrc] = !pak_data_crc(device, data, PAK_CHUNK_SIZE)
+        device.pif.ram[dcrc] = !data_crc(device, data, PAK_CHUNK_SIZE)
     }
 }
 
-pub fn pak_data_crc(device: &device::Device, data_offset: usize, size: usize) -> u8 {
+pub fn data_crc(device: &device::Device, data_offset: usize, size: usize) -> u8 {
     let mut i = 0;
     let mut crc = 0;
 

src/device/cop0.rs

@@ -1,37 +1,37 @@
 use crate::device;
 
 pub const COP0_INDEX_REG: u32 = 0;
-pub const COP0_RANDOM_REG: u32 = 1;
+const COP0_RANDOM_REG: u32 = 1;
 pub const COP0_ENTRYLO0_REG: u32 = 2;
 pub const COP0_ENTRYLO1_REG: u32 = 3;
 pub const COP0_CONTEXT_REG: u32 = 4;
 pub const COP0_PAGEMASK_REG: u32 = 5;
-pub const COP0_WIRED_REG: u32 = 6;
-//pub const COP0_UNUSED_7: u32 = 7;
+const COP0_WIRED_REG: u32 = 6;
+//const COP0_UNUSED_7: u32 = 7;
 pub const COP0_BADVADDR_REG: u32 = 8;
 pub const COP0_COUNT_REG: u32 = 9;
 pub const COP0_ENTRYHI_REG: u32 = 10;
-pub const COP0_COMPARE_REG: u32 = 11;
+const COP0_COMPARE_REG: u32 = 11;
 pub const COP0_STATUS_REG: u32 = 12;
 pub const COP0_CAUSE_REG: u32 = 13;
 pub const COP0_EPC_REG: u32 = 14;
-pub const COP0_PREVID_REG: u32 = 15;
-pub const COP0_CONFIG_REG: u32 = 16;
+const COP0_PREVID_REG: u32 = 15;
+const COP0_CONFIG_REG: u32 = 16;
 pub const COP0_LLADDR_REG: u32 = 17;
-//pub const COP0_WATCHLO_REG: u32 = 18;
-//pub const COP0_WATCHHI_REG: u32 = 19;
+//const COP0_WATCHLO_REG: u32 = 18;
+//const COP0_WATCHHI_REG: u32 = 19;
 pub const COP0_XCONTEXT_REG: u32 = 20;
-//pub const COP0_UNUSED_21: u32 = 21;
-//pub const COP0_UNUSED_22: u32 = 22;
-//pub const COP0_UNUSED_23: u32 = 23;
-//pub const COP0_UNUSED_24: u32 = 24;
-//pub const COP0_UNUSED_25: u32 = 25;
-//pub const COP0_PARITYERR_REG: u32 = 26;
-//pub const COP0_CACHEERR_REG: u32 = 27;
+//const COP0_UNUSED_21: u32 = 21;
+//const COP0_UNUSED_22: u32 = 22;
+//const COP0_UNUSED_23: u32 = 23;
+//const COP0_UNUSED_24: u32 = 24;
+//const COP0_UNUSED_25: u32 = 25;
+//const COP0_PARITYERR_REG: u32 = 26;
+//const COP0_CACHEERR_REG: u32 = 27;
 pub const COP0_TAGLO_REG: u32 = 28;
-//pub const COP0_TAGHI_REG: u32 = 29;
-pub const COP0_ERROREPC_REG: u32 = 30;
-//pub const COP0_UNUSED_31: u32 = 31;
+//const COP0_TAGHI_REG: u32 = 29;
+const COP0_ERROREPC_REG: u32 = 30;
+//const COP0_UNUSED_31: u32 = 31;
 pub const COP0_REGS_COUNT: u32 = 32;
 
 pub const COP0_STATUS_IE: u64 = 1 << 0;
@@ -42,12 +42,12 @@ pub const COP0_STATUS_FR: u64 = 1 << 26;
 pub const COP0_STATUS_CU1: u64 = 1 << 29;
 pub const COP0_STATUS_CU2: u64 = 1 << 30;
 
-//pub const COP0_CAUSE_EXCCODE_INTR: u64 = 0 << 2;
+//const COP0_CAUSE_EXCCODE_INTR: u64 = 0 << 2;
 pub const COP0_CAUSE_EXCCODE_MOD: u64 = 1 << 2;
 pub const COP0_CAUSE_EXCCODE_TLBL: u64 = 2 << 2;
 pub const COP0_CAUSE_EXCCODE_TLBS: u64 = 3 << 2;
-//pub const COP0_CAUSE_EXCCODE_ADEL: u64 = 4 << 2;
-//pub const COP0_CAUSE_EXCCODE_ADES: u64 = 5 << 2;
+//const COP0_CAUSE_EXCCODE_ADEL: u64 = 4 << 2;
+//const COP0_CAUSE_EXCCODE_ADES: u64 = 5 << 2;
 pub const COP0_CAUSE_EXCCODE_SYS: u64 = 8 << 2;
 pub const COP0_CAUSE_EXCCODE_BP: u64 = 9 << 2;
 pub const COP0_CAUSE_EXCCODE_RI: u64 = 10 << 2;
@@ -55,7 +55,7 @@ pub const COP0_CAUSE_EXCCODE_CPU: u64 = 11 << 2;
 pub const COP0_CAUSE_EXCCODE_TR: u64 = 13 << 2;
 pub const COP0_CAUSE_EXCCODE_FPE: u64 = 15 << 2;
 pub const COP0_CAUSE_IP2: u64 = 1 << 10;
-pub const COP0_CAUSE_IP7: u64 = 1 << 15;
+const COP0_CAUSE_IP7: u64 = 1 << 15;
 pub const COP0_CAUSE_BD: u64 = 1 << 31;
 
 pub const COP0_CAUSE_CE1: u64 = 1 << 28;

src/device/cop1.rs

@@ -1,31 +1,33 @@
 use crate::device;
 
-//pub const FCR31_FLAG_INEXACT_BIT: u32 = 1 << 2;
-//pub const FCR31_FLAG_UNDERFLOW_BIT: u32 = 1 << 3;
-//pub const FCR31_FLAG_OVERFLOW_BIT: u32 = 1 << 4;
-//pub const FCR31_FLAG_DIVBYZERO_BIT: u32 = 1 << 5;
-//pub const FCR31_FLAG_INVALID_BIT: u32 = 1 << 6;
-//pub const FCR31_ENABLE_INEXACT_BIT: u32 = 1 << 7;
-//pub const FCR31_ENABLE_UNDERFLOW_BIT: u32 = 1 << 8;
-//pub const FCR31_ENABLE_OVERFLOW_BIT: u32 = 1 << 9;
-//pub const FCR31_ENABLE_DIVBYZERO_BIT: u32 = 1 << 10;
-//pub const FCR31_ENABLE_INVALID_BIT: u32 = 1 << 11;
-//pub const FCR31_CAUSE_INEXACT_BIT: u32 = 1 << 12;
-//pub const FCR31_CAUSE_UNDERFLOW_BIT: u32 = 1 << 13;
-//pub const FCR31_CAUSE_OVERFLOW_BIT: u32 = 1 << 14;
-//pub const FCR31_CAUSE_DIVBYZERO_BIT: u32 = 1 << 15;
-//pub const FCR31_CAUSE_INVALID_BIT: u32 = 1 << 16;
-pub const FCR31_CAUSE_UNIMP_BIT: u32 = 1 << 17;
+//const FCR31_FLAG_INEXACT_BIT: u32 = 1 << 2;
+//const FCR31_FLAG_UNDERFLOW_BIT: u32 = 1 << 3;
+//const FCR31_FLAG_OVERFLOW_BIT: u32 = 1 << 4;
+//const FCR31_FLAG_DIVBYZERO_BIT: u32 = 1 << 5;
+//const FCR31_FLAG_INVALID_BIT: u32 = 1 << 6;
+//const FCR31_ENABLE_INEXACT_BIT: u32 = 1 << 7;
+//const FCR31_ENABLE_UNDERFLOW_BIT: u32 = 1 << 8;
+//const FCR31_ENABLE_OVERFLOW_BIT: u32 = 1 << 9;
+//const FCR31_ENABLE_DIVBYZERO_BIT: u32 = 1 << 10;
+//const FCR31_ENABLE_INVALID_BIT: u32 = 1 << 11;
+//const FCR31_CAUSE_INEXACT_BIT: u32 = 1 << 12;
+//const FCR31_CAUSE_UNDERFLOW_BIT: u32 = 1 << 13;
+//const FCR31_CAUSE_OVERFLOW_BIT: u32 = 1 << 14;
+//const FCR31_CAUSE_DIVBYZERO_BIT: u32 = 1 << 15;
+//const FCR31_CAUSE_INVALID_BIT: u32 = 1 << 16;
+const FCR31_CAUSE_UNIMP_BIT: u32 = 1 << 17;
 pub const FCR31_CMP_BIT: u32 = 1 << 23;
-pub const FCR31_FS_BIT: u32 = 1 << 24;
+#[cfg(target_arch = "x86_64")]
+const FCR31_FS_BIT: u32 = 1 << 24;
 
-pub const FCR31_CAUSE_MASK: u32 = 0b00000000000000111111000000000000;
-pub const FCR31_ENABLE_MASK: u32 = 0b00000000000000000000111110000000;
-pub const FCR31_WRITE_MASK: u32 = 0b00000001100000111111111111111111;
+const FCR31_CAUSE_MASK: u32 = 0b00000000000000111111000000000000;
+const FCR31_ENABLE_MASK: u32 = 0b00000000000000000000111110000000;
+const FCR31_WRITE_MASK: u32 = 0b00000001100000111111111111111111;
 
 pub struct Cop1 {
     pub fcr0: u32,
     pub fcr31: u32,
+    #[cfg(target_arch = "x86_64")]
     pub flush_mode: u32,
     pub fgr32: [[u8; 4]; 32],
     pub fgr64: [[u8; 8]; 32],
@@ -367,21 +369,24 @@ pub fn set_control_registers_fpu(device: &mut device::Device, index: u32, data:
                 device::exceptions::floating_point_exception(device)
             }
 
-            unsafe {
-                let flush_mode;
-                if (device.cpu.cop1.fcr31 & 2) != 0 {
-                    if (device.cpu.cop1.fcr31 & FCR31_FS_BIT) != 0 {
-                        flush_mode = std::arch::x86_64::_MM_FLUSH_ZERO_OFF
+            #[cfg(target_arch = "x86_64")]
+            {
+                unsafe {
+                    let flush_mode;
+                    if (device.cpu.cop1.fcr31 & 2) != 0 {
+                        if (device.cpu.cop1.fcr31 & FCR31_FS_BIT) != 0 {
+                            flush_mode = std::arch::x86_64::_MM_FLUSH_ZERO_OFF
+                        } else {
+                            flush_mode = std::arch::x86_64::_MM_FLUSH_ZERO_ON;
+                        }
                     } else {
                         flush_mode = std::arch::x86_64::_MM_FLUSH_ZERO_ON;
                     }
-                } else {
-                    flush_mode = std::arch::x86_64::_MM_FLUSH_ZERO_ON;
-                }
-                if flush_mode != device.cpu.cop1.flush_mode {
-                    #[allow(deprecated)]
-                    std::arch::x86_64::_MM_SET_FLUSH_ZERO_MODE(flush_mode);
-                    device.cpu.cop1.flush_mode = flush_mode;
+                    if flush_mode != device.cpu.cop1.flush_mode {
+                        #[allow(deprecated)]
+                        std::arch::x86_64::_MM_SET_FLUSH_ZERO_MODE(flush_mode);
+                        device.cpu.cop1.flush_mode = flush_mode;
+                    }
                 }
             }
         }

src/device/events.rs

@@ -11,6 +11,7 @@ pub enum EventType {
     InterruptCheck,
     SPDma,
     Compare,
+    Vru,
     Count,
 }
 

src/device/is_viewer.rs

@@ -1,6 +1,6 @@
 use crate::device;
 
-pub const IS_VIEWER_MASK: usize = 0xFFFF;
+const IS_VIEWER_MASK: usize = 0xFFFF;
 
 pub fn read_mem(
     device: &mut device::Device,

src/device/memory.rs

@@ -1,24 +1,24 @@
 use crate::device;
 
-pub const MM_RDRAM_DRAM: usize = 0x00000000;
-pub const MM_RDRAM_REGS: usize = 0x03f00000;
-pub const MM_RSP_MEM: usize = 0x04000000;
-pub const MM_RSP_REGS: usize = 0x04040000;
-pub const MM_RSP_REGS_PC: usize = 0x04080000;
-pub const MM_DPC_REGS: usize = 0x04100000;
-pub const MM_DPS_REGS: usize = 0x04200000;
-pub const MM_MI_REGS: usize = 0x04300000;
-pub const MM_VI_REGS: usize = 0x04400000;
-pub const MM_AI_REGS: usize = 0x04500000;
-pub const MM_PI_REGS: usize = 0x04600000;
-pub const MM_RI_REGS: usize = 0x04700000;
-pub const MM_SI_REGS: usize = 0x04800000;
+const MM_RDRAM_DRAM: usize = 0x00000000;
+const MM_RDRAM_REGS: usize = 0x03f00000;
+const MM_RSP_MEM: usize = 0x04000000;
+const MM_RSP_REGS: usize = 0x04040000;
+const MM_RSP_REGS_PC: usize = 0x04080000;
+const MM_DPC_REGS: usize = 0x04100000;
+const MM_DPS_REGS: usize = 0x04200000;
+const MM_MI_REGS: usize = 0x04300000;
+const MM_VI_REGS: usize = 0x04400000;
+const MM_AI_REGS: usize = 0x04500000;
+const MM_PI_REGS: usize = 0x04600000;
+const MM_RI_REGS: usize = 0x04700000;
+const MM_SI_REGS: usize = 0x04800000;
 //const MM_DOM2_ADDR1: usize = 0x05000000;
 pub const MM_DOM2_ADDR2: usize = 0x08000000;
 pub const MM_CART_ROM: usize = 0x10000000;
-pub const MM_PIF_MEM: usize = 0x1fc00000;
-//pub const MM_DOM1_ADDR3: usize = 0x1fd00000;
-pub const MM_IS_VIEWER: usize = 0x13ff0000;
+const MM_PIF_MEM: usize = 0x1fc00000;
+//const MM_DOM1_ADDR3: usize = 0x1fd00000;
+const MM_IS_VIEWER: usize = 0x13ff0000;
 
 #[derive(PartialEq)]
 pub enum AccessType {

src/device/mempak.rs

@@ -1,7 +1,7 @@
 use crate::device;
 
-pub const MEMPAK_SIZE: usize = 0x8000;
-pub const MPK_PAGE_SIZE: usize = 256;
+const MEMPAK_SIZE: usize = 0x8000;
+const MPK_PAGE_SIZE: usize = 256;
 
 pub fn format_mempak(device: &mut device::Device) {
     if device.ui.saves.mempak.0.len() < MEMPAK_SIZE * 4 {

src/device/mi.rs

@@ -1,9 +1,9 @@
 use crate::device;
 
-pub const MI_INIT_MODE_REG: u32 = 0;
-pub const MI_VERSION_REG: u32 = 1;
-pub const MI_INTR_REG: u32 = 2;
-pub const MI_INTR_MASK_REG: u32 = 3;
+const MI_INIT_MODE_REG: u32 = 0;
+const MI_VERSION_REG: u32 = 1;
+const MI_INTR_REG: u32 = 2;
+const MI_INTR_MASK_REG: u32 = 3;
 pub const MI_REGS_COUNT: u32 = 4;
 
 /* read */
@@ -15,34 +15,34 @@ pub const MI_INTR_PI: u32 = 1 << 4;
 pub const MI_INTR_DP: u32 = 1 << 5;
 
 /* write */
-pub const MI_CLR_SP: u32 = 1 << 0;
-pub const MI_SET_SP: u32 = 1 << 1;
-pub const MI_CLR_SI: u32 = 1 << 2;
-pub const MI_SET_SI: u32 = 1 << 3;
-pub const MI_CLR_AI: u32 = 1 << 4;
-pub const MI_SET_AI: u32 = 1 << 5;
-pub const MI_CLR_VI: u32 = 1 << 6;
-pub const MI_SET_VI: u32 = 1 << 7;
-pub const MI_CLR_PI: u32 = 1 << 8;
-pub const MI_SET_PI: u32 = 1 << 9;
-pub const MI_CLR_DP: u32 = 1 << 10;
-pub const MI_SET_DP: u32 = 1 << 11;
+const MI_CLR_SP: u32 = 1 << 0;
+const MI_SET_SP: u32 = 1 << 1;
+const MI_CLR_SI: u32 = 1 << 2;
+const MI_SET_SI: u32 = 1 << 3;
+const MI_CLR_AI: u32 = 1 << 4;
+const MI_SET_AI: u32 = 1 << 5;
+const MI_CLR_VI: u32 = 1 << 6;
+const MI_SET_VI: u32 = 1 << 7;
+const MI_CLR_PI: u32 = 1 << 8;
+const MI_SET_PI: u32 = 1 << 9;
+const MI_CLR_DP: u32 = 1 << 10;
+const MI_SET_DP: u32 = 1 << 11;
 
 /* mode read */
-pub const MI_INIT_MODE: u32 = 1 << 7;
-pub const MI_EBUS_MODE: u32 = 1 << 8;
-pub const MI_RDRAM_MODE: u32 = 1 << 9;
+const MI_INIT_MODE: u32 = 1 << 7;
+const MI_EBUS_MODE: u32 = 1 << 8;
+const MI_RDRAM_MODE: u32 = 1 << 9;
 
 /* mode write */
-pub const MI_CLR_INIT: u32 = 1 << 7;
-pub const MI_SET_INIT: u32 = 1 << 8;
-pub const MI_CLR_EBUS: u32 = 1 << 9;
-pub const MI_SET_EBUS: u32 = 1 << 10;
-pub const MI_CLR_DP_INTR: u32 = 1 << 11;
-pub const MI_CLR_RDRAM: u32 = 1 << 12;
-pub const MI_SET_RDRAM: u32 = 1 << 13;
+const MI_CLR_INIT: u32 = 1 << 7;
+const MI_SET_INIT: u32 = 1 << 8;
+const MI_CLR_EBUS: u32 = 1 << 9;
+const MI_SET_EBUS: u32 = 1 << 10;
+const MI_CLR_DP_INTR: u32 = 1 << 11;
+const MI_CLR_RDRAM: u32 = 1 << 12;
+const MI_SET_RDRAM: u32 = 1 << 13;
 
-pub const MI_INIT_LENGTH_MASK: u32 = 0b1111111;
+const MI_INIT_LENGTH_MASK: u32 = 0b1111111;
 
 pub struct Mi {
     pub regs: [u32; MI_REGS_COUNT as usize],

src/device/pi.rs

@@ -1,29 +1,30 @@
 use crate::device;
 
-pub const PI_DRAM_ADDR_REG: u32 = 0;
-pub const PI_CART_ADDR_REG: u32 = 1;
-pub const PI_RD_LEN_REG: u32 = 2;
-pub const PI_WR_LEN_REG: u32 = 3;
+const PI_DRAM_ADDR_REG: u32 = 0;
+const PI_CART_ADDR_REG: u32 = 1;
+const PI_RD_LEN_REG: u32 = 2;
+const PI_WR_LEN_REG: u32 = 3;
 pub const PI_STATUS_REG: u32 = 4;
-pub const PI_BSD_DOM1_LAT_REG: u32 = 5;
-pub const PI_BSD_DOM1_PWD_REG: u32 = 6;
-pub const PI_BSD_DOM1_PGS_REG: u32 = 7;
-pub const PI_BSD_DOM1_RLS_REG: u32 = 8;
-pub const PI_BSD_DOM2_LAT_REG: u32 = 9;
-pub const PI_BSD_DOM2_PWD_REG: u32 = 10;
-pub const PI_BSD_DOM2_PGS_REG: u32 = 11;
-pub const PI_BSD_DOM2_RLS_REG: u32 = 12;
-pub const PI_REGS_COUNT: u32 = 13;
+const PI_BSD_DOM1_LAT_REG: u32 = 5;
+const PI_BSD_DOM1_PWD_REG: u32 = 6;
+const PI_BSD_DOM1_PGS_REG: u32 = 7;
+const PI_BSD_DOM1_RLS_REG: u32 = 8;
+const PI_BSD_DOM2_LAT_REG: u32 = 9;
+const PI_BSD_DOM2_PWD_REG: u32 = 10;
+const PI_BSD_DOM2_PGS_REG: u32 = 11;
+const PI_BSD_DOM2_RLS_REG: u32 = 12;
+//const UNKNOWN_REG: u32 = 13; //LibDragon
+pub const PI_REGS_COUNT: u32 = 14;
 
 /* PI_STATUS - read */
-pub const PI_STATUS_DMA_BUSY: u32 = 1 << 0;
+const PI_STATUS_DMA_BUSY: u32 = 1 << 0;
 pub const PI_STATUS_IO_BUSY: u32 = 1 << 1;
-//pub const PI_STATUS_ERROR: u32 = 1 << 2;
-pub const PI_STATUS_INTERRUPT: u32 = 1 << 3;
+//const PI_STATUS_ERROR: u32 = 1 << 2;
+const PI_STATUS_INTERRUPT: u32 = 1 << 3;
 
 /* PI_STATUS - write */
-pub const PI_STATUS_RESET: u32 = 1 << 0;
-pub const PI_STATUS_CLR_INTR: u32 = 1 << 1;
+const PI_STATUS_RESET: u32 = 1 << 0;
+const PI_STATUS_CLR_INTR: u32 = 1 << 1;
 
 pub struct Pi {
     pub regs: [u32; PI_REGS_COUNT as usize],

src/device/pif.rs

@@ -99,7 +99,7 @@ pub fn update_pif_ram(device: &mut device::Device) -> u64 {
     for k in 0..PIF_CHANNELS_COUNT {
         active_channels += process_channel(device, k)
     }
-    (24000 + (active_channels * 28000)) as u64
+    (24000 + (active_channels * 30000)) as u64
 }
 
 pub fn disable_pif_channel(channel: &mut PifChannel) {
@@ -229,8 +229,16 @@ pub fn init(device: &mut device::Device) {
         write: device::mempak::write,
     };
 
-    device.pif.channels[0].pak_handler = Some(mempak_handler);
-    device.pif.channels[0].process = Some(device::controller::process);
+    for i in 0..4 {
+        if device.ui.config.input.controller_enabled[i] {
+            device.pif.channels[i].pak_handler = Some(mempak_handler);
+            device.pif.channels[i].process = Some(device::controller::process);
+        }
+    }
+    if device.ui.config.input.emulate_vru {
+        device.pif.channels[3].pak_handler = None;
+        device.pif.channels[3].process = Some(device::vru::process);
+    }
     device.pif.channels[4].process = Some(device::cart::process)
 }
 

src/device/rdp.rs

@@ -5,41 +5,41 @@ pub const DPC_START_REG: u32 = 0;
 pub const DPC_END_REG: u32 = 1;
 pub const DPC_CURRENT_REG: u32 = 2;
 pub const DPC_STATUS_REG: u32 = 3;
-pub const DPC_CLOCK_REG: u32 = 4;
-pub const DPC_BUFBUSY_REG: u32 = 5;
-pub const DPC_PIPEBUSY_REG: u32 = 6;
-pub const DPC_TMEM_REG: u32 = 7;
+const DPC_CLOCK_REG: u32 = 4;
+const DPC_BUFBUSY_REG: u32 = 5;
+const DPC_PIPEBUSY_REG: u32 = 6;
+const DPC_TMEM_REG: u32 = 7;
 pub const DPC_REGS_COUNT: u32 = 8;
 
-//pub const DPS_TBIST_REG: u32 = 0;
-//pub const DPS_TEST_MODE_REG: u32 = 1;
-//pub const DPS_BUFTEST_ADDR_REG: u32 = 2;
-//pub const DPS_BUFTEST_DATA_REG: u32 = 3;
+//const DPS_TBIST_REG: u32 = 0;
+//const DPS_TEST_MODE_REG: u32 = 1;
+//const DPS_BUFTEST_ADDR_REG: u32 = 2;
+//const DPS_BUFTEST_DATA_REG: u32 = 3;
 pub const DPS_REGS_COUNT: u32 = 4;
 
 /* DPC status - read */
-pub const DPC_STATUS_XBUS_DMEM_DMA: u32 = 1 << 0;
-pub const DPC_STATUS_FREEZE: u32 = 1 << 1;
-pub const DPC_STATUS_FLUSH: u32 = 1 << 2;
-pub const DPC_STATUS_START_GCLK: u32 = 1 << 3;
-pub const DPC_STATUS_TMEM_BUSY: u32 = 1 << 4;
-pub const DPC_STATUS_PIPE_BUSY: u32 = 1 << 5;
-pub const DPC_STATUS_CMD_BUSY: u32 = 1 << 6;
-pub const DPC_STATUS_CBUF_READY: u32 = 1 << 7;
-//pub const DPC_STATUS_DMA_BUSY: u32 = 1 << 8;
-//pub const DPC_STATUS_END_VALID: u32 = 1 << 9;
-pub const DPC_STATUS_START_VALID: u32 = 1 << 10;
+const DPC_STATUS_XBUS_DMEM_DMA: u32 = 1 << 0;
+const DPC_STATUS_FREEZE: u32 = 1 << 1;
+const DPC_STATUS_FLUSH: u32 = 1 << 2;
+const DPC_STATUS_START_GCLK: u32 = 1 << 3;
+const DPC_STATUS_TMEM_BUSY: u32 = 1 << 4;
+const DPC_STATUS_PIPE_BUSY: u32 = 1 << 5;
+const DPC_STATUS_CMD_BUSY: u32 = 1 << 6;
+const DPC_STATUS_CBUF_READY: u32 = 1 << 7;
+//const DPC_STATUS_DMA_BUSY: u32 = 1 << 8;
+//const DPC_STATUS_END_VALID: u32 = 1 << 9;
+const DPC_STATUS_START_VALID: u32 = 1 << 10;
 /* DPC status - write */
-pub const DPC_CLR_XBUS_DMEM_DMA: u32 = 1 << 0;
-pub const DPC_SET_XBUS_DMEM_DMA: u32 = 1 << 1;
-pub const DPC_CLR_FREEZE: u32 = 1 << 2;
-pub const DPC_SET_FREEZE: u32 = 1 << 3;
-pub const DPC_CLR_FLUSH: u32 = 1 << 4;
-pub const DPC_SET_FLUSH: u32 = 1 << 5;
-pub const DPC_CLR_TMEM_CTR: u32 = 1 << 6;
-pub const DPC_CLR_PIPE_CTR: u32 = 1 << 7;
-pub const DPC_CLR_CMD_CTR: u32 = 1 << 8;
-pub const DPC_CLR_CLOCK_CTR: u32 = 1 << 9;
+const DPC_CLR_XBUS_DMEM_DMA: u32 = 1 << 0;
+const DPC_SET_XBUS_DMEM_DMA: u32 = 1 << 1;
+const DPC_CLR_FREEZE: u32 = 1 << 2;
+const DPC_SET_FREEZE: u32 = 1 << 3;
+const DPC_CLR_FLUSH: u32 = 1 << 4;
+const DPC_SET_FLUSH: u32 = 1 << 5;
+const DPC_CLR_TMEM_CTR: u32 = 1 << 6;
+const DPC_CLR_PIPE_CTR: u32 = 1 << 7;
+const DPC_CLR_CMD_CTR: u32 = 1 << 8;
+const DPC_CLR_CLOCK_CTR: u32 = 1 << 9;
 
 pub struct Rdp {
     pub regs_dpc: [u32; DPC_REGS_COUNT as usize],

src/device/rdram.rs

@@ -57,10 +57,11 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
 
 pub fn read_regs(
     _device: &mut device::Device,
-    _address: u64,
+    address: u64,
     _access_size: device::memory::AccessSize,
 ) -> u32 {
-    panic!("rdram read reg");
+    println!("Warning: read from RDRAM reg {:#x}", address);
+    0
 }
 
 pub fn write_regs(_device: &mut device::Device, _address: u64, _value: u32, _mask: u32) {

src/device/ri.rs

@@ -1,13 +1,13 @@
 use crate::device;
 
-//pub const RI_MODE_REG: u32 = 0;
-//pub const RI_CONFIG_REG: u32 = 1;
-//pub const RI_CURRENT_LOAD_REG: u32 = 2;
-pub const RI_SELECT_REG: u32 = 3;
-//pub const RI_REFRESH_REG: u32 = 4;
-//pub const RI_LATENCY_REG: u32 = 5;
-//pub const RI_ERROR_REG: u32 = 6;
-//pub const RI_WERROR_REG: u32 = 7;
+//const RI_MODE_REG: u32 = 0;
+//const RI_CONFIG_REG: u32 = 1;
+//const RI_CURRENT_LOAD_REG: u32 = 2;
+const RI_SELECT_REG: u32 = 3;
+//const RI_REFRESH_REG: u32 = 4;
+//const RI_LATENCY_REG: u32 = 5;
+//const RI_ERROR_REG: u32 = 6;
+//const RI_WERROR_REG: u32 = 7;
 pub const RI_REGS_COUNT: u32 = 8;
 
 pub struct Ri {

src/device/rsp_cpu.rs

@@ -1,4 +1,9 @@
+#[cfg(target_arch = "aarch64")]
+use device::__m128i;
+#[cfg(target_arch = "aarch64")]
+include!(concat!(env!("OUT_DIR"), "/simd_bindings.rs"));
 use crate::device;
+#[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
 
 pub struct BranchState {
@@ -33,14 +38,14 @@ pub struct Cpu {
     pub vpr: [u128; 32],
     pub reciprocals: [u16; 512],
     pub inverse_square_roots: [u16; 512],
-    pub vcol: std::arch::x86_64::__m128i,
-    pub vcoh: std::arch::x86_64::__m128i,
-    pub vccl: std::arch::x86_64::__m128i,
-    pub vcch: std::arch::x86_64::__m128i,
-    pub vce: std::arch::x86_64::__m128i,
-    pub accl: std::arch::x86_64::__m128i,
-    pub accm: std::arch::x86_64::__m128i,
-    pub acch: std::arch::x86_64::__m128i,
+    pub vcol: __m128i,
+    pub vcoh: __m128i,
+    pub vccl: __m128i,
+    pub vcch: __m128i,
+    pub vce: __m128i,
+    pub accl: __m128i,
+    pub accm: __m128i,
+    pub acch: __m128i,
     pub divdp: bool,
     pub divin: i16,
     pub divout: i16,

src/device/rsp_interface.rs

@@ -1,64 +1,64 @@
 use crate::device;
 
-pub const SP_MEM_ADDR_REG: u32 = 0;
-pub const SP_DRAM_ADDR_REG: u32 = 1;
-pub const SP_RD_LEN_REG: u32 = 2;
-pub const SP_WR_LEN_REG: u32 = 3;
+const SP_MEM_ADDR_REG: u32 = 0;
+const SP_DRAM_ADDR_REG: u32 = 1;
+const SP_RD_LEN_REG: u32 = 2;
+const SP_WR_LEN_REG: u32 = 3;
 pub const SP_STATUS_REG: u32 = 4;
-pub const SP_DMA_FULL_REG: u32 = 5;
-pub const SP_DMA_BUSY_REG: u32 = 6;
-pub const SP_SEMAPHORE_REG: u32 = 7;
+const SP_DMA_FULL_REG: u32 = 5;
+const SP_DMA_BUSY_REG: u32 = 6;
+const SP_SEMAPHORE_REG: u32 = 7;
 pub const SP_REGS_COUNT: u32 = 8;
 
 pub const SP_PC_REG: u32 = 0;
-//pub const SP_IBIST_REG: u32 = 1;
+//const SP_IBIST_REG: u32 = 1;
 pub const SP_REGS2_COUNT: u32 = 2;
 
 /* SP_STATUS - read */
 pub const SP_STATUS_HALT: u32 = 1 << 0;
-pub const SP_STATUS_BROKE: u32 = 1 << 1;
-pub const SP_STATUS_DMA_BUSY: u32 = 1 << 2;
-pub const SP_STATUS_DMA_FULL: u32 = 1 << 3;
-//pub const SP_STATUS_IO_FULL: u32 = 1 << 4;
-pub const SP_STATUS_SSTEP: u32 = 1 << 5;
-pub const SP_STATUS_INTR_BREAK: u32 = 1 << 6;
-pub const SP_STATUS_SIG0: u32 = 1 << 7;
-pub const SP_STATUS_SIG1: u32 = 1 << 8;
-pub const SP_STATUS_SIG2: u32 = 1 << 9;
-pub const SP_STATUS_SIG3: u32 = 1 << 10;
-pub const SP_STATUS_SIG4: u32 = 1 << 11;
-pub const SP_STATUS_SIG5: u32 = 1 << 12;
-pub const SP_STATUS_SIG6: u32 = 1 << 13;
-pub const SP_STATUS_SIG7: u32 = 1 << 14;
+const SP_STATUS_BROKE: u32 = 1 << 1;
+const SP_STATUS_DMA_BUSY: u32 = 1 << 2;
+const SP_STATUS_DMA_FULL: u32 = 1 << 3;
+//const SP_STATUS_IO_FULL: u32 = 1 << 4;
+const SP_STATUS_SSTEP: u32 = 1 << 5;
+const SP_STATUS_INTR_BREAK: u32 = 1 << 6;
+const SP_STATUS_SIG0: u32 = 1 << 7;
+const SP_STATUS_SIG1: u32 = 1 << 8;
+const SP_STATUS_SIG2: u32 = 1 << 9;
+const SP_STATUS_SIG3: u32 = 1 << 10;
+const SP_STATUS_SIG4: u32 = 1 << 11;
+const SP_STATUS_SIG5: u32 = 1 << 12;
+const SP_STATUS_SIG6: u32 = 1 << 13;
+const SP_STATUS_SIG7: u32 = 1 << 14;
 
 /* SP_STATUS - write */
-pub const SP_CLR_HALT: u32 = 1 << 0;
+const SP_CLR_HALT: u32 = 1 << 0;
 pub const SP_SET_HALT: u32 = 1 << 1;
-pub const SP_CLR_BROKE: u32 = 1 << 2;
-pub const SP_CLR_INTR: u32 = 1 << 3;
-pub const SP_SET_INTR: u32 = 1 << 4;
-pub const SP_CLR_SSTEP: u32 = 1 << 5;
-pub const SP_SET_SSTEP: u32 = 1 << 6;
-pub const SP_CLR_INTR_BREAK: u32 = 1 << 7;
-pub const SP_SET_INTR_BREAK: u32 = 1 << 8;
-pub const SP_CLR_SIG0: u32 = 1 << 9;
-pub const SP_SET_SIG0: u32 = 1 << 10;
-pub const SP_CLR_SIG1: u32 = 1 << 11;
-pub const SP_SET_SIG1: u32 = 1 << 12;
-pub const SP_CLR_SIG2: u32 = 1 << 13;
-pub const SP_SET_SIG2: u32 = 1 << 14;
-pub const SP_CLR_SIG3: u32 = 1 << 15;
-pub const SP_SET_SIG3: u32 = 1 << 16;
-pub const SP_CLR_SIG4: u32 = 1 << 17;
-pub const SP_SET_SIG4: u32 = 1 << 18;
-pub const SP_CLR_SIG5: u32 = 1 << 19;
-pub const SP_SET_SIG5: u32 = 1 << 20;
-pub const SP_CLR_SIG6: u32 = 1 << 21;
-pub const SP_SET_SIG6: u32 = 1 << 22;
-pub const SP_CLR_SIG7: u32 = 1 << 23;
-pub const SP_SET_SIG7: u32 = 1 << 24;
+const SP_CLR_BROKE: u32 = 1 << 2;
+const SP_CLR_INTR: u32 = 1 << 3;
+const SP_SET_INTR: u32 = 1 << 4;
+const SP_CLR_SSTEP: u32 = 1 << 5;
+const SP_SET_SSTEP: u32 = 1 << 6;
+const SP_CLR_INTR_BREAK: u32 = 1 << 7;
+const SP_SET_INTR_BREAK: u32 = 1 << 8;
+const SP_CLR_SIG0: u32 = 1 << 9;
+const SP_SET_SIG0: u32 = 1 << 10;
+const SP_CLR_SIG1: u32 = 1 << 11;
+const SP_SET_SIG1: u32 = 1 << 12;
+const SP_CLR_SIG2: u32 = 1 << 13;
+const SP_SET_SIG2: u32 = 1 << 14;
+const SP_CLR_SIG3: u32 = 1 << 15;
+const SP_SET_SIG3: u32 = 1 << 16;
+const SP_CLR_SIG4: u32 = 1 << 17;
+const SP_SET_SIG4: u32 = 1 << 18;
+const SP_CLR_SIG5: u32 = 1 << 19;
+const SP_SET_SIG5: u32 = 1 << 20;
+const SP_CLR_SIG6: u32 = 1 << 21;
+const SP_SET_SIG6: u32 = 1 << 22;
+const SP_CLR_SIG7: u32 = 1 << 23;
+const SP_SET_SIG7: u32 = 1 << 24;
 
-pub const RSP_MEM_MASK: usize = 0x1FFF;
+const RSP_MEM_MASK: usize = 0x1FFF;
 
 #[derive(PartialEq, Copy, Clone)]
 pub enum DmaDir {

src/device/rsp_su_instructions.rs

@@ -1,4 +1,9 @@
+#[cfg(target_arch = "aarch64")]
+use device::__m128i;
+#[cfg(target_arch = "aarch64")]
+include!(concat!(env!("OUT_DIR"), "/simd_bindings.rs"));
 use crate::device;
+#[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
 
 pub fn rd(opcode: u32) -> u32 {
@@ -39,7 +44,7 @@ pub fn sign_extend_7bit_offset(offset: u8, shift_amount: u32) -> u32 {
     (((soffset) as i32) as u32) << shift_amount
 }
 
-pub fn modify_vpr_byte(vpr: &mut u128, value: u8, element: u8) {
+pub fn modify_vpr_byte(vpr: &mut u128, element: u8, value: u8) {
     let pos = 15 - (element & 15);
     let mask = 0xFF << (pos * 8);
     *vpr &= !mask;
@@ -51,7 +56,7 @@ pub fn get_vpr_byte(vpr: u128, element: u8) -> u8 {
     (vpr >> (pos * 8)) as u8
 }
 
-pub fn modify_vpr_element(vpr: &mut u128, value: u16, element: u8) {
+pub fn modify_vpr_element(vpr: &mut u128, element: u8, value: u16) {
     let pos = 7 - (element & 7);
     let mask = 0xFFFF << (pos * 16);
     *vpr &= !mask;
@@ -508,7 +513,7 @@ pub fn cfc2(device: &mut device::Device, opcode: u32) {
             lo = &mut device.rsp.cpu.vce;
         }
         _ => {
-            panic!("unknown ctc2")
+            panic!("unknown cfc2")
         }
     }
 
@@ -522,14 +527,14 @@ pub fn cfc2(device: &mut device::Device, opcode: u32) {
 pub fn mtc2(device: &mut device::Device, opcode: u32) {
     modify_vpr_byte(
         &mut device.rsp.cpu.vpr[rd(opcode) as usize],
-        (device.rsp.cpu.gpr[rt(opcode) as usize] >> 8) as u8,
         velement(opcode),
+        (device.rsp.cpu.gpr[rt(opcode) as usize] >> 8) as u8,
     );
     if velement(opcode) != 15 {
         modify_vpr_byte(
             &mut device.rsp.cpu.vpr[rd(opcode) as usize],
-            device.rsp.cpu.gpr[rt(opcode) as usize] as u8,
             velement(opcode) + 1,
+            device.rsp.cpu.gpr[rt(opcode) as usize] as u8,
         );
     }
 }
@@ -574,7 +579,7 @@ pub fn ctc2(device: &mut device::Device, opcode: u32) {
             ),
             _mm_setzero_si128(),
         );
-        *hi = std::arch::x86_64::_mm_cmpeq_epi8(
+        *hi = _mm_cmpeq_epi8(
             _mm_and_si128(
                 _mm_set1_epi8(!(device.rsp.cpu.gpr[rt(opcode) as usize] >> 8) as i8),
                 mask,
@@ -591,8 +596,8 @@ pub fn lbv(device: &mut device::Device, opcode: u32) {
     let element = velement(opcode);
     modify_vpr_byte(
         &mut device.rsp.cpu.vpr[rt(opcode) as usize],
-        device.rsp.mem[(address & 0xFFF) as usize],
         element,
+        device.rsp.mem[(address & 0xFFF) as usize],
     );
 }
 
@@ -605,8 +610,8 @@ pub fn lsv(device: &mut device::Device, opcode: u32) {
     while element < end {
         modify_vpr_byte(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
-            device.rsp.mem[(address & 0xFFF) as usize],
             element,
+            device.rsp.mem[(address & 0xFFF) as usize],
         );
         address += 1;
         element += 1;
@@ -622,8 +627,8 @@ pub fn llv(device: &mut device::Device, opcode: u32) {
     while element < end {
         modify_vpr_byte(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
-            device.rsp.mem[(address & 0xFFF) as usize],
             element,
+            device.rsp.mem[(address & 0xFFF) as usize],
         );
         address += 1;
         element += 1;
@@ -639,8 +644,8 @@ pub fn ldv(device: &mut device::Device, opcode: u32) {
     while element < end {
         modify_vpr_byte(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
-            device.rsp.mem[(address & 0xFFF) as usize],
             element,
+            device.rsp.mem[(address & 0xFFF) as usize],
         );
         address += 1;
         element += 1;
@@ -656,8 +661,8 @@ pub fn lqv(device: &mut device::Device, opcode: u32) {
     while element < end {
         modify_vpr_byte(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
-            device.rsp.mem[(address & 0xFFF) as usize],
             element,
+            device.rsp.mem[(address & 0xFFF) as usize],
         );
         address += 1;
         element += 1;
@@ -673,8 +678,8 @@ pub fn lrv(device: &mut device::Device, opcode: u32) {
     while element < 16 {
         modify_vpr_byte(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
-            device.rsp.mem[(address & 0xFFF) as usize],
             element,
+            device.rsp.mem[(address & 0xFFF) as usize],
         );
         address += 1;
         element += 1;
@@ -687,16 +692,14 @@ pub fn lpv(device: &mut device::Device, opcode: u32) {
 
     let index = ((address & 7) as u8).wrapping_sub(velement(opcode));
     address &= !7;
-    let mut offset: u8 = 0;
-    while offset < 8 {
+    for offset in 0..8 {
         modify_vpr_element(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
+            offset,
             (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(offset)) & 15) as u32))
                 & 0xFFF) as usize] as u16)
                 << 8,
-            offset,
         );
-        offset += 1;
     }
 }
 
@@ -706,16 +709,14 @@ pub fn luv(device: &mut device::Device, opcode: u32) {
 
     let index = ((address & 7) as u8).wrapping_sub(velement(opcode));
     address &= !7;
-    let mut offset: u8 = 0;
-    while offset < 8 {
+    for offset in 0..8 {
         modify_vpr_element(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
+            offset,
             (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(offset)) & 15) as u32))
                 & 0xFFF) as usize] as u16)
                 << 7,
-            offset,
         );
-        offset += 1;
     }
 }
 
@@ -725,16 +726,14 @@ pub fn lhv(device: &mut device::Device, opcode: u32) {
 
     let index = ((address & 7) as u8).wrapping_sub(velement(opcode));
     address &= !7;
-    let mut offset: u8 = 0;
-    while offset < 8 {
+    for offset in 0..8 {
         modify_vpr_element(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
+            offset,
             (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(offset * 2)) & 15) as u32))
                 & 0xFFF) as usize] as u16)
                 << 7,
-            offset,
         );
-        offset += 1;
     }
 }
 
@@ -751,25 +750,25 @@ pub fn lfv(device: &mut device::Device, opcode: u32) {
     while offset < 4 {
         modify_vpr_element(
             &mut tmp,
+            offset,
             (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(offset * 4)) & 15) as u32))
                 & 0xFFF) as usize] as u16)
                 << 7,
-            offset,
         );
         modify_vpr_element(
             &mut tmp,
+            offset + 4,
             (device.rsp.mem[((address
                 .wrapping_add(((index.wrapping_add(offset * 4).wrapping_add(8)) & 15) as u32))
                 & 0xFFF) as usize] as u16)
                 << 7,
-            offset + 4,
         );
         offset += 1;
     }
     offset = start;
     while offset < end {
         let value = get_vpr_byte(tmp, offset);
-        modify_vpr_byte(&mut device.rsp.cpu.vpr[rt(opcode) as usize], value, offset);
+        modify_vpr_byte(&mut device.rsp.cpu.vpr[rt(opcode) as usize], offset, value);
         offset += 1;
     }
 }
@@ -784,12 +783,11 @@ pub fn ltv(device: &mut device::Device, opcode: u32) {
     address = begin + (((velement(opcode)) as u32 + (address & 8)) & 15);
     let vtbase = rt(opcode) & !7;
     let mut vtoff = (velement(opcode)) as u32 >> 1;
-    let mut i = 0;
-    while i < 8 {
+    for i in 0..8 {
         modify_vpr_byte(
             &mut device.rsp.cpu.vpr[(vtbase + vtoff) as usize],
-            device.rsp.mem[(address & 0xFFF) as usize],
             i * 2,
+            device.rsp.mem[(address & 0xFFF) as usize],
         );
         address += 1;
         if address == begin + 16 {
@@ -797,15 +795,14 @@ pub fn ltv(device: &mut device::Device, opcode: u32) {
         }
         modify_vpr_byte(
             &mut device.rsp.cpu.vpr[(vtbase + vtoff) as usize],
-            device.rsp.mem[(address & 0xFFF) as usize],
             i * 2 + 1,
+            device.rsp.mem[(address & 0xFFF) as usize],
         );
         address += 1;
         if address == begin + 16 {
             address = begin
         }
         vtoff = (vtoff + 1) & 7;
-        i += 1;
     }
 }
 
@@ -934,13 +931,11 @@ pub fn shv(device: &mut device::Device, opcode: u32) {
     let element = velement(opcode);
     let index = (address & 7) as u8;
     address &= !7;
-    let mut offset = 0;
-    while offset < 8 {
+    for offset in 0..8 {
         let byte_val = element + offset * 2;
         let value = (get_vpr_byte(device.rsp.cpu.vpr[rt(opcode) as usize], byte_val) << 1)
             | (get_vpr_byte(device.rsp.cpu.vpr[rt(opcode) as usize], byte_val + 1) >> 7);
         device.rsp.mem[((address + ((index + offset * 2) & 15) as u32) & 0xFFF) as usize] = value;
-        offset += 1;
     }
 }
 
@@ -949,8 +944,7 @@ pub fn sfv(device: &mut device::Device, opcode: u32) {
         .wrapping_add(sign_extend_7bit_offset(voffset(opcode), 4));
     let base = address & 7;
     address &= !7;
-    let element = velement(opcode);
-    let elements = match element {
+    let elements = match velement(opcode) {
         0 | 15 => [0, 1, 2, 3],
         1 => [6, 7, 4, 5],
         4 => [1, 2, 3, 0],
@@ -967,12 +961,10 @@ pub fn sfv(device: &mut device::Device, opcode: u32) {
         }
     };
     let mut offset = 0;
-    let mut i = 0;
-    while i < 4 {
+    for element in elements {
         device.rsp.mem[((address + ((base + offset) & 15)) & 0xFFF) as usize] =
-            (get_vpr_element(device.rsp.cpu.vpr[rt(opcode) as usize], elements[i]) >> 7) as u8;
+            (get_vpr_element(device.rsp.cpu.vpr[rt(opcode) as usize], element) >> 7) as u8;
         offset += 4;
-        i += 1;
     }
 }
 

src/device/si.rs

@@ -1,18 +1,18 @@
 use crate::device;
 
-pub const SI_DRAM_ADDR_REG: u32 = 0;
-pub const SI_PIF_ADDR_RD64B_REG: u32 = 1;
-//pub const SI_R2_REG: u32 = 2;
-//pub const SI_R3_REG: u32 = 3;
-pub const SI_PIF_ADDR_WR64B_REG: u32 = 4;
-//pub const SI_R5_REG: u32 = 5;
+const SI_DRAM_ADDR_REG: u32 = 0;
+const SI_PIF_ADDR_RD64B_REG: u32 = 1;
+//const SI_R2_REG: u32 = 2;
+//const SI_R3_REG: u32 = 3;
+const SI_PIF_ADDR_WR64B_REG: u32 = 4;
+//const SI_R5_REG: u32 = 5;
 pub const SI_STATUS_REG: u32 = 6;
 pub const SI_REGS_COUNT: u32 = 7;
 
 pub const SI_STATUS_DMA_BUSY: u32 = 1 << 0;
 pub const SI_STATUS_IO_BUSY: u32 = 1 << 1;
-//pub const SI_STATUS_DMA_ERROR: u32 = 1 << 3;
-pub const SI_STATUS_INTERRUPT: u32 = 1 << 12;
+//const SI_STATUS_DMA_ERROR: u32 = 1 << 3;
+const SI_STATUS_INTERRUPT: u32 = 1 << 12;
 
 #[derive(PartialEq)]
 pub enum DmaDir {
@@ -59,7 +59,7 @@ pub fn dma_write(device: &mut device::Device) {
     device::events::create_event(
         device,
         device::events::EventType::SI,
-        device.cpu.cop0.regs[device::cop0::COP0_COUNT_REG as usize] + 5200, //based on https://github.com/rasky/n64-systembench
+        device.cpu.cop0.regs[device::cop0::COP0_COUNT_REG as usize] + 6000, //based on https://github.com/rasky/n64-systembench
         dma_event,
     )
 }

src/device/sram.rs

@@ -1,13 +1,13 @@
 use crate::device;
 use crate::ui;
 
-pub const SRAM_MASK: usize = 0xFFFF;
-pub const SRAM_SIZE: usize = 0x8000;
-pub const FLASHRAM_SIZE: usize = 0x20000;
+const SRAM_MASK: usize = 0xFFFF;
+const SRAM_SIZE: usize = 0x8000;
+const FLASHRAM_SIZE: usize = 0x20000;
 pub const FLASHRAM_TYPE_ID: u32 = 0x11118001;
 pub const MX29L1100_ID: u32 = 0x00c2001e;
-pub const MX29L0000_ID: u32 = 0x00c20000;
-pub const MX29L0001_ID: u32 = 0x00c20001;
+const MX29L0000_ID: u32 = 0x00c20000;
+const MX29L0001_ID: u32 = 0x00c20001;
 
 #[derive(PartialEq)]
 pub enum FlashramMode {

src/device/vi.rs

@@ -2,18 +2,18 @@ use crate::device;
 use crate::ui;
 use governor::clock::Clock;
 
-pub const VI_STATUS_REG: u32 = 0;
-//pub const VI_ORIGIN_REG: u32 = 1;
+const VI_STATUS_REG: u32 = 0;
+//const VI_ORIGIN_REG: u32 = 1;
 pub const VI_WIDTH_REG: u32 = 2;
-//pub const VI_V_INTR_REG: u32 = 3;
-pub const VI_CURRENT_REG: u32 = 4;
-//pub const VI_BURST_REG: u32 = 5;
-pub const VI_V_SYNC_REG: u32 = 6;
-pub const VI_H_SYNC_REG: u32 = 7;
-//pub const VI_LEAP_REG: u32 = 8;
+//const VI_V_INTR_REG: u32 = 3;
+const VI_CURRENT_REG: u32 = 4;
+//const VI_BURST_REG: u32 = 5;
+const VI_V_SYNC_REG: u32 = 6;
+const VI_H_SYNC_REG: u32 = 7;
+//const VI_LEAP_REG: u32 = 8;
 pub const VI_H_START_REG: u32 = 9;
 pub const VI_V_START_REG: u32 = 10;
-//pub const VI_V_BURST_REG: u32 = 11;
+//const VI_V_BURST_REG: u32 = 11;
 pub const VI_X_SCALE_REG: u32 = 12;
 pub const VI_Y_SCALE_REG: u32 = 13;
 pub const VI_REGS_COUNT: u32 = 14;
@@ -169,6 +169,6 @@ pub fn speed_limiter(device: &device::Device) {
         let dur = outcome.wait_time_from(governor::clock::DefaultClock::default().now());
         spin_sleep::sleep(dur);
 
-        device.vi.limiter.as_ref().unwrap().check().unwrap();
+        let _ = device.vi.limiter.as_ref().unwrap().check();
     }
 }

src/main.rs

@@ -54,18 +54,47 @@ struct Args {
 }
 
 fn main() {
-    let config_dir = dirs::config_dir().unwrap().join("gopher64");
-    let cache_dir = dirs::cache_dir().unwrap().join("gopher64");
+    let exe_path = std::env::current_exe().unwrap();
+    let portable_dir = exe_path.parent();
+    let portable = portable_dir.unwrap().join("portable.txt").exists();
+    let config_dir;
+    let cache_dir;
+    let data_dir;
+    if portable {
+        config_dir = portable_dir.unwrap().join("portable_data").join("config");
+        cache_dir = portable_dir.unwrap().join("portable_data").join("cache");
+        data_dir = portable_dir.unwrap().join("portable_data").join("data");
+    } else {
+        config_dir = dirs::config_dir().unwrap().join("gopher64");
+        cache_dir = dirs::cache_dir().unwrap().join("gopher64");
+        data_dir = dirs::data_dir().unwrap().join("gopher64");
+    };
 
-    let _ = std::fs::create_dir_all(config_dir.clone());
-    let _ = std::fs::create_dir_all(cache_dir.clone());
-    let _ = std::fs::remove_file(cache_dir.clone().join("game_running"));
+    let mut result = std::fs::create_dir_all(config_dir.clone());
+    if result.is_err() {
+        panic!("could not create config dir: {}", result.err().unwrap())
+    }
+    result = std::fs::create_dir_all(cache_dir.clone());
+    if result.is_err() {
+        panic!("could not create cache dir: {}", result.err().unwrap())
+    }
+    result = std::fs::create_dir_all(data_dir.clone().join("saves"));
+    if result.is_err() {
+        panic!("could not create data dir: {}", result.err().unwrap())
+    }
+    let running_file = cache_dir.join("game_running");
+    if running_file.exists() {
+        result = std::fs::remove_file(running_file);
+        if result.is_err() {
+            panic!("could not remove running file: {}", result.err().unwrap())
+        }
+    }
 
     let args = Args::parse();
     let args_as_strings: Vec<String> = std::env::args().collect();
     let args_count = args_as_strings.len();
     if args_count > 1 {
-        let mut device = device::Device::new();
+        let mut device = device::Device::new(config_dir);
 
         if args.clear_input_bindings {
             ui::input::clear_bindings(&mut device.ui);
@@ -116,7 +145,7 @@ fn main() {
 
         if args.game.is_some() {
             let file_path = std::path::Path::new(args.game.as_ref().unwrap());
-            device::run_game(file_path, &mut device, args.fullscreen);
+            device::run_game(file_path, data_dir, &mut device, args.fullscreen);
         }
     } else {
         let options = eframe::NativeOptions {
@@ -126,7 +155,11 @@ fn main() {
         eframe::run_native(
             "gopher64",
             options,
-            Box::new(|_cc| Ok(Box::new(ui::gui::GopherEguiApp::new()))),
+            Box::new(|cc| {
+                Ok(Box::new(ui::gui::GopherEguiApp::new(
+                    cc, config_dir, cache_dir, data_dir,
+                )))
+            }),
         )
         .unwrap();
     }

src/ui.rs

@@ -4,6 +4,7 @@ pub mod gui;
 pub mod input;
 pub mod storage;
 pub mod video;
+pub mod vru;
 
 pub struct Ui {
     pub controllers: [input::Controllers; 4],
@@ -36,17 +37,14 @@ fn write_config(ui: &Ui) {
 }
 
 impl Ui {
-    pub fn new() -> Ui {
+    pub fn new(config_dir: std::path::PathBuf) -> Ui {
         let sdl_context = sdl2::init().unwrap();
         let video_subsystem = sdl_context.video().unwrap();
         let audio_subsystem = sdl_context.audio().unwrap();
         let joystick_subsystem = sdl_context.joystick().unwrap();
         let controller_subsystem = sdl_context.game_controller().unwrap();
 
-        let config_file_path = dirs::config_dir()
-            .unwrap()
-            .join("gopher64")
-            .join("config.json");
+        let config_file_path = config_dir.join("config.json");
         let config_file = std::fs::read(config_file_path.clone());
         let mut config_map = config::Config::new();
         if config_file.is_ok() {

src/ui/config.rs

@@ -15,10 +15,17 @@ pub struct Input {
     pub input_profiles: std::collections::HashMap<String, InputProfile>,
     pub input_profile_binding: [String; 4],
     pub controller_assignment: [Option<String>; 4],
+    pub controller_enabled: [bool; 4],
+    pub emulate_vru: bool,
+}
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct Video {
+    pub upscale: bool,
 }
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct Config {
     pub input: Input,
+    pub video: Video,
 }
 
 impl Config {
@@ -35,7 +42,10 @@ impl Config {
                 ],
                 controller_assignment: [None, None, None, None],
                 input_profiles,
+                controller_enabled: [true, false, false, false],
+                emulate_vru: false,
             },
+            video: Video { upscale: false },
         }
     }
 }

src/ui/gui.rs

@@ -3,12 +3,22 @@ use crate::ui;
 use eframe::egui;
 
 pub struct GopherEguiApp {
+    config_dir: std::path::PathBuf,
+    cache_dir: std::path::PathBuf,
+    data_dir: std::path::PathBuf,
     configure_profile: bool,
     profile_name: String,
     controllers: Vec<String>,
     selected_controller: [i32; 4],
     selected_profile: [String; 4],
     input_profiles: Vec<String>,
+    controller_enabled: [bool; 4],
+    upscale: bool,
+    emulate_vru: bool,
+    show_vru_dialog: bool,
+    vru_window_receiver: Option<std::sync::mpsc::Receiver<Vec<String>>>,
+    vru_word_notifier: Option<std::sync::mpsc::Sender<String>>,
+    vru_word_list: Vec<String>,
 }
 
 fn get_input_profiles(game_ui: &ui::Ui) -> Vec<String> {
@@ -31,8 +41,14 @@ fn get_controllers(game_ui: &ui::Ui) -> Vec<String> {
 }
 
 impl GopherEguiApp {
-    pub fn new() -> GopherEguiApp {
-        let game_ui = ui::Ui::new();
+    pub fn new(
+        cc: &eframe::CreationContext<'_>,
+        config_dir: std::path::PathBuf,
+        cache_dir: std::path::PathBuf,
+        data_dir: std::path::PathBuf,
+    ) -> GopherEguiApp {
+        add_japanese_font(&cc.egui_ctx);
+        let game_ui = ui::Ui::new(config_dir.clone());
         let joystick_subsystem = game_ui.joystick_subsystem.as_ref().unwrap();
         let num_joysticks = joystick_subsystem.num_joysticks().unwrap();
         let mut guids: Vec<String> = vec![];
@@ -57,17 +73,34 @@ impl GopherEguiApp {
             }
         }
         GopherEguiApp {
+            cache_dir: cache_dir.clone(),
+            config_dir: config_dir.clone(),
+            data_dir: data_dir.clone(),
             configure_profile: false,
             profile_name: "".to_string(),
             selected_profile: game_ui.config.input.input_profile_binding.clone(),
             selected_controller,
             controllers: get_controllers(&game_ui),
             input_profiles: get_input_profiles(&game_ui),
+            controller_enabled: game_ui.config.input.controller_enabled,
+            upscale: game_ui.config.video.upscale,
+            emulate_vru: game_ui.config.input.emulate_vru,
+            show_vru_dialog: false,
+            vru_window_receiver: None,
+            vru_word_notifier: None,
+            vru_word_list: Vec::new(),
         }
     }
 }
 
-fn save_config(game_ui: &mut ui::Ui, selected_controller: [i32; 4], selected_profile: [String; 4]) {
+fn save_config(
+    game_ui: &mut ui::Ui,
+    selected_controller: [i32; 4],
+    selected_profile: [String; 4],
+    controller_enabled: [bool; 4],
+    upscale: bool,
+    emulate_vru: bool,
+) {
     let joystick_subsystem = game_ui.joystick_subsystem.as_ref().unwrap();
     for (pos, item) in selected_controller.iter().enumerate() {
         if *item != -1 {
@@ -83,15 +116,22 @@ fn save_config(game_ui: &mut ui::Ui, selected_controller: [i32; 4], selected_pro
     }
 
     game_ui.config.input.input_profile_binding = selected_profile;
+    game_ui.config.input.controller_enabled = controller_enabled;
+
+    game_ui.config.video.upscale = upscale;
+    game_ui.config.input.emulate_vru = emulate_vru;
 }
 
 impl Drop for GopherEguiApp {
     fn drop(&mut self) {
-        let mut game_ui = ui::Ui::new();
+        let mut game_ui = ui::Ui::new(self.config_dir.clone());
         save_config(
             &mut game_ui,
             self.selected_controller,
             self.selected_profile.clone(),
+            self.controller_enabled,
+            self.upscale,
+            self.emulate_vru,
         );
     }
 }
@@ -110,8 +150,9 @@ impl eframe::App for GopherEguiApp {
                     ui.horizontal(|ui| {
                         if ui.button("Configure Profile").clicked() {
                             let profile_name = self.profile_name.clone();
+                            let config_dir = self.config_dir.clone();
                             execute(async {
-                                let mut game_ui = ui::Ui::new();
+                                let mut game_ui = ui::Ui::new(config_dir);
                                 ui::input::configure_input_profile(&mut game_ui, profile_name);
                             });
                             self.configure_profile = false;
@@ -138,32 +179,71 @@ impl eframe::App for GopherEguiApp {
                 let task = rfd::AsyncFileDialog::new().pick_file();
                 let selected_controller = self.selected_controller;
                 let selected_profile = self.selected_profile.clone();
+                let controller_enabled = self.controller_enabled;
+                let upscale = self.upscale;
+                let emulate_vru = self.emulate_vru;
+                let config_dir = self.config_dir.clone();
+                let cache_dir = self.cache_dir.clone();
+                let data_dir = self.data_dir.clone();
+
+                let (vru_window_notifier, vru_window_receiver): (
+                    std::sync::mpsc::Sender<Vec<String>>,
+                    std::sync::mpsc::Receiver<Vec<String>>,
+                ) = std::sync::mpsc::channel();
+
+                let (vru_word_notifier, vru_word_receiver): (
+                    std::sync::mpsc::Sender<String>,
+                    std::sync::mpsc::Receiver<String>,
+                ) = std::sync::mpsc::channel();
+
+                if emulate_vru {
+                    self.vru_window_receiver = Some(vru_window_receiver);
+                    self.vru_word_notifier = Some(vru_word_notifier);
+                }
+
+                let gui_ctx = ctx.clone();
                 execute(async move {
                     let file = task.await;
 
                     if let Some(file) = file {
-                        let running_file = dirs::cache_dir()
-                            .unwrap()
-                            .join("gopher64")
-                            .join("game_running");
+                        let running_file = cache_dir.join("game_running");
                         if running_file.exists() {
                             return;
                         }
-                        let _ = std::fs::File::create(running_file.clone());
-                        let mut device = device::Device::new();
-                        save_config(&mut device.ui, selected_controller, selected_profile);
-                        device::run_game(std::path::Path::new(file.path()), &mut device, false);
-                        let _ = std::fs::remove_file(running_file.clone());
+                        let result = std::fs::File::create(running_file.clone());
+                        if result.is_err() {
+                            panic!("could not create running file: {}", result.err().unwrap())
+                        }
+                        let mut device = device::Device::new(config_dir);
+                        save_config(
+                            &mut device.ui,
+                            selected_controller,
+                            selected_profile,
+                            controller_enabled,
+                            upscale,
+                            emulate_vru,
+                        );
+                        if emulate_vru {
+                            device.vru.window_notifier = Some(vru_window_notifier);
+                            device.vru.word_receiver = Some(vru_word_receiver);
+                            device.vru.gui_ctx = Some(gui_ctx);
+                        }
+                        device::run_game(
+                            std::path::Path::new(file.path()),
+                            data_dir,
+                            &mut device,
+                            false,
+                        );
+                        let result = std::fs::remove_file(running_file.clone());
+                        if result.is_err() {
+                            panic!("could not remove running file: {}", result.err().unwrap())
+                        }
                     }
                 });
             }
 
             if ui.button("Configure Input Profile").clicked() {
-                let running_file = dirs::cache_dir()
-                    .unwrap()
-                    .join("gopher64")
-                    .join("game_running");
-                if running_file.exists() {
+                if self.cache_dir.join("game_running").exists() {
                     return;
                 }
                 self.configure_profile = true;
@@ -171,13 +251,15 @@ impl eframe::App for GopherEguiApp {
 
             ui.add_space(32.0);
             ui.label("Controller Config:");
-            egui::Grid::new("some_unique_id").show(ui, |ui| {
+            egui::Grid::new("controller_config").show(ui, |ui| {
                 ui.label("Port");
+                ui.label("Enabled");
                 ui.label("Profile");
                 ui.label("Controller");
                 ui.end_row();
                 for i in 0..4 {
                     ui.label(format!("{}", i + 1));
+                    ui.checkbox(&mut self.controller_enabled[i], "");
 
                     egui::ComboBox::from_id_salt(format!("profile-combo-{}", i))
                         .selected_text(self.selected_profile[i].clone())
@@ -216,11 +298,83 @@ impl eframe::App for GopherEguiApp {
                 }
             });
             ui.add_space(32.0);
+            ui.checkbox(&mut self.upscale, "High-Res Graphics");
+            ui.checkbox(
+                &mut self.emulate_vru,
+                "Emulate VRU (connects VRU to controller port 4)",
+            );
+            ui.add_space(32.0);
             ui.label(format!("Version: {}", env!("CARGO_PKG_VERSION")));
         });
+
+        if self.emulate_vru && self.vru_window_receiver.is_some() {
+            let result = self.vru_window_receiver.as_ref().unwrap().try_recv();
+            if result.is_ok() {
+                self.show_vru_dialog = true;
+                self.vru_word_list = result.unwrap();
+            }
+        }
+
+        if self.show_vru_dialog {
+            ctx.show_viewport_immediate(
+                egui::ViewportId::from_hash_of("vru_dialog"),
+                egui::ViewportBuilder::default()
+                    .with_title("What would you like to say?")
+                    .with_always_on_top(),
+                |ctx, class| {
+                    assert!(
+                        class == egui::ViewportClass::Immediate,
+                        "This egui backend doesn't support multiple viewports"
+                    );
+                    egui::CentralPanel::default().show(ctx, |ui| {
+                        egui::Grid::new("vru_words").show(ui, |ui| {
+                            for (i, v) in self.vru_word_list.iter().enumerate() {
+                                if i % 5 == 0 {
+                                    ui.end_row();
+                                }
+                                if ui.button((*v).to_string()).clicked() {
+                                    self.vru_word_notifier
+                                        .as_ref()
+                                        .unwrap()
+                                        .send(v.clone())
+                                        .unwrap();
+                                    self.show_vru_dialog = false;
+                                }
+                            }
+                        });
+                    });
+
+                    if ctx.input(|i| i.viewport().close_requested()) {
+                        self.vru_word_notifier
+                            .as_ref()
+                            .unwrap()
+                            .send(String::from(""))
+                            .unwrap();
+                        self.show_vru_dialog = false;
+                    }
+                },
+            );
+        }
     }
 }
 
 fn execute<F: std::future::Future<Output = ()> + Send + 'static>(f: F) {
     std::thread::spawn(move || futures::executor::block_on(f));
 }
+
+fn add_japanese_font(ctx: &egui::Context) {
+    ctx.add_font(eframe::epaint::text::FontInsert::new(
+        "japanese_font",
+        egui::FontData::from_static(include_bytes!("../../data/NotoSansJP-Regular.ttf")),
+        vec![
+            eframe::epaint::text::InsertFontFamily {
+                family: egui::FontFamily::Proportional,
+                priority: egui::epaint::text::FontPriority::Lowest,
+            },
+            eframe::epaint::text::InsertFontFamily {
+                family: egui::FontFamily::Monospace,
+                priority: egui::epaint::text::FontPriority::Lowest,
+            },
+        ],
+    ));
+}

src/ui/input.rs

@@ -2,29 +2,29 @@ use std::ops::Neg;
 
 use crate::ui;
 
-pub const R_DPAD: usize = 0;
-pub const L_DPAD: usize = 1;
-pub const D_DPAD: usize = 2;
-pub const U_DPAD: usize = 3;
-pub const START_BUTTON: usize = 4;
-pub const Z_TRIG: usize = 5;
-pub const B_BUTTON: usize = 6;
-pub const A_BUTTON: usize = 7;
-pub const R_CBUTTON: usize = 8;
-pub const L_CBUTTON: usize = 9;
-pub const D_CBUTTON: usize = 10;
-pub const U_CBUTTON: usize = 11;
-pub const R_TRIG: usize = 12;
-pub const L_TRIG: usize = 13;
-pub const X_AXIS: usize = 16;
-pub const Y_AXIS: usize = 24;
+const R_DPAD: usize = 0;
+const L_DPAD: usize = 1;
+const D_DPAD: usize = 2;
+const U_DPAD: usize = 3;
+const START_BUTTON: usize = 4;
+const Z_TRIG: usize = 5;
+const B_BUTTON: usize = 6;
+const A_BUTTON: usize = 7;
+const R_CBUTTON: usize = 8;
+const L_CBUTTON: usize = 9;
+const D_CBUTTON: usize = 10;
+const U_CBUTTON: usize = 11;
+const R_TRIG: usize = 12;
+const L_TRIG: usize = 13;
+const X_AXIS: usize = 16;
+const Y_AXIS: usize = 24;
 
-pub const AXIS_LEFT: usize = 14;
-pub const AXIS_RIGHT: usize = 15;
-pub const AXIS_UP: usize = 16;
-pub const AXIS_DOWN: usize = 17;
+const AXIS_LEFT: usize = 14;
+const AXIS_RIGHT: usize = 15;
+const AXIS_UP: usize = 16;
+const AXIS_DOWN: usize = 17;
 
-pub const MAX_AXIS_VALUE: f64 = 85.0;
+const MAX_AXIS_VALUE: f64 = 85.0;
 
 pub struct Controllers {
     pub game_controller: Option<sdl2::controller::GameController>,
@@ -541,7 +541,10 @@ pub fn init(ui: &mut ui::Ui) {
                         .unwrap()
                         .open(joystick_index);
                     if joystick_result.is_err() {
-                        println!("could not connect joystick")
+                        println!(
+                            "could not connect joystick: {}",
+                            joystick_result.err().unwrap()
+                        )
                     } else {
                         ui.controllers[i].joystick = Some(joystick_result.unwrap());
                     }

src/ui/storage.rs

@@ -86,16 +86,11 @@ pub fn get_save_type(game_id: &str) -> Vec<SaveTypes> {
     }
 }
 
-pub fn init(ui: &mut ui::Ui) {
+pub fn init(ui: &mut ui::Ui, data_dir: std::path::PathBuf) {
     let id = ui.game_id.as_str();
     ui.save_type = get_save_type(id);
 
-    let base_path = dirs::data_dir().unwrap().join("gopher64").join("saves");
-
-    let result = std::fs::create_dir_all(base_path.clone());
-    if result.is_err() {
-        panic!("could not create save dir")
-    }
+    let base_path = data_dir.join("saves");
 
     ui.paths.eep_file_path.clone_from(&base_path);
     ui.paths
@@ -148,7 +143,7 @@ pub fn load_saves(ui: &mut ui::Ui) {
 
 pub fn write_rom_save(ui: &ui::Ui) {
     let f = std::fs::File::create(ui.paths.romsave_file_path.clone()).unwrap();
-    serde_json::to_writer(f, &ui.saves.romsave).unwrap();
+    serde_json::to_writer(f, &ui.saves.romsave.0).unwrap();
 }
 
 pub fn write_saves(ui: &ui::Ui) {

src/ui/video.rs

@@ -1,30 +1,7 @@
+#![allow(non_snake_case)]
+include!(concat!(env!("OUT_DIR"), "/parallel_bindings.rs"));
 use crate::device;
 
-#[repr(C)]
-pub struct GfxInfo {
-    pub rdram: *mut u8,
-    pub dmem: *mut u8,
-    pub rdram_size: u32,
-    pub dpc_current_reg: *mut u32,
-    pub dpc_start_reg: *mut u32,
-    pub dpc_end_reg: *mut u32,
-    pub dpc_status_reg: *mut u32,
-    pub vi_h_start_reg: *mut u32,
-    pub vi_v_start_reg: *mut u32,
-    pub vi_x_scale_reg: *mut u32,
-    pub vi_y_scale_reg: *mut u32,
-    pub vi_width_reg: *mut u32,
-}
-
-unsafe extern "C" {
-    pub fn rdp_init(window: usize, gfx_info: GfxInfo, fullscreen: bool);
-    pub fn rdp_close();
-    pub fn rdp_update_screen() -> bool;
-    pub fn rdp_set_vi_register(reg: u32, value: u32);
-    pub fn rdp_process_commands() -> u64;
-    pub fn rdp_full_sync();
-}
-
 pub fn init(device: &mut device::Device, fullscreen: bool) {
     let mut builder = device
         .ui
@@ -42,26 +19,27 @@ pub fn init(device: &mut device::Device, fullscreen: bool) {
     }
     device.ui.window = Some(builder.build().unwrap());
 
-    let gfx_info = GfxInfo {
-        rdram: device.rdram.mem.as_mut_ptr(),
-        dmem: device.rsp.mem.as_mut_ptr(),
-        rdram_size: device.rdram.size,
-        dpc_current_reg: &mut device.rdp.regs_dpc[device::rdp::DPC_CURRENT_REG as usize],
-        dpc_start_reg: &mut device.rdp.regs_dpc[device::rdp::DPC_START_REG as usize],
-        dpc_end_reg: &mut device.rdp.regs_dpc[device::rdp::DPC_END_REG as usize],
-        dpc_status_reg: &mut device.rdp.regs_dpc[device::rdp::DPC_STATUS_REG as usize],
-        vi_h_start_reg: &mut device.vi.regs[device::vi::VI_H_START_REG as usize],
-        vi_v_start_reg: &mut device.vi.regs[device::vi::VI_V_START_REG as usize],
-        vi_x_scale_reg: &mut device.vi.regs[device::vi::VI_X_SCALE_REG as usize],
-        vi_y_scale_reg: &mut device.vi.regs[device::vi::VI_Y_SCALE_REG as usize],
-        vi_width_reg: &mut device.vi.regs[device::vi::VI_WIDTH_REG as usize],
+    let gfx_info = GFX_INFO {
+        RDRAM: device.rdram.mem.as_mut_ptr(),
+        DMEM: device.rsp.mem.as_mut_ptr(),
+        RDRAM_SIZE: device.rdram.size,
+        DPC_CURRENT_REG: &mut device.rdp.regs_dpc[device::rdp::DPC_CURRENT_REG as usize],
+        DPC_START_REG: &mut device.rdp.regs_dpc[device::rdp::DPC_START_REG as usize],
+        DPC_END_REG: &mut device.rdp.regs_dpc[device::rdp::DPC_END_REG as usize],
+        DPC_STATUS_REG: &mut device.rdp.regs_dpc[device::rdp::DPC_STATUS_REG as usize],
+        VI_H_START_REG: &mut device.vi.regs[device::vi::VI_H_START_REG as usize],
+        VI_V_START_REG: &mut device.vi.regs[device::vi::VI_V_START_REG as usize],
+        VI_X_SCALE_REG: &mut device.vi.regs[device::vi::VI_X_SCALE_REG as usize],
+        VI_Y_SCALE_REG: &mut device.vi.regs[device::vi::VI_Y_SCALE_REG as usize],
+        VI_WIDTH_REG: &mut device.vi.regs[device::vi::VI_WIDTH_REG as usize],
     };
 
     unsafe {
         rdp_init(
-            device.ui.window.as_mut().unwrap().raw() as usize,
+            device.ui.window.as_mut().unwrap().raw() as *mut std::ffi::c_void,
             gfx_info,
             fullscreen,
+            device.ui.config.video.upscale,
         )
     }
 }

src/ui/vru.rs

@@ -0,0 +1,28 @@
+use eframe::egui;
+
+use crate::ui;
+
+pub fn prompt_for_match(
+    words: &[String],
+    window_notifier: &std::sync::mpsc::Sender<Vec<String>>,
+    word_index_notifier: &std::sync::mpsc::Receiver<String>,
+    gui_ctx: &egui::Context,
+) -> u16 {
+    let mut dedup_words = words.to_owned();
+    dedup_words.sort();
+    dedup_words.dedup();
+    window_notifier.send(dedup_words).unwrap();
+    gui_ctx.request_repaint(); // this is so the window pops up right away
+    let mut result = word_index_notifier.try_recv();
+    while result.is_err() {
+        result = word_index_notifier.try_recv();
+        std::thread::sleep(std::time::Duration::from_secs_f64(1.0 / 60.0));
+        ui::video::update_screen(); // so the OS doesn't complain about the game window being frozen
+    }
+    for (i, v) in words.iter().enumerate() {
+        if *v == *result.as_ref().unwrap() {
+            return i as u16;
+        }
+    }
+    0x7FFF
+}