fix windows build (#636)

* clippy fixes

* fix netplay browser

.cargo/config.toml

@@ -1,4 +1,4 @@
-[target.'cfg(target_os = "linux")']
+[target.'cfg(all(target_arch = "aarch64", target_os = "linux"))']
 rustflags = ["-C", "link-arg=-fuse-ld=lld"]
 
 [target.'cfg(target_os = "windows")']

.github/workflows/build.yml

@@ -29,7 +29,7 @@ jobs:
             arch: linux-aarch64
             llvm: ARM64
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -48,7 +48,7 @@ jobs:
             libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev libxtst-dev \
             libxkbcommon-dev libdrm-dev libgbm-dev libgl1-mesa-dev libgles2-mesa-dev \
             libegl1-mesa-dev libdbus-1-dev libibus-1.0-dev libudev-dev fcitx-libs-dev \
-            libpipewire-0.3-dev libwayland-dev libdecor-0-dev liburing-dev
+            libpipewire-0.3-dev libwayland-dev libdecor-0-dev liburing-dev libfreetype-dev libfontconfig-dev
           version: ${{ matrix.target }}-1.0
       - name: Install LLVM and Clang
         uses: KyleMayes/install-llvm-action@v2
@@ -60,8 +60,10 @@ jobs:
           cargo build --release -v --target=${{ matrix.target }}
           mkdir output
           cp target/${{ matrix.target }}/release/gopher64 output/gopher64-${{ matrix.arch }}
+        env:
+          NETPLAY_ID: ${{ secrets.NETPLAY_ID }}
       - name: Upload file
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v5
         with:
           name: gopher64-${{ matrix.arch }}
           path: output/gopher64-${{ matrix.arch }}
@@ -81,7 +83,7 @@ jobs:
           #  arch: windows-aarch64
           #  llvm: woa64
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -102,15 +104,19 @@ jobs:
           cargo build --release -v --target=${{ matrix.target }}
           mkdir output
           cp target/${{ matrix.target }}/release/gopher64.exe output/gopher64-${{ matrix.arch }}.exe
+        env:
+          CC: clang-cl
+          CXX: clang-cl
+          NETPLAY_ID: ${{ secrets.NETPLAY_ID }}
       - name: Upload unsigned artifact
         id: upload-unsigned-artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v5
         with:
           name: gopher64-${{ matrix.arch }}
           path: output/gopher64-${{ matrix.arch }}.exe
       - name: SignPath
         if: ${{ github.ref_type == 'tag' }}
-        uses: signpath/github-action-submit-signing-request@v1.3
+        uses: signpath/github-action-submit-signing-request@v2.0
         with:
           api-token: "${{ secrets.SIGNPATH_API_TOKEN }}"
           organization-id: "${{ secrets.SIGNPATH_ORG_ID }}"
@@ -121,6 +127,7 @@ jobs:
           wait-for-completion: false
 
   build-macos:
+    if: false
     runs-on: macos-15
     strategy:
       fail-fast: false
@@ -131,7 +138,7 @@ jobs:
           - target: aarch64-apple-darwin
             arch: mac-aarch64
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -145,8 +152,9 @@ jobs:
           cp target/${{ matrix.target }}/release/gopher64 output/gopher64-${{ matrix.arch }}
         env:
           AR: ar
+          NETPLAY_ID: ${{ secrets.NETPLAY_ID }}
       - name: Upload file
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v5
         with:
           name: gopher64-${{ matrix.arch }}
           path: output/gopher64-${{ matrix.arch }}

.github/workflows/lint.yml

@@ -16,7 +16,7 @@ jobs:
   lint-linux:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -34,7 +34,7 @@ jobs:
             libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev libxtst-dev \
             libxkbcommon-dev libdrm-dev libgbm-dev libgl1-mesa-dev libgles2-mesa-dev \
             libegl1-mesa-dev libdbus-1-dev libibus-1.0-dev libudev-dev fcitx-libs-dev \
-            libpipewire-0.3-dev libwayland-dev libdecor-0-dev liburing-dev
+            libpipewire-0.3-dev libwayland-dev libdecor-0-dev liburing-dev libfreetype-dev libfontconfig-dev
           version: lint-1.0
       - name: Install LLVM and Clang
         uses: KyleMayes/install-llvm-action@v2

.github/workflows/sec.yml

@@ -10,7 +10,7 @@ jobs:
       checks: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: rustsec/audit-check@v2

Cargo.toml

@@ -1,32 +1,32 @@
 [package]
 name = "gopher64"
-version = "1.1.4"
+version = "1.1.11"
 edition = "2024"
-rust-version = "1.89"
+rust-version = "1.92.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 dirs = "6.0"
-zip = "4.3"
+zip = "6.0"
 governor = "0.10"
-sevenz-rust2 = { version = "0.17", default-features = false }
+sevenz-rust2 = { version = "0.20", default-features = false }
 chrono = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde-big-array = "0.5"
-slint = { version = "1.12", default-features = false, features = ["compat-1-2", "std", "backend-winit", "renderer-femtovg"] }
+slint = { version = "1.12", default-features = false, features = ["compat-1-2", "std", "backend-winit", "renderer-skia-vulkan"] }
 open = "5.3"
 sha2 = "0.10"
 sdl3-sys = { version = "0.5", features = ["build-from-source-static"] }
-sdl3-ttf-sys = { version = "0.2", features = ["build-static-vendored", "no-sdlttf-harfbuzz", "no-sdlttf-plutosvg"] }
-rfd = { version = "0.15", default-features = false, features = ["xdg-portal", "tokio"] }
+sdl3-ttf-sys = { version = "0.2", features = ["build-from-source-static", "no-sdlttf-harfbuzz", "no-sdlttf-plutosvg"] }
+rfd = { version = "0.16", default-features = false, features = ["xdg-portal", "tokio", "wayland"] }
 tokio = {version = "1.46", features = ["rt-multi-thread", "macros"] }
 spin_sleep = "1.3"
 encoding_rs = "0.8"
 mimalloc = "0.1"
 regex = "1.11"
-tokio-tungstenite = "0.27"
+tokio-tungstenite = "0.28"
 futures = "0.3"
 socket2 = { version = "0.6", features = ["all"] }
 rand_chacha = "0.9"
@@ -45,3 +45,10 @@ cc = { version = "1.2", features = ["parallel"] }
 [profile.release]
 panic = "abort"
 lto = "thin"
+strip = true
+
+[profile.release-with-debug]
+inherits = "release"
+debug = true
+strip = false
+panic = "unwind"

build.rs

@@ -40,6 +40,7 @@ fn main() {
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/pipeline_event.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/query_pool.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/render_pass.cpp")
+        .file("parallel-rdp/parallel-rdp-standalone/vulkan/rtas.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/sampler.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/semaphore.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/semaphore_manager.cpp")
@@ -54,6 +55,7 @@ fn main() {
         .file("parallel-rdp/parallel-rdp-standalone/util/timeline_trace_file.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/util/environment.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/util/thread_name.cpp")
+        .file("parallel-rdp/parallel-rdp-standalone/util/slab_allocator.cpp")
         .file("parallel-rdp/interface.cpp")
         .file("parallel-rdp/wsi_platform.cpp")
         .include("parallel-rdp/parallel-rdp-standalone/parallel-rdp")
@@ -72,7 +74,6 @@ fn main() {
 
     let os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
     let arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap();
-    let profile = std::env::var("PROFILE").unwrap();
     let opt_flag = if arch == "x86_64" {
         "-march=x86-64-v3"
     } else if arch == "aarch64" {
@@ -95,11 +96,10 @@ fn main() {
             .unwrap();
     }
 
-    if profile == "release" {
-        volk_build.flag("-flto=thin");
-        rdp_build.flag("-flto=thin");
-        simd_build.flag("-flto=thin");
-    }
+    volk_build.flag("-flto=thin");
+    rdp_build.flag("-flto=thin");
+    simd_build.flag("-flto=thin");
+
     volk_build.compile("volk");
     rdp_build.compile("parallel-rdp");
 
@@ -111,10 +111,12 @@ fn main() {
         .allowlist_function("rdp_close")
         .allowlist_function("rdp_set_vi_register")
         .allowlist_function("rdp_update_screen")
+        .allowlist_function("rdp_render_frame")
         .allowlist_function("rdp_process_commands")
         .allowlist_function("rdp_onscreen_message")
         .allowlist_function("rdp_check_callback")
         .allowlist_function("rdp_new_processor")
+        .allowlist_function("rdp_check_framebuffers")
         .allowlist_function("rdp_state_size")
         .allowlist_function("rdp_save_state")
         .allowlist_function("rdp_load_state")
@@ -162,6 +164,7 @@ fn main() {
             .allowlist_function("_mm_cmplt_epi16")
             .allowlist_function("_mm_subs_epu16")
             .allowlist_function("_mm_set1_epi32")
+            .allowlist_function("_mm_set1_epi16")
             .blocklist_type("__m128i")
             .blocklist_type("int64x2_t")
             .wrap_static_fns(true)
@@ -191,5 +194,8 @@ fn main() {
     let git_hash = String::from_utf8(git_output.stdout).unwrap();
     println!("cargo:rustc-env=GIT_HASH={git_hash}");
 
+    let netplay_id = std::env::var("NETPLAY_ID").unwrap_or("gopher64".to_string());
+    println!("cargo:rustc-env=NETPLAY_ID={netplay_id}");
+
     println!("cargo:rustc-env=N64_STACK_SIZE={}", 8 * 1024 * 1024);
 }

parallel-rdp/interface.cpp

@@ -53,14 +53,27 @@ enum vi_registers
 	VI_REGS_COUNT
 };
 
+typedef struct
+{
+	uint32_t depthbuffer_address;
+	uint32_t framebuffer_address;
+	uint32_t framebuffer_y_offset;
+	uint32_t texture_address;
+	uint32_t framebuffer_pixel_size;
+	uint32_t framebuffer_width;
+	uint32_t texture_pixel_size;
+	uint32_t texture_width;
+	uint32_t framebuffer_height;
+	bool depth_buffer_enabled;
+} FrameBufferInfo;
+
 typedef struct
 {
 	uint32_t cmd_data[0x00040000 >> 2];
 	int cmd_cur;
 	int cmd_ptr;
 	uint32_t region;
-	uint64_t vi_counter;
-	uint64_t last_sync;
+	FrameBufferInfo frame_buffer_info;
 } RDP_DEVICE;
 
 static SDL_Window *window;
@@ -75,6 +88,9 @@ static GFX_INFO gfx_info;
 static const uint32_t *fragment_spirv;
 static size_t fragment_size;
 
+std::vector<bool> rdram_dirty;
+uint64_t sync_signal;
+
 static TTF_Font *message_font;
 static std::queue<std::string> messages;
 static uint64_t message_timer;
@@ -240,6 +256,9 @@ void rdp_new_processor(GFX_INFO _gfx_info)
 {
 	gfx_info = _gfx_info;
 
+	sync_signal = 0;
+	rdram_dirty.assign(gfx_info.RDRAM_SIZE >> 3, false);
+
 	if (processor)
 	{
 		delete processor;
@@ -256,6 +275,11 @@ void rdp_new_processor(GFX_INFO _gfx_info)
 		flags |= RDP::COMMAND_PROCESSOR_FLAG_SUPER_SAMPLED_DITHER_BIT;
 		flags |= RDP::COMMAND_PROCESSOR_FLAG_UPSCALING_4X_BIT;
 	}
+	else if (gfx_info.upscale == 8)
+	{
+		flags |= RDP::COMMAND_PROCESSOR_FLAG_SUPER_SAMPLED_DITHER_BIT;
+		flags |= RDP::COMMAND_PROCESSOR_FLAG_UPSCALING_8X_BIT;
+	}
 
 	processor = new RDP::CommandProcessor(wsi->get_device(), gfx_info.RDRAM, 0, gfx_info.RDRAM_SIZE, gfx_info.RDRAM_SIZE / 2, flags);
 }
@@ -523,13 +547,16 @@ void rdp_set_vi_register(uint32_t reg, uint32_t value)
 	processor->set_vi_register(RDP::VIRegister(reg), value);
 }
 
-void rdp_update_screen()
+void rdp_render_frame()
 {
 	auto &device = wsi->get_device();
 	render_frame(device);
+}
+
+void rdp_update_screen()
+{
 	wsi->end_frame();
 	wsi->begin_frame();
-	rdp_device.vi_counter += 1;
 }
 
 CALL_BACK rdp_check_callback()
@@ -543,6 +570,28 @@ CALL_BACK rdp_check_callback()
 	return return_value;
 }
 
+void rdp_check_framebuffers(uint32_t address, uint32_t length)
+{
+	if (sync_signal)
+	{
+		address >>= 3;
+		length = (length + 7) >> 3;
+
+		if (address >= rdram_dirty.size())
+			return;
+
+		uint32_t end_addr = std::min(address + length, static_cast<uint32_t>(rdram_dirty.size()));
+
+		auto it = std::find(rdram_dirty.begin() + address, rdram_dirty.begin() + end_addr, true);
+		if (it != rdram_dirty.begin() + end_addr)
+		{
+			processor->wait_for_timeline(sync_signal);
+			rdram_dirty.assign(gfx_info.RDRAM_SIZE >> 3, false);
+			sync_signal = 0;
+		}
+	}
+}
+
 size_t rdp_state_size()
 {
 	return sizeof(RDP_DEVICE);
@@ -550,6 +599,7 @@ size_t rdp_state_size()
 
 void rdp_save_state(uint8_t *state)
 {
+	processor->wait_for_timeline(processor->signal_timeline());
 	memcpy(state, &rdp_device, sizeof(RDP_DEVICE));
 }
 
@@ -565,6 +615,24 @@ void rdp_onscreen_message(const char *_message)
 	messages.push(_message);
 }
 
+uint32_t pixel_size(uint32_t pixel_type, uint32_t area)
+{
+	switch (pixel_type)
+	{
+	case 0:
+		return area / 2;
+	case 1:
+		return area;
+	case 2:
+		return area * 2;
+	case 3:
+		return area * 4;
+	default:
+		printf("Invalid pixel size: %u\n", pixel_type);
+		return 0;
+	}
+}
+
 uint64_t rdp_process_commands()
 {
 	uint64_t interrupt_timer = 0;
@@ -628,6 +696,75 @@ uint64_t rdp_process_commands()
 
 		switch (RDP::Op(command))
 		{
+		case RDP::Op::FillTriangle:
+		case RDP::Op::FillZBufferTriangle:
+		case RDP::Op::TextureTriangle:
+		case RDP::Op::TextureZBufferTriangle:
+		case RDP::Op::ShadeTriangle:
+		case RDP::Op::ShadeZBufferTriangle:
+		case RDP::Op::ShadeTextureTriangle:
+		case RDP::Op::ShadeTextureZBufferTriangle:
+		case RDP::Op::TextureRectangle:
+		case RDP::Op::TextureRectangleFlip:
+		case RDP::Op::FillRectangle:
+		{
+			uint32_t offset_address = (rdp_device.frame_buffer_info.framebuffer_address + pixel_size(rdp_device.frame_buffer_info.framebuffer_pixel_size, rdp_device.frame_buffer_info.framebuffer_y_offset * rdp_device.frame_buffer_info.framebuffer_width)) >> 3;
+			if (offset_address < rdram_dirty.size() && !rdram_dirty[offset_address])
+			{
+				uint32_t end_addr = std::min(offset_address + ((pixel_size(rdp_device.frame_buffer_info.framebuffer_pixel_size, rdp_device.frame_buffer_info.framebuffer_width * rdp_device.frame_buffer_info.framebuffer_height) + 7) >> 3), static_cast<uint32_t>(rdram_dirty.size()));
+				std::fill(rdram_dirty.begin() + offset_address, rdram_dirty.begin() + end_addr, true);
+			}
+
+			if (rdp_device.frame_buffer_info.depth_buffer_enabled)
+			{
+				offset_address = (rdp_device.frame_buffer_info.depthbuffer_address + pixel_size(2, rdp_device.frame_buffer_info.framebuffer_y_offset * rdp_device.frame_buffer_info.framebuffer_width)) >> 3;
+				if (offset_address < rdram_dirty.size() && !rdram_dirty[offset_address])
+				{
+					uint32_t end_addr = std::min(offset_address + ((pixel_size(2, rdp_device.frame_buffer_info.framebuffer_width * rdp_device.frame_buffer_info.framebuffer_height) + 7) >> 3), static_cast<uint32_t>(rdram_dirty.size()));
+					std::fill(rdram_dirty.begin() + offset_address, rdram_dirty.begin() + end_addr, true);
+				}
+			}
+		}
+		break;
+		case RDP::Op::LoadTLut:
+		case RDP::Op::LoadTile:
+		{
+			uint32_t upper_left_t = (w1 & 0xFFF) >> 2;
+			uint32_t offset_address = (rdp_device.frame_buffer_info.texture_address + pixel_size(rdp_device.frame_buffer_info.texture_pixel_size, upper_left_t * rdp_device.frame_buffer_info.texture_width)) >> 3;
+			if (offset_address < rdram_dirty.size() && !rdram_dirty[offset_address])
+			{
+				uint32_t lower_right_t = (w2 & 0xFFF) >> 2;
+				uint32_t end_addr = std::min(offset_address + ((pixel_size(rdp_device.frame_buffer_info.texture_pixel_size, (lower_right_t - upper_left_t) * rdp_device.frame_buffer_info.texture_width) + 7) >> 3), static_cast<uint32_t>(rdram_dirty.size()));
+				std::fill(rdram_dirty.begin() + offset_address, rdram_dirty.begin() + end_addr, true);
+			}
+		}
+		break;
+		case RDP::Op::LoadBlock:
+		{
+			uint32_t upper_left_s = ((w1 >> 12) & 0xFFF);
+			uint32_t upper_left_t = (w1 & 0xFFF);
+			uint32_t offset_address = (rdp_device.frame_buffer_info.texture_address + pixel_size(rdp_device.frame_buffer_info.texture_pixel_size, upper_left_s + upper_left_t * rdp_device.frame_buffer_info.texture_width)) >> 3;
+			if (offset_address < rdram_dirty.size() && !rdram_dirty[offset_address])
+			{
+				uint32_t lower_right_s = ((w2 >> 12) & 0xFFF);
+				uint32_t end_addr = std::min(offset_address + ((pixel_size(rdp_device.frame_buffer_info.texture_pixel_size, lower_right_s - upper_left_s) + 7) >> 3), static_cast<uint32_t>(rdram_dirty.size()));
+				std::fill(rdram_dirty.begin() + offset_address, rdram_dirty.begin() + end_addr, true);
+			}
+		}
+		break;
+		case RDP::Op::SetColorImage:
+			rdp_device.frame_buffer_info.framebuffer_address = (w2 & 0x00FFFFFF);
+			rdp_device.frame_buffer_info.framebuffer_pixel_size = (w1 >> 19) & 0x3;
+			rdp_device.frame_buffer_info.framebuffer_width = (w1 & 0x3FF) + 1;
+			break;
+		case RDP::Op::SetMaskImage:
+			rdp_device.frame_buffer_info.depthbuffer_address = (w2 & 0x00FFFFFF);
+			break;
+		case RDP::Op::SetTextureImage:
+			rdp_device.frame_buffer_info.texture_address = (w2 & 0x00FFFFFF);
+			rdp_device.frame_buffer_info.texture_pixel_size = (w1 >> 19) & 0x3;
+			rdp_device.frame_buffer_info.texture_width = (w1 & 0x3FF) + 1;
+			break;
 		case RDP::Op::SetScissor:
 		{
 			uint32_t upper_left_x = ((w1 >> 12) & 0xFFF) >> 2;
@@ -642,14 +779,21 @@ uint64_t rdp_process_commands()
 			{
 				rdp_device.region = 0;
 			}
-			break;
+
+			rdp_device.frame_buffer_info.framebuffer_y_offset = upper_left_y;
+			rdp_device.frame_buffer_info.framebuffer_height = lower_right_y - upper_left_y;
 		}
+		break;
+		case RDP::Op::SetOtherModes:
+		{
+			uint8_t cycle_type = (w1 >> 20) & 3;
+			uint8_t depth_read_write = (w2 >> 4) & 3;
+			rdp_device.frame_buffer_info.depth_buffer_enabled = ((cycle_type & 2) == 0) && (depth_read_write != 0);
+		}
+		break;
 		case RDP::Op::SyncFull:
-			if (rdp_device.last_sync != rdp_device.vi_counter)
-			{
-				processor->wait_for_timeline(processor->signal_timeline());
-				rdp_device.last_sync = rdp_device.vi_counter;
-			}
+			sync_signal = processor->signal_timeline();
+
 			interrupt_timer = rdp_device.region;
 			if (interrupt_timer == 0)
 				interrupt_timer = 5000;

parallel-rdp/interface.hpp

@@ -42,10 +42,12 @@ extern "C"
 	void rdp_close();
 	void rdp_set_vi_register(uint32_t reg, uint32_t value);
 	void rdp_update_screen();
+	void rdp_render_frame();
 	CALL_BACK rdp_check_callback();
 	uint64_t rdp_process_commands();
 	void rdp_onscreen_message(const char *_message);
 	void rdp_new_processor(GFX_INFO _gfx_info);
+	void rdp_check_framebuffers(uint32_t address, uint32_t length);
 	size_t rdp_state_size();
 	void rdp_save_state(uint8_t *state);
 	void rdp_load_state(const uint8_t *state);

rust-toolchain.toml

@@ -1,2 +1,2 @@
 [toolchain]
-channel = "1.89.0"
+channel = "1.92.0"

src/device.rs

@@ -93,8 +93,7 @@ fn set_rng() -> rand_chacha::ChaCha8Rng {
 
 fn init_rng(device: &mut Device) {
     let mut rng_seed = set_rng().next_u64();
-    if device.netplay.is_some() {
-        let netplay = device.netplay.as_mut().unwrap();
+    if let Some(netplay) = &mut device.netplay {
         if netplay.player_number == 0 {
             netplay::send_rng(netplay, rng_seed);
         } else {

src/device/cart/rom.rs

@@ -135,8 +135,7 @@ pub fn dma_write(
 pub fn init(device: &mut device::Device, rom_file: Vec<u8>) {
     let now: chrono::DateTime<chrono::Local> = chrono::Local::now();
     device.cart.rtc_timestamp = now.naive_local().and_utc().timestamp();
-    if device.netplay.is_some() {
-        let netplay = device.netplay.as_mut().unwrap();
+    if let Some(netplay) = &mut device.netplay {
         if netplay.player_number == 0 {
             netplay::send_rtc(netplay, device.cart.rtc_timestamp);
         } else {

src/device/controller.rs

@@ -56,15 +56,14 @@ pub fn process(device: &mut device::Device, channel: usize) {
         }
         JCMD_CONTROLLER_READ => {
             let offset = device.pif.channels[channel].rx_buf.unwrap();
-            let input = if device.netplay.is_none() {
-                ui::input::get(&device.ui, channel)
-            } else {
-                if device.netplay.as_ref().unwrap().player_number as usize == channel {
+            let input = if let Some(netplay) = &mut device.netplay {
+                if netplay.player_number as usize == channel {
                     let local_input = ui::input::get(&device.ui, 0);
-                    netplay::send_input(device.netplay.as_ref().unwrap(), local_input);
+                    netplay::send_input(netplay, local_input);
                 }
-
                 netplay::get_input(device, channel)
+            } else {
+                ui::input::get(&device.ui, channel)
             };
 
             device.pif.ram[offset..offset + 4].copy_from_slice(&input.data.to_ne_bytes());
@@ -162,10 +161,12 @@ pub fn pak_switch_event(device: &mut device::Device) {
     for (i, channel) in device.pif.channels.iter_mut().enumerate() {
         if channel.change_pak != PakType::None {
             //stop rumble if it is on
-            if device.netplay.is_none() {
+            if let Some(netplay) = &device.netplay {
+                if netplay.player_number as usize == i {
+                    device::ui::input::set_rumble(&device.ui, 0, 0);
+                }
+            } else {
                 device::ui::input::set_rumble(&device.ui, i, 0);
-            } else if device.netplay.as_ref().unwrap().player_number as usize == i {
-                device::ui::input::set_rumble(&device.ui, 0, 0);
             }
 
             let new_pak_type = match channel.change_pak {

src/device/controller/rumble.rs

@@ -15,10 +15,13 @@ pub fn read(device: &mut device::Device, _channel: usize, address: u16, data: us
 pub fn write(device: &mut device::Device, channel: usize, address: u16, data: usize, size: usize) {
     if address == 0xc000 {
         let rumble = device.pif.ram[data + size - 1];
-        if device.netplay.is_none() {
+
+        if let Some(netplay) = &device.netplay {
+            if netplay.player_number as usize == channel {
+                device::ui::input::set_rumble(&device.ui, 0, rumble);
+            }
+        } else {
             device::ui::input::set_rumble(&device.ui, channel, rumble);
-        } else if device.netplay.as_ref().unwrap().player_number as usize == channel {
-            device::ui::input::set_rumble(&device.ui, 0, rumble);
         }
     }
 }

src/device/controller/vru.rs

@@ -187,11 +187,12 @@ pub fn process(device: &mut device::Device, channel: usize) {
             device.pif.ram[device.pif.channels[channel].rx_buf.unwrap()] = 0;
         }
         JCMD_VRU_READ => {
-            let index = if device.vru_window.window_notifier.is_some() {
+            let index = if let Some(window_notifier) = &device.vru_window.window_notifier {
                 ui::vru::prompt_for_match(
                     &device.vru.words,
-                    device.vru_window.window_notifier.as_ref().unwrap(),
+                    window_notifier,
                     device.vru_window.word_receiver.as_mut().unwrap(),
+                    device.vi.frame_time,
                 )
             } else {
                 0x7FFF

src/device/exceptions.rs

@@ -18,7 +18,6 @@ pub fn check_pending_interrupts(device: &mut device::Device) {
         device.cpu.cop0.regs[device::cop0::COP0_CAUSE_REG as usize] = device::cop0::COP0_CAUSE_IP2;
     } else if device.cpu.cop0.pending_compare_interrupt {
         device.cpu.cop0.regs[device::cop0::COP0_CAUSE_REG as usize] = device::cop0::COP0_CAUSE_IP7;
-        device.cpu.cop0.pending_compare_interrupt = false;
     }
 
     if (device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize]

src/device/is_viewer.rs

@@ -22,8 +22,8 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
         let data = std::str::from_utf8(
             &device.cart.is_viewer_buffer[0x20_usize..(0x20 + length) as usize],
         );
-        if data.is_ok() {
-            print!("{}", data.unwrap());
+        if let Ok(data) = data {
+            print!("{}", data);
         }
     } else {
         let mut data = u32::from_be_bytes(

src/device/memory.rs

@@ -62,11 +62,16 @@ pub fn masked_write_64(dst: &mut u64, value: u64, mask: u64) {
 
 pub fn translate_address(
     device: &mut device::Device,
-    address: u64,
+    mut address: u64,
     access_type: AccessType,
 ) -> (u64, bool, bool) {
     if (address & 0xc0000000) != 0x80000000 {
-        return device::tlb::get_physical_address(device, address, access_type);
+        if (address & 0xFFFFFFFF00000000) == 0x9000000000000000 {
+            // this is a hack to support 64-bit addresses used by some homebrew
+            address |= 0xA0000000;
+        } else {
+            return device::tlb::get_physical_address(device, address, access_type);
+        }
     }
     (address & 0x1FFFFFFF, address & 0x20000000 == 0, false)
 }

src/device/mi.rs

@@ -1,6 +1,6 @@
 use crate::device;
 
-const MI_INIT_MODE_REG: u32 = 0;
+pub const MI_INIT_MODE_REG: u32 = 0;
 const MI_VERSION_REG: u32 = 1;
 pub const MI_INTR_REG: u32 = 2;
 pub const MI_INTR_MASK_REG: u32 = 3;
@@ -29,7 +29,7 @@ const MI_CLR_DP: u32 = 1 << 10;
 const MI_SET_DP: u32 = 1 << 11;
 
 /* mode read */
-const MI_INIT_MODE: u32 = 1 << 7;
+pub const MI_INIT_MODE: u32 = 1 << 7;
 const MI_EBUS_MODE: u32 = 1 << 8;
 const MI_RDRAM_MODE: u32 = 1 << 9;
 
@@ -42,7 +42,7 @@ const MI_CLR_DP_INTR: u32 = 1 << 11;
 const MI_CLR_RDRAM: u32 = 1 << 12;
 const MI_SET_RDRAM: u32 = 1 << 13;
 
-const MI_INIT_LENGTH_MASK: u32 = 0b1111111;
+pub const MI_INIT_LENGTH_MASK: u32 = 0b1111111;
 
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct Mi {
@@ -78,9 +78,15 @@ fn update_init_mode(device: &mut device::Device, w: u32) {
     device.mi.regs[MI_INIT_MODE_REG as usize] |= w & MI_INIT_LENGTH_MASK;
 
     if w & MI_CLR_INIT != 0 {
+        for i in 0..(0x3F00000 >> 16) {
+            device.memory.memory_map_write[i] = device::rdram::write_mem;
+        }
         device.mi.regs[MI_INIT_MODE_REG as usize] &= !MI_INIT_MODE
     }
     if w & MI_SET_INIT != 0 {
+        for i in 0..(0x3F00000 >> 16) {
+            device.memory.memory_map_write[i] = device::rdram::write_mem_repeat;
+        }
         device.mi.regs[MI_INIT_MODE_REG as usize] |= MI_INIT_MODE
     }
     if w & MI_CLR_EBUS != 0 {

src/device/pi.rs

@@ -1,4 +1,5 @@
 use crate::device;
+use crate::ui;
 use rand_chacha::rand_core::RngCore;
 
 const PI_DRAM_ADDR_REG: u32 = 0;
@@ -92,6 +93,9 @@ fn dma_write(device: &mut device::Device) {
         length -= dram_addr & 0x7;
     }
 
+    // check RDP before PI writes to RDRAM
+    ui::video::check_framebuffers(dram_addr, length);
+
     let cycles = (handler.write)(device, cart_addr, dram_addr, length);
 
     device::events::create_event(device, device::events::EVENT_TYPE_PI, cycles);

src/device/pif.rs

@@ -218,11 +218,11 @@ pub fn process_ram(device: &mut device::Device) {
 
 pub fn connect_pif_channels(device: &mut device::Device) {
     for i in 0..4 {
-        if device.netplay.is_none() {
-            if device.ui.config.input.controller_enabled[i] {
+        if let Some(netplay) = &device.netplay {
+            if netplay.player_data[i].reg_id != 0 {
                 device.pif.channels[i].process = Some(device::controller::process);
             }
-        } else if device.netplay.as_ref().unwrap().player_data[i].reg_id != 0 {
+        } else if device.ui.config.input.controller_enabled[i] {
             device.pif.channels[i].process = Some(device::controller::process);
         }
     }
@@ -268,16 +268,16 @@ pub fn init(device: &mut device::Device) {
     connect_pif_channels(device);
 
     for i in 0..4 {
-        if device.netplay.is_none() {
-            if device.ui.config.input.controller_enabled[i] {
-                if device.transferpaks[i].cart.rom.is_empty() {
-                    device.pif.channels[i].pak_handler = Some(default_handler);
-                } else {
-                    device.pif.channels[i].pak_handler = Some(tpak_handler);
-                }
+        if let Some(netplay) = &device.netplay {
+            if netplay.player_data[i].reg_id != 0 {
+                device.pif.channels[i].pak_handler = Some(default_handler);
+            }
+        } else if device.ui.config.input.controller_enabled[i] {
+            if device.transferpaks[i].cart.rom.is_empty() {
+                device.pif.channels[i].pak_handler = Some(default_handler);
+            } else {
+                device.pif.channels[i].pak_handler = Some(tpak_handler);
             }
-        } else if device.netplay.as_ref().unwrap().player_data[i].reg_id != 0 {
-            device.pif.channels[i].pak_handler = Some(default_handler);
         }
     }
     if device.ui.config.input.emulate_vru && device.netplay.is_none() {

src/device/rdram.rs

@@ -1,4 +1,5 @@
 use crate::device;
+use crate::ui;
 use std::alloc::{Layout, alloc_zeroed};
 
 //const RDRAM_CONFIG_REG: u32 = 0;
@@ -50,6 +51,8 @@ pub fn read_mem(
     );
     let masked_address = address as usize & RDRAM_MASK;
 
+    ui::video::check_framebuffers(masked_address as u32, 4);
+
     u32::from_ne_bytes(
         device
             .rdram
@@ -62,6 +65,8 @@ pub fn read_mem(
 }
 
 pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u32) {
+    ui::video::check_framebuffers(address as u32, 4);
+
     let mut data = u32::from_ne_bytes(
         device
             .rdram
@@ -80,6 +85,39 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
         .copy_from_slice(&data.to_ne_bytes());
 }
 
+pub fn write_mem_repeat(device: &mut device::Device, address: u64, value: u32, mask: u32) {
+    if mask != 0xFFFFFFFF {
+        panic!("RDRAM write_mem_repeat called with mask {:#x}", mask);
+    }
+
+    let repeat_length = (device.mi.regs[device::mi::MI_INIT_MODE_REG as usize]
+        & device::mi::MI_INIT_LENGTH_MASK)
+        + 1;
+
+    if !repeat_length.is_multiple_of(4) {
+        panic!(
+            "RDRAM write_mem_repeat called with non-word-aligned length {}",
+            repeat_length
+        );
+    }
+
+    ui::video::check_framebuffers(address as u32, repeat_length);
+
+    for i in (0..repeat_length as u64).step_by(4) {
+        device
+            .rdram
+            .mem
+            .get_mut((address + i) as usize..(address + i) as usize + 4)
+            .unwrap_or(&mut [0; 4])
+            .copy_from_slice(&value.to_ne_bytes());
+    }
+
+    device.mi.regs[device::mi::MI_INIT_MODE_REG as usize] &= !device::mi::MI_INIT_MODE;
+    for i in 0..(0x3F00000 >> 16) {
+        device.memory.memory_map_write[i] = device::rdram::write_mem;
+    }
+}
+
 pub fn read_regs(
     device: &mut device::Device,
     address: u64,

src/device/rsp_interface.rs

@@ -1,4 +1,5 @@
 use crate::device;
+use crate::ui;
 
 const SP_MEM_ADDR_REG: u32 = 0;
 const SP_DRAM_ADDR_REG: u32 = 1;
@@ -146,6 +147,7 @@ fn do_dma(device: &mut device::Device, dma: RspDma) {
     let mut dram_addr = dma.dramaddr & 0xfffff8;
     let offset = dma.memaddr & 0x1000;
 
+    ui::video::check_framebuffers(dram_addr, count * (length + skip) - skip);
     if dma.dir == DmaDir::Read {
         let mut j = 0;
         while j < count {
@@ -219,6 +221,8 @@ fn fifo_push(device: &mut device::Device, dir: DmaDir) {
         panic!("RSP DMA already full")
     }
 
+    device.rsp.cpu.sync_point = true;
+
     if device.rsp.regs[SP_DMA_BUSY_REG as usize] != 0 {
         device.rsp.fifo[1].dir = dir;
         if dir == DmaDir::Read {
@@ -276,21 +280,20 @@ pub fn read_regs(
     }
     let reg = (address & 0xFFFF) >> 2;
     match reg as u32 {
-        SP_DMA_BUSY_REG | SP_DMA_FULL_REG => {
-            if device.rsp.regs[reg as usize] != 0 {
-                device.rsp.cpu.sync_point = true;
-            }
-            device.rsp.regs[reg as usize]
-        }
         SP_STATUS_REG => {
             let value = device.rsp.regs[reg as usize]
-                & !(SP_STATUS_HALT | SP_STATUS_BROKE | SP_STATUS_INTR_BREAK);
+                & (SP_STATUS_SIG0
+                    | SP_STATUS_SIG1
+                    | SP_STATUS_SIG2
+                    | SP_STATUS_SIG3
+                    | SP_STATUS_SIG4
+                    | SP_STATUS_SIG5
+                    | SP_STATUS_SIG6
+                    | SP_STATUS_SIG7);
             if value == device.rsp.last_status_value && value != 0 {
                 device.rsp.cpu.sync_point = true;
             }
-            if value & (SP_STATUS_DMA_BUSY | SP_STATUS_DMA_FULL) != 0 {
-                device.rsp.cpu.sync_point = true;
-            }
+
             device.rsp.last_status_value = value;
             device.rsp.regs[reg as usize]
         }
@@ -464,6 +467,7 @@ fn update_sp_status(device: &mut device::Device, w: u32) {
 fn do_task(device: &mut device::Device) {
     device.rsp.cpu.sync_point = false;
     device.rsp.last_status_value = 0;
+    device.rdp.last_status_value = 0;
     if device.rsp.regs[SP_DMA_BUSY_REG as usize] == 1 {
         device.rsp.run_after_dma = true
     } else {

src/device/rsp_su_instructions.rs

@@ -304,25 +304,44 @@ pub fn lh(device: &mut device::Device, opcode: u32) {
     let address =
         device.rsp.cpu.gpr[rs(opcode) as usize].wrapping_add(imm(opcode) as i16 as i32 as u32);
 
-    let mut w = [0; 2];
-    w[0] = device.rsp.mem[address as usize & 0xFFF];
-    w[1] = device.rsp.mem[(address as usize + 1) & 0xFFF];
+    // Optimize for aligned access when possible
+    let addr_masked = address as usize & 0xFFF;
+    let value = if addr_masked <= 0xFFE {
+        u16::from_be_bytes(
+            device.rsp.mem[addr_masked..addr_masked + 2]
+                .try_into()
+                .unwrap(),
+        )
+    } else {
+        let w0 = device.rsp.mem[addr_masked];
+        let w1 = device.rsp.mem[(addr_masked + 1) & 0xFFF];
+        ((w0 as u16) << 8) | w1 as u16
+    };
 
-    device.rsp.cpu.gpr[rt(opcode) as usize] =
-        (((w[0] as u16) << 8) | w[1] as u16) as i16 as i32 as u32
+    device.rsp.cpu.gpr[rt(opcode) as usize] = value as i16 as i32 as u32;
 }
 
 pub fn lw(device: &mut device::Device, opcode: u32) {
     let address =
         device.rsp.cpu.gpr[rs(opcode) as usize].wrapping_add(imm(opcode) as i16 as i32 as u32);
 
-    let mut w = [0; 4];
-    for (i, item) in w.iter_mut().enumerate() {
-        *item = device.rsp.mem[(address as usize + i) & 0xFFF];
-    }
+    // Optimize for aligned access when possible
+    let addr_masked = address as usize & 0xFFF;
+    let value = if addr_masked <= 0xFFC {
+        u32::from_be_bytes(
+            device.rsp.mem[addr_masked..addr_masked + 4]
+                .try_into()
+                .unwrap(),
+        )
+    } else {
+        let mut value = 0;
+        for i in 0..4 {
+            value |= (device.rsp.mem[(addr_masked + i) & 0xFFF] as u32) << (8 * (3 - i));
+        }
+        value
+    };
 
-    device.rsp.cpu.gpr[rt(opcode) as usize] =
-        ((w[0] as u32) << 24) | ((w[1] as u32) << 16) | ((w[2] as u32) << 8) | (w[3] as u32)
+    device.rsp.cpu.gpr[rt(opcode) as usize] = value;
 }
 
 pub fn lbu(device: &mut device::Device, opcode: u32) {
@@ -336,24 +355,44 @@ pub fn lhu(device: &mut device::Device, opcode: u32) {
     let address =
         device.rsp.cpu.gpr[rs(opcode) as usize].wrapping_add(imm(opcode) as i16 as i32 as u32);
 
-    let mut w = [0; 2];
-    w[0] = device.rsp.mem[address as usize & 0xFFF];
-    w[1] = device.rsp.mem[(address as usize + 1) & 0xFFF];
+    // Optimize for aligned access when possible
+    let addr_masked = address as usize & 0xFFF;
+    let value = if addr_masked <= 0xFFE {
+        u16::from_be_bytes(
+            device.rsp.mem[addr_masked..addr_masked + 2]
+                .try_into()
+                .unwrap(),
+        )
+    } else {
+        let w0 = device.rsp.mem[addr_masked];
+        let w1 = device.rsp.mem[(addr_masked + 1) & 0xFFF];
+        ((w0 as u16) << 8) | w1 as u16
+    };
 
-    device.rsp.cpu.gpr[rt(opcode) as usize] = (((w[0] as u16) << 8) | w[1] as u16) as u32
+    device.rsp.cpu.gpr[rt(opcode) as usize] = value as u32;
 }
 
 pub fn lwu(device: &mut device::Device, opcode: u32) {
     let address =
         device.rsp.cpu.gpr[rs(opcode) as usize].wrapping_add(imm(opcode) as i16 as i32 as u32);
 
-    let mut w = [0; 4];
-    for (i, item) in w.iter_mut().enumerate() {
-        *item = device.rsp.mem[(address as usize + i) & 0xFFF];
-    }
+    // Optimize for aligned access when possible
+    let addr_masked = address as usize & 0xFFF;
+    let value = if addr_masked <= 0xFFC {
+        u32::from_be_bytes(
+            device.rsp.mem[addr_masked..addr_masked + 4]
+                .try_into()
+                .unwrap(),
+        )
+    } else {
+        let mut value = 0;
+        for i in 0..4 {
+            value |= (device.rsp.mem[(addr_masked + i) & 0xFFF] as u32) << (8 * (3 - i));
+        }
+        value
+    };
 
-    device.rsp.cpu.gpr[rt(opcode) as usize] =
-        ((w[0] as u32) << 24) | ((w[1] as u32) << 16) | ((w[2] as u32) << 8) | (w[3] as u32)
+    device.rsp.cpu.gpr[rt(opcode) as usize] = value;
 }
 
 pub fn sb(device: &mut device::Device, opcode: u32) {
@@ -367,18 +406,30 @@ pub fn sh(device: &mut device::Device, opcode: u32) {
     let address =
         device.rsp.cpu.gpr[rs(opcode) as usize].wrapping_add(imm(opcode) as i16 as i32 as u32);
 
-    device.rsp.mem[address as usize & 0xFFF] = (device.rsp.cpu.gpr[rt(opcode) as usize] >> 8) as u8;
-    device.rsp.mem[(address as usize + 1) & 0xFFF] =
-        (device.rsp.cpu.gpr[rt(opcode) as usize]) as u8;
+    let addr_masked = address as usize & 0xFFF;
+    let value = device.rsp.cpu.gpr[rt(opcode) as usize] as u16;
+    // Optimize for aligned access when possible
+    if addr_masked <= 0xFFE {
+        device.rsp.mem[addr_masked..addr_masked + 2].copy_from_slice(&value.to_be_bytes());
+    } else {
+        device.rsp.mem[addr_masked] = (value >> 8) as u8;
+        device.rsp.mem[(addr_masked + 1) & 0xFFF] = value as u8;
+    }
 }
 
 pub fn sw(device: &mut device::Device, opcode: u32) {
     let address =
         device.rsp.cpu.gpr[rs(opcode) as usize].wrapping_add(imm(opcode) as i16 as i32 as u32);
 
-    for i in 0..4 {
-        device.rsp.mem[(address as usize + i) & 0xFFF] =
-            (device.rsp.cpu.gpr[rt(opcode) as usize] >> ((3 - i) * 8)) as u8;
+    let addr_masked = address as usize & 0xFFF;
+    let value = device.rsp.cpu.gpr[rt(opcode) as usize];
+    // Optimize for aligned access when possible
+    if addr_masked <= 0xFFC {
+        device.rsp.mem[addr_masked..addr_masked + 4].copy_from_slice(&value.to_be_bytes());
+    } else {
+        for i in 0..4 {
+            device.rsp.mem[(addr_masked + i) & 0xFFF] = (value >> ((3 - i) * 8)) as u8;
+        }
     }
 }
 
@@ -737,10 +788,21 @@ pub fn llv(device: &mut device::Device, opcode: u32) {
     let mut element = velement(opcode);
 
     if element.is_multiple_of(4) {
-        let mut value = 0;
-        for i in 0..4 {
-            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u32) << (8 * (3 - i));
-        }
+        // Optimize for aligned access when possible
+        let addr_masked = address as usize & 0xFFF;
+        let value = if addr_masked <= 0xFFC {
+            u32::from_be_bytes(
+                device.rsp.mem[addr_masked..addr_masked + 4]
+                    .try_into()
+                    .unwrap(),
+            )
+        } else {
+            let mut value = 0;
+            for i in 0..4 {
+                value |= (device.rsp.mem[(addr_masked + i) & 0xFFF] as u32) << (8 * (3 - i));
+            }
+            value
+        };
         modify_vpr32(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
             element / 4,
@@ -767,10 +829,21 @@ pub fn ldv(device: &mut device::Device, opcode: u32) {
     let mut element = velement(opcode);
 
     if element.is_multiple_of(8) {
-        let mut value = 0;
-        for i in 0..8 {
-            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u64) << (8 * (7 - i));
-        }
+        // Optimize for aligned access when possible
+        let addr_masked = address as usize & 0xFFF;
+        let value = if addr_masked <= 0xFF8 {
+            u64::from_be_bytes(
+                device.rsp.mem[addr_masked..addr_masked + 8]
+                    .try_into()
+                    .unwrap(),
+            )
+        } else {
+            let mut value = 0;
+            for i in 0..8 {
+                value |= (device.rsp.mem[(addr_masked + i) & 0xFFF] as u64) << (8 * (7 - i));
+            }
+            value
+        };
         modify_vpr64(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
             element / 8,
@@ -797,10 +870,21 @@ pub fn lqv(device: &mut device::Device, opcode: u32) {
     let mut element = velement(opcode);
 
     if element == 0 && address.is_multiple_of(16) {
-        let mut value = 0;
-        for i in 0..16 {
-            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u128) << (8 * (15 - i));
-        }
+        // Optimize for aligned 16-byte access
+        let addr_masked = address as usize & 0xFFF;
+        let value = if addr_masked <= 0xFF0 {
+            u128::from_be_bytes(
+                device.rsp.mem[addr_masked..addr_masked + 16]
+                    .try_into()
+                    .unwrap(),
+            )
+        } else {
+            let mut value = 0;
+            for i in 0..16 {
+                value |= (device.rsp.mem[(addr_masked + i) & 0xFFF] as u128) << (8 * (15 - i));
+            }
+            value
+        };
         modify_vpr128(&mut device.rsp.cpu.vpr[rt(opcode) as usize], value);
     } else {
         let end = std::cmp::min(16 + element - ((address & 15) as u8), 16);
@@ -823,10 +907,21 @@ pub fn lrv(device: &mut device::Device, opcode: u32) {
     let mut element = 16u8.wrapping_sub(((address & 15) as u8).wrapping_sub(velement(opcode)));
     address &= !15;
     if element == 0 {
-        let mut value = 0;
-        for i in 0..16 {
-            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u128) << (8 * (15 - i));
-        }
+        // Optimize for aligned 16-byte access
+        let addr_masked = address as usize & 0xFFF;
+        let value = if addr_masked <= 0xFF0 {
+            u128::from_be_bytes(
+                device.rsp.mem[addr_masked..addr_masked + 16]
+                    .try_into()
+                    .unwrap(),
+            )
+        } else {
+            let mut value = 0;
+            for i in 0..16 {
+                value |= (device.rsp.mem[(addr_masked + i) & 0xFFF] as u128) << (8 * (15 - i));
+            }
+            value
+        };
         modify_vpr128(&mut device.rsp.cpu.vpr[rt(opcode) as usize], value);
     } else {
         while element < 16 {

src/device/si.rs

@@ -1,6 +1,7 @@
 use rand_chacha::rand_core::RngCore;
 
 use crate::device;
+use crate::ui;
 
 const SI_DRAM_ADDR_REG: u32 = 0;
 const SI_PIF_ADDR_RD64B_REG: u32 = 1;
@@ -98,6 +99,8 @@ fn copy_pif_rdram(device: &mut device::Device) {
             i += 4;
         }
     } else if device.si.dma_dir == DmaDir::Read {
+        // check RDP before SI writes to RDRAM
+        ui::video::check_framebuffers(dram_addr as u32, device::pif::PIF_RAM_SIZE as u32);
         let mut i = 0;
         while i < device::pif::PIF_RAM_SIZE {
             let data = u32::from_be_bytes(device.pif.ram[i..i + 4].try_into().unwrap());

src/device/vi.rs

@@ -137,21 +137,31 @@ pub fn vertical_interrupt_event(device: &mut device::Device) {
     if device.cheats.enabled {
         cheats::execute_cheats(device, device.cheats.cheats.clone());
     }
-    let mut speed_limiter_toggled = ui::video::check_callback(device);
 
-    if device.netplay.is_some() {
-        netplay::send_sync_check(device);
-        if device.vi.enable_speed_limiter == device.netplay.as_ref().unwrap().fast_forward {
+    ui::video::render_frame();
+
+    let (mut speed_limiter_toggled, paused) = ui::video::check_callback(device);
+
+    if let Some(netplay) = &mut device.netplay {
+        netplay::send_sync_check(netplay, device.cpu.cop0.regs.as_ref());
+        if device.vi.enable_speed_limiter == netplay.fast_forward {
             speed_limiter_toggled = true;
-            device.vi.enable_speed_limiter = !device.netplay.as_ref().unwrap().fast_forward;
+            device.vi.enable_speed_limiter = !netplay.fast_forward;
         }
     }
 
-    device.vi.vi_counter += 1;
     if device.vi.vi_counter.is_multiple_of(device.vi.limit_freq) && device.vi.enable_speed_limiter {
         speed_limiter(device, speed_limiter_toggled);
     }
+
     ui::video::update_screen();
+    device.vi.vi_counter += 1;
+
+    if device.netplay.is_none() && paused {
+        ui::video::pause_loop(device.vi.frame_time);
+    }
+
+    unsafe { sdl3_sys::events::SDL_PumpEvents() };
 
     /*
     let vis = if device.cart.pal { 50 } else { 60 };

src/main.rs

@@ -9,6 +9,7 @@ mod netplay;
 mod savestates;
 mod ui;
 use clap::Parser;
+use std::io::Error;
 use ui::gui;
 
 /// N64 emulator
@@ -22,15 +23,22 @@ struct Args {
         short,
         long,
         value_name = "PROFILE_NAME",
-        help = "Create a new input profile (keyboard/gamepad mappings)."
+        help = "Create a new input profile (keyboard/gamepad mappings)"
     )]
     configure_input_profile: Option<String>,
     #[arg(
         short,
         long,
-        help = "Use DirectInput when configuring a new input profile."
+        help = "Use DirectInput when configuring a new input profile"
     )]
     use_dinput: bool,
+    #[arg(
+        short,
+        long,
+        value_name = "DEADZONE_PERCENTAGE",
+        help = "Used along with --configure-input-profile to set the deadzone for analog sticks"
+    )]
+    deadzone: Option<i32>,
     #[arg(
         short,
         long,
@@ -67,111 +75,89 @@ struct Args {
 }
 
 #[tokio::main]
-async fn main() {
+async fn main() -> std::io::Result<()> {
     let dirs = ui::get_dirs();
 
-    let mut result = std::fs::create_dir_all(dirs.config_dir);
-    if result.is_err() {
-        panic!("could not create config dir: {}", result.err().unwrap())
-    }
-    result = std::fs::create_dir_all(dirs.data_dir.join("saves"));
-    if result.is_err() {
-        panic!("could not create save dir: {}", result.err().unwrap())
-    }
-    result = std::fs::create_dir_all(dirs.data_dir.join("states"));
-    if result.is_err() {
-        panic!("could not create state dir: {}", result.err().unwrap())
-    }
-
+    std::fs::create_dir_all(dirs.config_dir)?;
+    std::fs::create_dir_all(dirs.data_dir.join("saves"))?;
+    std::fs::create_dir_all(dirs.data_dir.join("states"))?;
     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 && args.game.is_none() {
+    if let Some(game) = args.game {
+        let file_path = std::path::Path::new(&game);
+        let Some(rom_contents) = device::get_rom_contents(file_path) else {
+            return Err(Error::other(format!(
+                "Could not read ROM file: {}",
+                file_path.display()
+            )));
+        };
+        let handle = std::thread::Builder::new()
+            .name("n64".to_string())
+            .stack_size(env!("N64_STACK_SIZE").parse().unwrap())
+            .spawn(move || {
+                let mut device = device::Device::new();
+                let overclock = device.ui.config.emulation.overclock;
+                let disable_expansion_pak = device.ui.config.emulation.disable_expansion_pak;
+
+                let game_cheats = {
+                    let game_crc = ui::storage::get_game_crc(&rom_contents);
+                    let cheats = ui::config::Cheats::new();
+                    cheats.cheats.get(&game_crc).cloned().unwrap_or_default()
+                };
+                device::run_game(
+                    &mut device,
+                    rom_contents,
+                    ui::gui::GameSettings {
+                        fullscreen: args.fullscreen,
+                        overclock,
+                        disable_expansion_pak,
+                        cheats: game_cheats,
+                    },
+                );
+            })?;
+
+        handle.join().unwrap();
+    } else if std::env::args().count() > 1 {
         let mut ui = ui::Ui::new();
 
         if args.clear_input_bindings {
             ui::input::clear_bindings(&mut ui);
-            return;
+            return Ok(());
         }
-        if args.port.is_some() {
-            let port = args.port.unwrap();
-            if !(1..=4).contains(&port) {
-                println!("Port must be betwen 1 and 4");
-                return;
-            }
+        if let Some(port) = args.port
+            && !(1..=4).contains(&port)
+        {
+            return Err(Error::other("Port must be between 1 and 4"));
         }
         if args.list_controllers {
             let controllers = ui::input::get_controller_names(&ui);
             for (i, controller) in controllers.iter().enumerate() {
                 println!("Controller {i}: {controller}");
             }
-            return;
+            return Ok(());
         }
-        if args.configure_input_profile.is_some() {
+        if let Some(profile) = args.configure_input_profile {
             ui::input::configure_input_profile(
                 &mut ui,
-                args.configure_input_profile.unwrap(),
+                profile,
                 args.use_dinput,
+                args.deadzone.unwrap_or(ui::input::DEADZONE_DEFAULT),
             );
-            return;
+            return Ok(());
         }
-        if args.assign_controller.is_some() {
-            if args.port.is_none() {
-                println!("Must specify port number");
-                return;
-            }
-            ui::input::assign_controller(
-                &mut ui,
-                args.assign_controller.unwrap(),
-                args.port.unwrap(),
-            );
+        if let Some(assign_controller) = args.assign_controller {
+            let Some(port) = args.port else {
+                return Err(Error::other("Must specify port number"));
+            };
+            ui::input::assign_controller(&mut ui, assign_controller, port);
         }
-        if args.bind_input_profile.is_some() {
-            if args.port.is_none() {
-                println!("Must specify port number");
-                return;
-            }
-            ui::input::bind_input_profile(
-                &mut ui,
-                args.bind_input_profile.unwrap(),
-                args.port.unwrap(),
-            );
-        }
-    } else if args.game.is_some() {
-        let file_path = std::path::Path::new(args.game.as_ref().unwrap());
-        if let Some(rom_contents) = device::get_rom_contents(file_path) {
-            let handle = std::thread::Builder::new()
-                .name("n64".to_string())
-                .stack_size(env!("N64_STACK_SIZE").parse().unwrap())
-                .spawn(move || {
-                    let mut device = device::Device::new();
-                    let overclock = device.ui.config.emulation.overclock;
-                    let disable_expansion_pak = device.ui.config.emulation.disable_expansion_pak;
-
-                    let game_cheats = {
-                        let game_crc = ui::storage::get_game_crc(&rom_contents);
-                        let cheats = ui::config::Cheats::new();
-                        cheats.cheats.get(&game_crc).cloned().unwrap_or_default()
-                    };
-                    device::run_game(
-                        &mut device,
-                        rom_contents,
-                        ui::gui::GameSettings {
-                            fullscreen: args.fullscreen,
-                            overclock,
-                            disable_expansion_pak,
-                            cheats: game_cheats,
-                        },
-                    );
-                })
-                .unwrap();
-
-            handle.join().unwrap();
-        } else {
-            println!("Could not read rom file");
-            return;
+        if let Some(profile) = args.bind_input_profile {
+            let Some(port) = args.port else {
+                return Err(Error::other("Must specify port number"));
+            };
+            ui::input::bind_input_profile(&mut ui, profile, port);
         }
     } else {
         gui::app_window();
     }
+    Ok(())
 }

src/netplay.rs

@@ -103,14 +103,13 @@ pub fn receive_save(netplay: &mut Netplay, save_type: &str, save_data: &mut Vec<
     *save_data = response;
 }
 
-pub fn send_sync_check(device: &mut device::Device) {
-    let netplay = device.netplay.as_mut().unwrap();
+pub fn send_sync_check(netplay: &mut Netplay, regs: &[u64]) {
     if netplay.vi_counter.is_multiple_of(600) {
         let mut request: Vec<u8> = [UDP_SYNC_DATA].to_vec();
         request.extend_from_slice(&(netplay.vi_counter).to_be_bytes());
 
-        for i in 0..device::cop0::COP0_REGS_COUNT as usize {
-            request.extend_from_slice(&(device.cpu.cop0.regs[i] as u32).to_be_bytes());
+        for item in regs.iter() {
+            request.extend_from_slice(&(*item as u32).to_be_bytes());
         }
 
         netplay.udp_socket.send(&request).unwrap();

src/ui.rs

@@ -15,9 +15,7 @@ pub struct Dirs {
 }
 
 pub struct Audio {
-    pub audio_device_spec: sdl3_sys::audio::SDL_AudioSpec,
     pub audio_stream: *mut sdl3_sys::audio::SDL_AudioStream,
-    pub audio_device: u32,
     pub gain: f32,
 }
 
@@ -183,9 +181,7 @@ impl Ui {
             game_id: String::new(),
             game_hash: String::new(),
             audio: Audio {
-                audio_device_spec: Default::default(),
                 audio_stream: std::ptr::null_mut(),
-                audio_device: 0,
                 gain: 1.0,
             },
             video: Video {

src/ui/audio.rs

@@ -3,32 +3,6 @@ use crate::ui;
 
 pub fn init(ui: &mut ui::Ui, frequency: u64) {
     ui::sdl_init(sdl3_sys::init::SDL_INIT_AUDIO);
-
-    let device_audio_spec = sdl3_sys::audio::SDL_AudioSpec {
-        format: sdl3_sys::audio::SDL_AUDIO_S16LE,
-        freq: 48000,
-        channels: 2,
-    };
-    ui.audio.audio_device = unsafe {
-        sdl3_sys::audio::SDL_OpenAudioDevice(
-            sdl3_sys::audio::SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK,
-            &device_audio_spec,
-        )
-    };
-    if ui.audio.audio_device == 0 {
-        panic!("Could not open audio device");
-    }
-
-    if !unsafe {
-        sdl3_sys::audio::SDL_GetAudioDeviceFormat(
-            ui.audio.audio_device,
-            &mut ui.audio.audio_device_spec,
-            std::ptr::null_mut(),
-        )
-    } {
-        panic!("Could not get audio device format");
-    }
-
     init_game_audio(ui, frequency);
 }
 
@@ -40,25 +14,26 @@ pub fn init_game_audio(ui: &mut ui::Ui, frequency: u64) {
     };
 
     ui.audio.audio_stream = unsafe {
-        sdl3_sys::audio::SDL_CreateAudioStream(&game_audio_spec, &ui.audio.audio_device_spec)
+        sdl3_sys::audio::SDL_OpenAudioDeviceStream(
+            sdl3_sys::audio::SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK,
+            &game_audio_spec,
+            None,
+            std::ptr::null_mut(),
+        )
     };
     if ui.audio.audio_stream.is_null() {
-        return;
+        panic!("Could not create audio stream");
     }
     if !unsafe {
         sdl3_sys::audio::SDL_SetAudioStreamGain(ui.audio.audio_stream, ui.audio.gain)
-            && sdl3_sys::audio::SDL_BindAudioStream(ui.audio.audio_device, ui.audio.audio_stream)
+            && sdl3_sys::audio::SDL_ResumeAudioStreamDevice(ui.audio.audio_stream)
     } {
-        panic!("Could not bind audio stream");
+        panic!("Could not resume audio stream");
     }
 }
 
 pub fn close(ui: &mut ui::Ui) {
     close_game_audio(ui);
-    unsafe {
-        sdl3_sys::audio::SDL_CloseAudioDevice(ui.audio.audio_device);
-        ui.audio.audio_device = 0;
-    }
 }
 
 pub fn close_game_audio(ui: &mut ui::Ui) {

src/ui/config.rs

@@ -29,6 +29,7 @@ pub struct InputProfile {
     pub joystick_hat: [InputJoystickHat; ui::input::PROFILE_SIZE],
     pub joystick_axis: [InputControllerAxis; ui::input::PROFILE_SIZE],
     pub dinput: bool,
+    pub deadzone: i32,
 }
 
 #[derive(serde::Serialize, serde::Deserialize)]

src/ui/gui.rs

@@ -111,6 +111,7 @@ fn settings_window(app: &AppWindow, config: &ui::config::Config) {
         1 => 0,
         2 => 1,
         4 => 2,
+        8 => 3,
         _ => 0,
     };
     app.set_resolution(combobox_value);
@@ -190,6 +191,7 @@ fn controller_window(
         std::rc::Rc::new(controllers);
     app.set_controller_names(slint::ModelRc::from(controller_names_model));
 
+    let controller_changed = slint::VecModel::default();
     let selected_controllers = slint::VecModel::default();
     for selected in config.input.controller_assignment.iter() {
         let mut found = false;
@@ -203,14 +205,20 @@ fn controller_window(
         if !found {
             selected_controllers.push(0);
         }
+        controller_changed.push(false);
     }
     let selected_controllers_model: std::rc::Rc<slint::VecModel<i32>> =
         std::rc::Rc::new(selected_controllers);
     app.set_selected_controller(slint::ModelRc::from(selected_controllers_model));
 
+    let controller_changed_model: std::rc::Rc<slint::VecModel<bool>> =
+        std::rc::Rc::new(controller_changed);
+    app.set_controller_changed(slint::ModelRc::from(controller_changed_model));
+
     let weak_app = app.as_weak();
     app.on_input_profile_button_clicked(move || {
         let dialog = InputProfileDialog::new().unwrap();
+        dialog.set_deadzone(ui::input::DEADZONE_DEFAULT);
         let weak_dialog = dialog.as_weak();
         let weak_app = weak_app.clone();
         dialog.on_profile_creation_button_clicked(move || {
@@ -220,10 +228,16 @@ fn controller_window(
                     handle.hide().unwrap();
                     let profile_name = handle.get_profile_name().into();
                     let dinput = handle.get_dinput();
+                    let deadzone = handle.get_deadzone();
 
                     tokio::spawn(async move {
                         let mut game_ui = ui::Ui::new();
-                        ui::input::configure_input_profile(&mut game_ui, profile_name, dinput);
+                        ui::input::configure_input_profile(
+                            &mut game_ui,
+                            profile_name,
+                            dinput,
+                            deadzone,
+                        );
                         update_input_profiles(&weak_app, &game_ui.config);
                     });
                 })
@@ -242,7 +256,7 @@ pub fn save_settings(app: &AppWindow, controller_paths: &[Option<String>]) {
     config.emulation.overclock = app.get_overclock_n64_cpu();
     config.emulation.disable_expansion_pak = app.get_disable_expansion_pak();
     config.emulation.usb = app.get_emulate_usb();
-    let upscale_values = [1, 2, 4];
+    let upscale_values = [1, 2, 4, 8];
     config.video.upscale = upscale_values[app.get_resolution() as usize];
 
     config.input.emulate_vru = app.get_emulate_vru();
@@ -261,8 +275,10 @@ pub fn save_settings(app: &AppWindow, controller_paths: &[Option<String>]) {
     }
 
     for (i, selected_controller) in app.get_selected_controller().iter().enumerate() {
-        config.input.controller_assignment[i] =
-            controller_paths[selected_controller as usize].clone();
+        if app.get_controller_changed().row_data(i).unwrap_or(false) {
+            config.input.controller_assignment[i] =
+                controller_paths[selected_controller as usize].clone();
+        }
     }
 }
 
@@ -464,7 +480,7 @@ fn open_rom(app: &AppWindow, usb: ui::Usb) {
             select_gb_ram[i] = Some(
                 rfd::AsyncFileDialog::new()
                     .set_title(format!("GB RAM P{}", i + 1))
-                    .add_filter("GB RAM files", &["sav", "ram", "SAV", "RAM"])
+                    .add_filter("GB RAM files", &["sav", "ram", "srm", "SAV", "RAM", "SRM"])
                     .pick_file(),
             );
         }

src/ui/gui/appwindow.slint

@@ -47,6 +47,7 @@ export component AppWindow inherits Window {
     in-out property rom_dir <=> SettingsData.rom_dir;
     in-out property emulate_vru <=> ControllerData.emulate_vru;
     in-out property controller_enabled <=> ControllerData.controller_enabled;
+    in-out property controller_changed <=> ControllerData.controller_changed;
     in-out property transferpak <=> ControllerData.transferpak;
     in-out property selected_profile_binding <=> ControllerData.selected_profile_binding;
     in-out property input_profiles <=> ControllerData.input_profiles;

src/ui/gui/controller_page.slint

@@ -13,6 +13,7 @@ export global ControllerData {
     in-out property <[string]> input_profiles;
     in-out property <[string]> controller_names;
     in-out property <[int]> selected_controller;
+    in-out property <[bool]> controller_changed;
     in-out property <bool> blank_profiles;
 }
 
@@ -114,6 +115,7 @@ export component ControllerConfig inherits Page {
                         current-index: ControllerData.selected_controller[player];
                         selected => {
                             ControllerData.selected_controller[player] = self.current-index;
+                            ControllerData.controller_changed[player] = true;
                         }
                     }
                 }

src/ui/gui/input_profile.slint

@@ -1,8 +1,9 @@
-import { StandardButton, HorizontalBox, VerticalBox, Button, LineEdit, CheckBox } from "std-widgets.slint";
+import { StandardButton, HorizontalBox, VerticalBox, Button, LineEdit, CheckBox, Slider } from "std-widgets.slint";
 
 export global InputProfileData {
     in-out property <bool> dinput;
     in-out property <string> profile_name;
+    in-out property <int> deadzone;
 }
 
 export component InputProfileDialog inherits Window {
@@ -10,6 +11,7 @@ export component InputProfileDialog inherits Window {
     callback profile_creation_button_clicked;
     in-out property dinput <=> InputProfileData.dinput;
     in-out property profile_name <=> InputProfileData.profile_name;
+    in-out property deadzone <=> InputProfileData.deadzone;
     VerticalBox {
         HorizontalBox {
             LineEdit {
@@ -21,6 +23,28 @@ export component InputProfileDialog inherits Window {
             }
         }
 
+        HorizontalBox {
+            alignment: center;
+            Text {
+                text: @tr("Deadzone Percentage");
+                vertical-alignment: center;
+            }
+
+            Slider {
+                min-width: 160px;
+                maximum: 99;
+                value: InputProfileData.deadzone;
+                changed(value) => {
+                    InputProfileData.deadzone = value;
+                }
+            }
+
+            Text {
+                text: InputProfileData.deadzone + "%";
+                vertical-alignment: center;
+            }
+        }
+
         HorizontalBox {
             alignment: center;
             CheckBox {

src/ui/gui/netplay_join.slint

@@ -9,6 +9,7 @@ export component NetplayJoin inherits Window {
     in-out property sessions <=> NetplayData.sessions;
     in-out property current_session <=> NetplayData.current_session;
     in-out property room_urls <=> NetplayData.room_urls;
+    in-out property room_ports <=> NetplayData.room_ports;
     in-out property game_name <=> NetplayData.game_name;
     in-out property game_hash <=> NetplayData.game_hash;
     in-out property game_cheats <=> NetplayData.game_cheats;
@@ -19,7 +20,7 @@ export component NetplayJoin inherits Window {
     in-out property rom_dir <=> NetplayData.rom_dir;
     callback refresh_session();
     callback select_rom(string);
-    callback join_session(string, string, string, string, string);
+    callback join_session(string, string, string, string, int);
     preferred-width: 700px;
 
     VerticalBox {
@@ -93,6 +94,7 @@ export component NetplayJoin inherits Window {
                     NetplayData.current_session = -1;
                     NetplayData.sessions = [];
                     NetplayData.room_urls = [];
+                    NetplayData.room_ports = [];
                     refresh_session();
                 }
             }
@@ -129,7 +131,7 @@ export component NetplayJoin inherits Window {
                     NetplayData.game_hash,
                     NetplayData.password,
                     NetplayData.room_urls[NetplayData.current_session],
-                    NetplayData.sessions[NetplayData.current_session][1].text);
+                    NetplayData.room_ports[NetplayData.current_session]);
                 }
             }
         }

src/ui/gui/netplay_page.slint

@@ -19,6 +19,7 @@ export global NetplayData {
     in-out property <string> session_name;
     in-out property <[[StandardListViewItem]]> sessions;
     in-out property <[string]> room_urls;
+    in-out property <[int]> room_ports;
     in-out property <int> current_session: -1;
     in-out property <string> rom_dir;
     in-out property <string> custom_server_url;

src/ui/gui/settings_page.slint

@@ -29,7 +29,7 @@ export component Settings inherits Page {
             }
 
             ComboBox {
-                model: ["1x", "2x", "4x"];
+                model: ["1x", "2x", "4x", "8x"];
                 current-index: SettingsData.resolution;
                 selected => {
                     SettingsData.resolution = self.current-index;

src/ui/input.rs

@@ -28,6 +28,8 @@ const Y_AXIS_SHIFT: usize = 24;
 
 const MAX_AXIS_VALUE: f64 = 85.0;
 
+pub const DEADZONE_DEFAULT: i32 = 5;
+
 pub struct Controllers {
     pub rumble: bool,
     pub game_controller: *mut sdl3_sys::gamepad::SDL_Gamepad,
@@ -40,7 +42,7 @@ pub struct InputData {
 }
 
 fn bound_axis(x: &mut f64, y: &mut f64) {
-    let radius = 95.0; // this is roughly the maxium diagonal distance of the controller
+    let radius = f64::sqrt(70.0 * 70.0 + 70.0 * 70.0); // this is roughly the maxium diagonal distance of the controller
 
     // Calculate the distance from the origin (0, 0)
     let distance = f64::sqrt((*x) * (*x) + (*y) * (*y));
@@ -53,6 +55,24 @@ fn bound_axis(x: &mut f64, y: &mut f64) {
     }
 }
 
+fn apply_deadzone(x: &mut f64, y: &mut f64, deadzone: i32) {
+    let axis_deadzone = MAX_AXIS_VALUE * (deadzone as f64 / 100.0);
+
+    // Calculate the distance from the origin (0, 0)
+    let distance = f64::sqrt((*x) * (*x) + (*y) * (*y));
+
+    if distance <= axis_deadzone {
+        *x = 0.0;
+        *y = 0.0;
+        return;
+    }
+
+    let new_distance =
+        (distance - axis_deadzone) * MAX_AXIS_VALUE / (MAX_AXIS_VALUE - axis_deadzone);
+    *x = *x / distance * new_distance;
+    *y = *y / distance * new_distance;
+}
+
 fn set_axis_from_joystick(
     profile: &ui::config::InputProfile,
     joystick: *mut sdl3_sys::joystick::SDL_Joystick,
@@ -365,8 +385,6 @@ pub fn get_controller_paths(game_ui: &ui::Ui) -> Vec<Option<String>> {
 }
 
 pub fn get(ui: &ui::Ui, channel: usize) -> InputData {
-    unsafe { sdl3_sys::events::SDL_PumpEvents() };
-
     let profile_name = ui.config.input.input_profile_binding[channel].clone();
     let profile = ui.config.input.input_profiles.get(&profile_name).unwrap();
     let mut keys = 0;
@@ -409,9 +427,11 @@ pub fn get(ui: &ui::Ui, channel: usize) -> InputData {
     }
 
     if !controller.is_null() {
-        (x, y) = set_axis_from_controller(profile, controller)
+        (x, y) = set_axis_from_controller(profile, controller);
+        apply_deadzone(&mut x, &mut y, profile.deadzone);
     } else if !joystick.is_null() {
-        (x, y) = set_axis_from_joystick(profile, joystick)
+        (x, y) = set_axis_from_joystick(profile, joystick);
+        apply_deadzone(&mut x, &mut y, profile.deadzone);
     }
     bound_axis(&mut x, &mut y);
 
@@ -466,7 +486,7 @@ fn close_controllers(
     }
 }
 
-pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
+pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool, deadzone: i32) {
     ui::sdl_init(sdl3_sys::init::SDL_INIT_VIDEO);
     ui::ttf_init();
 
@@ -680,6 +700,13 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
                 }
             }
         }
+        ui::video::draw_text(
+            format!("Binding set for {key}").as_str(),
+            renderer,
+            text_engine,
+            font,
+        );
+        std::thread::sleep(std::time::Duration::from_millis(200));
     }
 
     close_controllers(open_joysticks, open_controllers);
@@ -699,6 +726,7 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
         joystick_hat: new_joystick_hat,
         joystick_axis: new_joystick_axis,
         dinput,
+        deadzone,
     };
     ui.config.input.input_profiles.insert(profile, new_profile);
 }
@@ -899,6 +927,7 @@ pub fn get_default_profile() -> ui::config::InputProfile {
             axis: 0,
         }; PROFILE_SIZE],
         dinput: false,
+        deadzone: DEADZONE_DEFAULT,
     }
 }
 

src/ui/netplay.rs

@@ -111,7 +111,7 @@ impl NetplayPages for NetplayJoin {
 fn populate_server_names<T: ComponentHandle + NetplayPages + 'static>(weak: slint::Weak<T>) {
     let task = reqwest::Client::new()
         .get("https://dispatch.gopher64.com/getRegions")
-        .header("netplay-id", EMU_NAME)
+        .header("netplay-id", env!("NETPLAY_ID"))
         .send();
     tokio::spawn(async move {
         let mut local_servers: Vec<(String, String)> = vec![];
@@ -140,31 +140,34 @@ fn populate_server_names<T: ComponentHandle + NetplayPages + 'static>(weak: slin
         }
 
         let response = task.await;
-        if let Ok(response) = response
+        let public_servers = if let Ok(response) = response
             && let Ok(servers) = response.json::<Vec<String>>().await
         {
-            weak.upgrade_in_event_loop(move |handle| {
-                let server_names: slint::VecModel<slint::SharedString> = slint::VecModel::default();
-                let server_urls: slint::VecModel<slint::SharedString> = slint::VecModel::default();
-                for local_server in local_servers {
-                    server_names.push(local_server.0.into());
-                    server_urls.push(local_server.1.into());
-                }
-                for server in servers {
-                    server_names.push(server.clone().into());
-                    server_urls.push(format!("dispatcher:{server}").into());
-                }
-                server_names.push("Custom".into());
-                handle.refresh_sessions();
-                let server_names_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
-                    std::rc::Rc::new(server_names);
-                let server_urls_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
-                    std::rc::Rc::new(server_urls);
-                handle.set_server_names(slint::ModelRc::from(server_names_model));
-                handle.set_server_urls(slint::ModelRc::from(server_urls_model));
-            })
-            .unwrap();
-        }
+            servers
+        } else {
+            vec![]
+        };
+        weak.upgrade_in_event_loop(move |handle| {
+            let server_names: slint::VecModel<slint::SharedString> = slint::VecModel::default();
+            let server_urls: slint::VecModel<slint::SharedString> = slint::VecModel::default();
+            for local_server in local_servers {
+                server_names.push(local_server.0.into());
+                server_urls.push(local_server.1.into());
+            }
+            for server in public_servers {
+                server_names.push(server.clone().into());
+                server_urls.push(format!("dispatcher:{server}").into());
+            }
+            server_names.push("Custom".into());
+            handle.refresh_sessions();
+            let server_names_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
+                std::rc::Rc::new(server_names);
+            let server_urls_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
+                std::rc::Rc::new(server_urls);
+            handle.set_server_names(slint::ModelRc::from(server_names_model));
+            handle.set_server_urls(slint::ModelRc::from(server_urls_model));
+        })
+        .unwrap();
     });
 }
 
@@ -296,7 +299,7 @@ pub fn setup_create_window(
                 let task = reqwest::Client::new()
                     .get("https://dispatch.gopher64.com/createServer")
                     .query(&[("region", server_url.strip_prefix("dispatcher:").unwrap())])
-                    .header("netplay-id", EMU_NAME)
+                    .header("netplay-id", env!("NETPLAY_ID"))
                     .send();
                 let netplay_read_sender = netplay_read_sender.clone();
                 let netplay_write_receiver = netplay_write_receiver.resubscribe();
@@ -448,7 +451,7 @@ fn show_netplay_error(message: String) {
 fn update_sessions(weak: slint::Weak<NetplayJoin>) {
     let task = reqwest::Client::new()
         .get("https://dispatch.gopher64.com/getServers")
-        .header("netplay-id", EMU_NAME)
+        .header("netplay-id", env!("NETPLAY_ID"))
         .send();
     tokio::spawn(async move {
         let mut dispatcher_servers = std::collections::HashMap::new();
@@ -491,6 +494,7 @@ fn update_sessions(weak: slint::Weak<NetplayJoin>) {
             tokio::spawn(async move {
                 let mut sessions = vec![];
                 let mut room_urls = vec![];
+                let mut room_ports = vec![];
                 for (server_name, server_url) in servers.iter() {
                     if let Ok(Ok((socket, _response))) = tokio::time::timeout(
                         std::time::Duration::from_secs(2),
@@ -533,6 +537,7 @@ fn update_sessions(weak: slint::Weak<NetplayJoin>) {
                             for room in rooms {
                                 let mut session = vec![];
                                 room_urls.push(server_url.into());
+                                room_ports.push(room.port.unwrap());
 
                                 session.push(slint::StandardListViewItem::from(
                                     slint::SharedString::from(server_name),
@@ -585,6 +590,11 @@ fn update_sessions(weak: slint::Weak<NetplayJoin>) {
                             std::rc::Rc::new(room_urls_vec);
                         handle.set_room_urls(slint::ModelRc::from(room_urls_model));
 
+                        let room_ports_vec = slint::VecModel::from(room_ports.to_vec());
+                        let room_ports_model: std::rc::Rc<slint::VecModel<i32>> =
+                            std::rc::Rc::new(room_ports_vec);
+                        handle.set_room_ports(slint::ModelRc::from(room_ports_model));
+
                         handle.set_current_session(-1);
                         handle.set_pending_refresh(false);
                     })
@@ -732,7 +742,7 @@ fn join_session(
     player_name: String,
     game_hash: String,
     password: String,
-    room_name: String,
+    room_port: i32,
     fullscreen: bool,
     weak_app: slint::Weak<AppWindow>,
     weak: slint::Weak<NetplayJoin>,
@@ -740,73 +750,26 @@ fn join_session(
     tokio::spawn(async move {
         let now_utc = chrono::Utc::now().timestamp_millis().to_string();
         let hasher = Sha256::new().chain_update(&now_utc).chain_update(EMU_NAME);
-        let request_rooms = NetplayMessage {
-            message_type: "request_get_rooms".to_string(),
-            player_name: None,
-            client_sha: None,
-            netplay_version: Some(NETPLAY_VERSION),
-            player_names: None,
-            emulator: Some(EMU_NAME.to_string()),
-            accept: None,
-            rooms: None,
-            message: None,
-            auth_time: Some(now_utc),
-            auth: Some(format!("{:x}", hasher.finalize())),
-            room: None,
-        };
-
-        netplay_write_sender.send(Some(request_rooms)).unwrap();
-
-        let mut port = 0;
-        match tokio::time::timeout(
-            std::time::Duration::from_secs(2),
-            netplay_read_receiver.recv(),
-        )
-        .await
-        {
-            Ok(Ok(message)) => {
-                if message.message_type == "reply_get_rooms"
-                    && message.accept.unwrap() == 0
-                    && let Some(rooms) = message.rooms
-                {
-                    for room in rooms {
-                        if room.room_name.unwrap() == room_name {
-                            port = room.port.unwrap_or(0);
-                        }
-                    }
-                }
-            }
-            Ok(Err(err)) => {
-                panic!("netplay_read_receiver error: {err}");
-            }
-            Err(_) => {
-                weak.upgrade_in_event_loop(move |handle| {
-                    handle.set_pending_session(false);
-                    show_netplay_error("Server did not respond".to_string());
-                })
-                .unwrap();
-            }
-        }
 
         let join_room = NetplayMessage {
             message_type: "request_join_room".to_string(),
             player_name: Some(player_name),
             client_sha: Some(env!("GIT_HASH").to_string()),
-            netplay_version: None,
-            emulator: None,
+            netplay_version: Some(NETPLAY_VERSION),
+            emulator: Some(EMU_NAME.to_string()),
             accept: None,
             message: None,
             rooms: None,
-            auth_time: None,
             player_names: None,
-            auth: None,
+            auth_time: Some(now_utc),
+            auth: Some(format!("{:x}", hasher.finalize())),
             room: Some(NetplayRoom {
                 room_name: None,
                 password: Some(password),
                 game_name: None,
                 md5: Some(game_hash),
                 protected: None,
-                port: Some(port),
+                port: Some(room_port),
                 features: None,
                 buffer_target: None,
             }),
@@ -1200,7 +1163,7 @@ pub fn setup_join_window(
     });
     let weak = join_window.as_weak();
     join_window.on_join_session(
-        move |player_name, game_hash, password, room_url, room_name| {
+        move |player_name, game_hash, password, room_url, room_port| {
             let _ = netplay_write_sender.send(None); // close current websocket if any
             manage_websocket(
                 room_url.to_string(),
@@ -1215,7 +1178,7 @@ pub fn setup_join_window(
                 player_name.to_string(),
                 game_hash.to_string(),
                 password.to_string(),
-                room_name.to_string(),
+                room_port,
                 fullscreen,
                 weak_app.clone(),
                 weak.clone(),

src/ui/video.rs

@@ -93,10 +93,13 @@ pub fn close(ui: &ui::Ui) {
 }
 
 pub fn update_screen() {
-    // when the window is closed, running is set to false
     unsafe { rdp_update_screen() }
 }
 
+pub fn render_frame() {
+    unsafe { rdp_render_frame() }
+}
+
 pub fn state_size() -> usize {
     unsafe { rdp_state_size() }
 }
@@ -130,9 +133,21 @@ pub fn load_state(device: &mut device::Device, rdp_state: *const u8) {
     }
 }
 
-pub fn check_callback(device: &mut device::Device) -> bool {
+pub fn pause_loop(frame_time: f64) {
+    let mut paused = true;
+    let mut frame_advance = false;
+    while paused && !frame_advance {
+        std::thread::sleep(std::time::Duration::from_secs_f64(frame_time));
+        unsafe { sdl3_sys::events::SDL_PumpEvents() };
+        let callback = unsafe { rdp_check_callback() };
+        paused = callback.paused;
+        frame_advance = callback.frame_advance;
+    }
+}
+
+pub fn check_callback(device: &mut device::Device) -> (bool, bool) {
     let mut speed_limiter_toggled = false;
-    let mut callback = unsafe { rdp_check_callback() };
+    let callback = unsafe { rdp_check_callback() };
     device.cpu.running = callback.emu_running;
     if device.netplay.is_none() {
         if callback.save_state {
@@ -144,11 +159,6 @@ pub fn check_callback(device: &mut device::Device) -> bool {
             speed_limiter_toggled = true;
             device.vi.enable_speed_limiter = callback.enable_speedlimiter;
         }
-        while callback.paused && !callback.frame_advance {
-            std::thread::sleep(std::time::Duration::from_secs_f64(1.0 / 60.0));
-            unsafe { sdl3_sys::events::SDL_PumpEvents() };
-            callback = unsafe { rdp_check_callback() };
-        }
     }
 
     if device.ui.storage.save_state_slot != callback.save_state_slot {
@@ -169,7 +179,7 @@ pub fn check_callback(device: &mut device::Device) -> bool {
     } else if callback.raise_volume {
         ui::audio::raise_audio_volume(&mut device.ui);
     }
-    speed_limiter_toggled
+    (speed_limiter_toggled, callback.paused)
 }
 
 pub fn set_register(reg: u32, value: u32) {
@@ -182,6 +192,10 @@ pub fn process_rdp_list() -> u64 {
     unsafe { rdp_process_commands() }
 }
 
+pub fn check_framebuffers(address: u32, length: u32) {
+    unsafe { rdp_check_framebuffers(address, length) }
+}
+
 pub fn onscreen_message(_ui: &ui::Ui, message: &str) {
     unsafe { rdp_onscreen_message(std::ffi::CString::new(message).unwrap().as_ptr()) };
 }

src/ui/vru.rs

@@ -2,6 +2,7 @@ pub fn prompt_for_match(
     words: &[String],
     window_notifier: &tokio::sync::mpsc::Sender<Option<Vec<String>>>,
     word_index_receiver: &mut tokio::sync::mpsc::Receiver<String>,
+    frame_time: f64,
 ) -> u16 {
     let mut dedup_words = words.to_owned();
     dedup_words.sort();
@@ -10,7 +11,7 @@ pub fn prompt_for_match(
     let mut result = word_index_receiver.try_recv();
     while result.is_err() {
         result = word_index_receiver.try_recv();
-        std::thread::sleep(std::time::Duration::from_secs_f64(1.0 / 60.0));
+        std::thread::sleep(std::time::Duration::from_secs_f64(frame_time));
         unsafe { sdl3_sys::events::SDL_PumpEvents() }; // so the OS doesn't complain about the game window being frozen
     }
     for (i, v) in words.iter().enumerate() {