Update parallel-rdp

* flush saves to disk

* more

* more

* more

* more

* more

* more

* more

* more

.cargo/config.toml

@@ -1,5 +1,16 @@
+[target.'cfg(all(target_arch = "aarch64", target_os = "linux"))']
+rustflags = ["-C", "link-arg=-fuse-ld=lld"]
+
+[target.'cfg(target_os = "windows")']
+linker = "rust-lld"
+
 [target.'cfg(target_arch = "x86_64")']
 rustflags = ["-C", "target-cpu=x86-64-v3"]
 
 [target.'cfg(target_arch = "aarch64")']
 rustflags = ["-C", "target-cpu=cortex-a76"]
+
+[env]
+CC = "clang"
+CXX = "clang++"
+AR = "llvm-ar"

.github/dependabot.yml

@@ -3,8 +3,12 @@ updates:
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "daily"
-  - package-ecosystem: "cargo"
+      interval: "weekly"
+  - package-ecosystem: "rust-toolchain"
     directory: "/"
     schedule:
-      interval: "daily"
+      interval: "weekly"
+# - package-ecosystem: "cargo"
+#   directory: "/"
+#   schedule:
+#     interval: "daily"

.github/workflows/build.yml

@@ -1,8 +1,12 @@
 name: Rust
+permissions:
+  contents: read
 
 on:
   push:
     branches: ["main"]
+    tags:
+      - "v*"
   pull_request:
     branches: ["main"]
 
@@ -19,69 +23,114 @@ jobs:
           - os: ubuntu-24.04
             target: x86_64-unknown-linux-gnu
             arch: linux-x86_64
+            llvm: X64
           - os: ubuntu-24.04-arm
             target: aarch64-unknown-linux-gnu
             arch: linux-aarch64
+            llvm: ARM64
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           target: ${{ matrix.target }}
           rustflags: ""
+      - name: Set LLVM_VERSION
+        run: echo "LLVM_VERSION=$(rustc --version --verbose | grep "LLVM version" | cut -d':' -f2 | xargs)" >> $GITHUB_ENV
       - name: Install SDL Dependencies
-        # https://wiki.libsdl.org/SDL3/README/linux#build-dependencies
+        # https://wiki.libsdl.org/SDL3/README-linux#build-dependencies
         uses: awalsh128/cache-apt-pkgs-action@v1
         with:
           packages: build-essential git make \
             pkg-config cmake ninja-build gnome-desktop-testing libasound2-dev libpulse-dev \
             libaudio-dev libjack-dev libsndio-dev libx11-dev libxext-dev \
-            libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev \
+            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
+        with:
+          version: ${{ env.LLVM_VERSION }}
+          force-url: https://github.com/llvm/llvm-project/releases/download/llvmorg-${{ env.LLVM_VERSION }}/LLVM-${{ env.LLVM_VERSION }}-Linux-${{ matrix.llvm }}.tar.xz
       - name: Build
         run: |
           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@v7
         with:
           name: gopher64-${{ matrix.arch }}
           path: output/gopher64-${{ matrix.arch }}
+          archive: false
 
   build-windows:
-    runs-on: windows-2025
+    runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
         include:
-          - target: x86_64-pc-windows-msvc
+          - os: windows-2025
+            target: x86_64-pc-windows-msvc
             arch: windows-x86_64
+            llvm: win64
+          #- os: windows-11-arm
+          #  target: aarch64-pc-windows-msvc
+          #  arch: windows-aarch64
+          #  llvm: woa64
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           target: ${{ matrix.target }}
           rustflags: ""
+      - name: Set LLVM_VERSION
+        run: |
+          $llvm_version = rustc --version --verbose | Select-String "LLVM version" | ForEach-Object { $_.Line.Split(":")[1].Trim() }
+          echo "LLVM_VERSION=$llvm_version" >> $env:GITHUB_ENV
+      - name: Install LLVM and Clang
+        uses: KyleMayes/install-llvm-action@v2
+        with:
+          version: ${{ env.LLVM_VERSION }}
+          force-url: https://github.com/llvm/llvm-project/releases/download/llvmorg-${{ env.LLVM_VERSION }}/LLVM-${{ env.LLVM_VERSION }}-${{ matrix.llvm }}.exe
       - name: Build
         run: |
           cargo build --release -v --target=${{ matrix.target }}
           mkdir output
           cp target/${{ matrix.target }}/release/gopher64.exe output/gopher64-${{ matrix.arch }}.exe
-      - name: Upload file
-        uses: actions/upload-artifact@v4
+        env:
+          CC: clang-cl
+          CXX: clang-cl
+          NETPLAY_ID: ${{ secrets.NETPLAY_ID }}
+      - name: Upload unsigned artifact
+        id: upload-unsigned-artifact
+        uses: actions/upload-artifact@v7
         with:
           name: gopher64-${{ matrix.arch }}
           path: output/gopher64-${{ matrix.arch }}.exe
+          archive: false
+      - name: SignPath
+        if: ${{ github.ref_type == 'tag' }}
+        uses: signpath/github-action-submit-signing-request@v2.0
+        with:
+          api-token: "${{ secrets.SIGNPATH_API_TOKEN }}"
+          organization-id: "${{ secrets.SIGNPATH_ORG_ID }}"
+          project-slug: "gopher64"
+          artifact-configuration-slug: "gopher64-${{ matrix.arch }}"
+          signing-policy-slug: "release-signing"
+          github-artifact-id: "${{ steps.upload-unsigned-artifact.outputs.artifact-id }}"
+          wait-for-completion: false
 
   build-macos:
-    runs-on: macos-14
+    if: false
+    runs-on: macos-15
     strategy:
       fail-fast: false
       matrix:
@@ -91,7 +140,7 @@ jobs:
           - target: aarch64-apple-darwin
             arch: mac-aarch64
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -103,8 +152,12 @@ jobs:
           cargo build --release -v --target=${{ matrix.target }}
           mkdir output
           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@v7
         with:
           name: gopher64-${{ matrix.arch }}
           path: output/gopher64-${{ matrix.arch }}
+          archive: false

.github/workflows/lint.yml

@@ -6,6 +6,9 @@ on:
   pull_request:
     branches: ["main"]
 
+permissions:
+  contents: read
+
 env:
   CARGO_TERM_COLOR: always
 
@@ -13,24 +16,31 @@ jobs:
   lint-linux:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           components: clippy, rustfmt
+      - name: Set LLVM_VERSION
+        run: echo "LLVM_VERSION=$(rustc --version --verbose | grep "LLVM version" | cut -d':' -f2 | xargs)" >> $GITHUB_ENV
       - name: Install SDL Dependencies
-        # https://wiki.libsdl.org/SDL3/README/linux#build-dependencies
+        # https://wiki.libsdl.org/SDL3/README-linux#build-dependencies
         uses: awalsh128/cache-apt-pkgs-action@v1
         with:
           packages: build-essential git make \
             pkg-config cmake ninja-build gnome-desktop-testing libasound2-dev libpulse-dev \
             libaudio-dev libjack-dev libsndio-dev libx11-dev libxext-dev \
-            libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev \
+            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
+        with:
+          version: ${{ env.LLVM_VERSION }}
+          force-url: https://github.com/llvm/llvm-project/releases/download/llvmorg-${{ env.LLVM_VERSION }}/LLVM-${{ env.LLVM_VERSION }}-Linux-X64.tar.xz
       - name: Rustfmt Check
         uses: actions-rust-lang/rustfmt@v1
       - name: Lint

.github/workflows/sec.yml

@@ -0,0 +1,18 @@
+name: Security audit
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 0 * * *"
+jobs:
+  audit:
+    permissions:
+      issues: write
+      checks: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          submodules: recursive
+      - uses: rustsec/audit-check@v2
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -9,7 +9,7 @@ target/
 # MSVC Windows builds of rustc generate these, which store debugging information
 *.pdb
 
-
+.vscode/settings.json
 # Added by cargo
 
 /target

.gitmodules

@@ -1,3 +1,7 @@
 [submodule "parallel-rdp/parallel-rdp-standalone"]
 	path = parallel-rdp/parallel-rdp-standalone
-	url = https://github.com/Themaister/parallel-rdp-standalone.git
+	url = https://github.com/gopher64/parallel-rdp-standalone.git
+	branch = gopher64
+[submodule "src/compat/sse2neon"]
+	path = src/compat/sse2neon
+	url = https://github.com/DLTcollab/sse2neon.git

Cargo.toml

@@ -1,45 +1,54 @@
 [package]
 name = "gopher64"
-version = "1.0.10"
+version = "1.1.15"
 edition = "2024"
-rust-version = "1.85"
+rust-version = "1.94.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 dirs = "6.0"
-zip = "2.1"
-governor = "0.8"
-sevenz-rust = "0.6"
+zip = "8.0"
+governor = "0.10"
+sevenz-rust2 = "0.20"
 chrono = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde-big-array = "0.5"
-eframe = { version = "0.31", default-features = false, features = ["wayland", "x11", "wgpu"] }
+slint = { version = "1.15", default-features = false, features = ["compat-1-2", "std", "backend-winit", "renderer-skia"] }
+open = "5.3"
 sha2 = "0.10"
-rusttype = "0.9"
-sdl3-sys = { version = "0.4", features = ["build-from-source-static"] }
-rfd = { version = "0.15", default-features = false, features = ["xdg-portal", "tokio"] }
-tokio = {version = "1.43", features = ["rt-multi-thread", "macros"] }
+sdl3-sys = { version = "0.6", features = ["build-from-source-static"] }
+sdl3-ttf-sys = { version = "0.6", features = ["build-from-source-static", "no-sdlttf-harfbuzz", "no-sdlttf-plutosvg"] }
+rfd = "0.17"
+tokio = {version = "1.46", features = ["rt-multi-thread", "macros", "fs"] }
 spin_sleep = "1.3"
 encoding_rs = "0.8"
 mimalloc = "0.1"
 regex = "1.11"
-tungstenite = "0.26"
-socket2 = "0.5"
-rand_chacha = "0.9"
+tokio-tungstenite = "0.28"
+futures = "0.3"
+socket2 = { version = "0.6", features = ["all"] }
+rand = "0.10"
 fatfs = "0.3"
 semver = "1.0"
 postcard = { version = "1.1", features = ["use-std"] }
 clap = { version = "4.5", features = ["derive"] }
-reqwest = { version = "0.12", default-features = false, features = ["http2","rustls-tls","charset","json"] }
+reqwest = { version = "0.13", features = ["json", "query"] }
 
 [build-dependencies]
-winres = "0.1"
-bindgen = "0.71"
+winresource = "0.1"
+bindgen = "0.72"
+slint-build = "1.12"
 cc = { version = "1.2", features = ["parallel"] }
 
 [profile.release]
-codegen-units = 1
-strip = true
 panic = "abort"
+lto = "thin"
+strip = true
+
+[profile.release-with-debug]
+inherits = "release"
+debug = true
+strip = false
+panic = "unwind"

README.md

@@ -1,7 +1,9 @@
 # gopher64
 ## download
 
-https://github.com/gopher64/gopher64/releases
+Windows: https://github.com/gopher64/gopher64/releases/latest/download/gopher64-windows-x86_64.exe
+
+Linux: https://flathub.org/apps/io.github.gopher64.gopher64
 
 ## wiki
 
@@ -15,17 +17,13 @@ https://discord.gg/9RGXq8W8JQ
 
 Keys are mapped according to [these defaults](https://github.com/gopher64/gopher64/wiki/Default-Keyboard-Setup). Xbox-style controllers also have a [default mapping applied](https://github.com/gopher64/gopher64/wiki/Default-Gamepad-Setup).
 
-You can create you own mappings by running `./gopher64 --configure-input-profile my_profile`. You then bind that profile to a port: `./gopher64 --bind-input-profile my_profile --port 1`
-
-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`
-
 ## netplay
 
-Gopher64 supports netplay (online play with others). It has a few public netplay servers. If you are interested in running a public netplay server, please let me know (open an issue or discussion, or contact me on Discord). You can also run the server (https://github.com/simple64/simple64-netplay-server) yourself on a LAN.
+Gopher64 supports netplay (online play with others) via cloud hosted servers. You can also run the server (https://github.com/gopher64/gopher64-netplay-server) yourself on a LAN.
 
 ## 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.
+If you would like to keep all the game data in the same folder as the executable, you just need to create a file called "portable.txt" in the same directory as the executable.
 
 ## flatpak
 
@@ -35,15 +33,9 @@ If you want to run the flatpak from the command line, you need to add the `--fil
 flatpak run --filesystem=host:ro io.github.gopher64.gopher64 /path/to/rom.z64
 ```
 
-## goals
-
-1. Performance. I want to be able to use this emulator on my laptop.
-2. Easy to use.
-3. Easy to work on. Dynamic recompilers perform well, but they are very hard to read and understand. This emulator will only have interpreters for the CPU and RSP. Additionally, it is completely written in Rust (besides Parallel-RDP), a modern programming language with a growing user base. I've tried to avoid the use of macros, which can reduce some repetitiveness in the code, but also reduce readability.
-
 ## building and usage
 
-1. Linux only: install the SDL3 dependencies: https://wiki.libsdl.org/SDL3/README/linux
+1. Linux only: install the SDL3 dependencies: https://wiki.libsdl.org/SDL3/README-linux#build-dependencies
 2. Install rust: https://www.rust-lang.org/tools/install
 3. `git clone --recursive https://github.com/gopher64/gopher64.git`
 4. `cd gopher64`
@@ -52,8 +44,14 @@ flatpak run --filesystem=host:ro io.github.gopher64.gopher64 /path/to/rom.z64
 
 ## 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.
+I am very open to contributions! Please contact me via a GitHub issue or Discord (loganmc10) before doing substantial work on a PR.
 
 ## license
 
 Gopher64 is licensed under the GPLv3 license. Many portions of gopher64 have been adapted from mupen64plus and/or ares. The license for mupen64plus can be found here: https://github.com/mupen64plus/mupen64plus-core/blob/master/LICENSES. The license for ares can be found here: https://github.com/ares-emulator/ares/blob/master/LICENSE.
+
+## privacy and code signing policy
+
+Free code signing for the Windows release is provided by [SignPath.io](https://about.signpath.io), certificate by [SignPath Foundation](https://signpath.org).
+
+During online netplay sessions, the server logs your IP address and basic session information (game title and session name) for operational purposes. No additional personal data is collected or stored.

build.rs

@@ -2,12 +2,21 @@ fn main() {
     println!("cargo::rerun-if-changed=parallel-rdp");
     println!("cargo::rerun-if-changed=src/compat");
 
+    let slint_config = slint_build::CompilerConfiguration::new().with_style("cosmic".into());
+    slint_build::compile_with_config("src/ui/gui/appwindow.slint", slint_config).unwrap();
+
     let mut simd_build = cc::Build::new();
-    let mut build = cc::Build::new();
-    build
+    let mut volk_build = cc::Build::new();
+    volk_build
+        .std("c17")
+        .include("parallel-rdp/parallel-rdp-standalone/vulkan-headers/include")
+        .file("parallel-rdp/parallel-rdp-standalone/volk/volk.c");
+    let mut rdp_build = cc::Build::new();
+    rdp_build
         .cpp(true)
-        .warnings(false)
-        .std("c++17")
+        .std("c++23")
+        .flag("-Wno-unused-parameter")
+        .flag("-Wno-missing-field-initializers")
         .file("parallel-rdp/parallel-rdp-standalone/parallel-rdp/command_ring.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/parallel-rdp/rdp_device.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/parallel-rdp/rdp_dump_write.cpp")
@@ -27,9 +36,11 @@ fn main() {
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/image.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/indirect_layout.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/memory_allocator.cpp")
+        .file("parallel-rdp/parallel-rdp-standalone/vulkan/pipeline_cache.cpp")
         .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")
@@ -44,7 +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/volk/volk.c")
+        .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")
@@ -55,40 +66,42 @@ fn main() {
         .include(
             std::path::PathBuf::from(std::env::var("DEP_SDL3_OUT_DIR").to_owned().unwrap())
                 .join("include"),
+        )
+        .include(
+            std::path::PathBuf::from(std::env::var("DEP_SDL3_TTF_OUT_DIR").to_owned().unwrap())
+                .join("include"),
         );
 
     let os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
     let arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap();
-    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");
+    let opt_flag = if arch == "x86_64" {
+        "-march=x86-64-v3"
+    } else if arch == "aarch64" {
+        "-march=armv8.2-a"
+    } else {
+        panic!("unknown arch")
+    };
 
-        winres::WindowsResource::new()
-            .set_icon("data/icon.ico")
+    volk_build.flag(opt_flag);
+    rdp_build.flag(opt_flag);
+    simd_build.flag(opt_flag);
+
+    if os == "windows" {
+        volk_build.flag("-DVK_USE_PLATFORM_WIN32_KHR");
+        rdp_build.flag("-DVK_USE_PLATFORM_WIN32_KHR");
+
+        winresource::WindowsResource::new()
+            .set_icon("data/icon/icon.ico")
             .compile()
             .unwrap();
-    } 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.flag("-DSSE2NEON_SUPPRESS_WARNINGS");
-            simd_build.file("src/compat/aarch64.c");
-        } else {
-            panic!("unknown arch")
-        }
-    } else {
-        panic!("unknown OS")
     }
 
-    build.compile("parallel-rdp");
+    volk_build.flag("-flto=thin");
+    rdp_build.flag("-flto=thin");
+    simd_build.flag("-flto=thin");
+
+    volk_build.compile("volk");
+    rdp_build.compile("parallel-rdp");
 
     let out_path = std::path::PathBuf::from(std::env::var("OUT_DIR").unwrap());
 
@@ -98,11 +111,15 @@ 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_full_sync")
+        .allowlist_function("rdp_state_size")
+        .allowlist_function("rdp_save_state")
+        .allowlist_function("rdp_load_state")
         .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
         .generate()
         .expect("Unable to generate bindings");
@@ -113,7 +130,7 @@ fn main() {
 
     if arch == "aarch64" {
         let simd_bindings = bindgen::Builder::default()
-            .header("src/compat/sse2neon/v1.8.0/sse2neon.h")
+            .header("src/compat/sse2neon/sse2neon.h")
             .allowlist_function("_mm_setzero_si128")
             .allowlist_function("_mm_set_epi8")
             .allowlist_function("_mm_movemask_epi8")
@@ -147,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)
@@ -158,9 +176,14 @@ fn main() {
             .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");
+        simd_build
+            .std("c17")
+            .flag("-D_POSIX_C_SOURCE=200112L")
+            .flag("-DSSE2NEON_SUPPRESS_WARNINGS")
+            .file("src/compat/aarch64.c")
+            .file(std::env::temp_dir().join("bindgen").join("extern.c"))
+            .include(".")
+            .compile("simd");
     }
 
     let git_output = std::process::Command::new("git")
@@ -169,7 +192,10 @@ fn main() {
         .unwrap();
 
     let git_hash = String::from_utf8(git_output.stdout).unwrap();
-    println!("cargo:rustc-env=GIT_HASH={}", git_hash);
+    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);
 }

data/icon/generate.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+magick gopher64.png -resize 512x512 gopher64_512x512.png
+magick gopher64.png -resize 256x256 gopher64_256x256.png
+magick gopher64.png -resize 128x128 gopher64_128x128.png
+magick gopher64.png -resize 256x256 icon.ico

data/shader/crt-aperture.frag

@@ -0,0 +1,135 @@
+#version 450
+
+/*
+    CRT Shader by EasyMode
+    License: GPL
+*/
+
+layout(push_constant) uniform Push
+{
+	vec4 SourceSize;
+	vec4 OutputSize;
+} params;
+
+#define SHARPNESS_IMAGE 1.0
+#define SHARPNESS_EDGES 3.0
+#define GLOW_WIDTH 0.5
+#define GLOW_HEIGHT 0.5
+#define GLOW_HALATION 0.1
+#define GLOW_DIFFUSION 0.05
+#define MASK_COLORS 2.0
+#define MASK_STRENGTH 0.3
+#define MASK_SIZE 1.0
+#define SCANLINE_SIZE_MIN 0.5
+#define SCANLINE_SIZE_MAX 1.5
+#define SCANLINE_SHAPE 2.5
+#define SCANLINE_OFFSET 1.0
+#define GAMMA_INPUT 2.4
+#define GAMMA_OUTPUT 2.4
+#define BRIGHTNESS 1.5
+
+layout(std140, set = 0, binding = 0) uniform UBO
+{
+	mat4 MVP;
+} global;
+
+#define FIX(c) max(abs(c), 1e-5)
+#define PI 3.141592653589
+#define TEX2D(c) pow(texture(tex, c).rgb, vec3(GAMMA_INPUT))
+#define saturate(c) clamp(c, 0.0, 1.0)
+
+mat3x3 get_color_matrix(sampler2D tex, vec2 co, vec2 dx)
+{
+    return mat3x3(TEX2D(co - dx), TEX2D(co), TEX2D(co + dx));
+}
+
+vec3 blur(mat3 m, float dist, float rad)
+{
+    vec3 x = vec3(dist - 1.0, dist, dist + 1.0) / rad;
+    vec3 w = exp2(x * x * -1.0);
+
+    return (m[0] * w.x + m[1] * w.y + m[2] * w.z) / (w.x + w.y + w.z);
+}
+
+vec3 filter_gaussian(sampler2D tex, vec2 co, vec2 tex_size)
+{
+    vec2 dx = vec2(1.0 / tex_size.x, 0.0);
+    vec2 dy = vec2(0.0, 1.0 / tex_size.y);
+    vec2 pix_co = co * tex_size;
+    vec2 tex_co = (floor(pix_co) + 0.5) / tex_size;
+    vec2 dist = (fract(pix_co) - 0.5) * -1.0;
+
+    mat3x3 line0 = get_color_matrix(tex, tex_co - dy, dx);
+    mat3x3 line1 = get_color_matrix(tex, tex_co, dx);
+    mat3x3 line2 = get_color_matrix(tex, tex_co + dy, dx);
+    mat3x3 column = mat3x3(blur(line0, dist.x, GLOW_WIDTH),
+                               blur(line1, dist.x, GLOW_WIDTH),
+                               blur(line2, dist.x, GLOW_WIDTH));
+
+    return blur(column, dist.y, GLOW_HEIGHT);
+}
+
+vec3 filter_lanczos(sampler2D tex, vec2 co, vec2 tex_size, float sharp)
+{
+    tex_size.x *= sharp;
+
+    vec2 dx = vec2(1.0 / tex_size.x, 0.0);
+    vec2 pix_co = co * tex_size - vec2(0.5, 0.0);
+    vec2 tex_co = (floor(pix_co) + vec2(0.5, 0.001)) / tex_size;
+    vec2 dist = fract(pix_co);
+    vec4 coef = PI * vec4(dist.x + 1.0, dist.x, dist.x - 1.0, dist.x - 2.0);
+
+    coef = FIX(coef);
+    coef = 2.0 * sin(coef) * sin(coef / 2.0) / (coef * coef);
+    coef /= dot(coef, vec4(1.0));
+
+    vec4 col1 = vec4(TEX2D(tex_co), 1.0);
+    vec4 col2 = vec4(TEX2D(tex_co + dx), 1.0);
+
+    return (mat4x4(col1, col1, col2, col2) * coef).rgb;
+}
+
+vec3 get_scanline_weight(float x, vec3 col)
+{
+    vec3 beam = mix(vec3(SCANLINE_SIZE_MIN), vec3(SCANLINE_SIZE_MAX), pow(col, vec3(1.0 / SCANLINE_SHAPE)));
+    vec3 x_mul = 2.0 / beam;
+    vec3 x_offset = x_mul * 0.5;
+
+    return smoothstep(0.0, 1.0, 1.0 - abs(x * x_mul - x_offset)) * x_offset;
+}
+
+vec3 get_mask_weight(float x)
+{
+    float i = mod(floor(x * params.OutputSize.x * params.SourceSize.x / (params.SourceSize.x * MASK_SIZE)), MASK_COLORS);
+
+    if (i == 0.0) return mix(vec3(1.0, 0.0, 1.0), vec3(1.0, 0.0, 0.0), MASK_COLORS - 2.0);
+    else if (i == 1.0) return vec3(0.0, 1.0, 0.0);
+    else return vec3(0.0, 0.0, 1.0);
+}
+
+#pragma stage fragment
+layout(location = 0) in vec2 vTexCoord;
+layout(location = 0) out vec4 FragColor;
+layout(set = 0, binding = 0) uniform sampler2D Source;
+
+void main()
+{
+    float scale = floor(params.OutputSize.y * params.SourceSize.w);
+    float offset = 1.0 / scale * 0.5;
+    
+    if (bool(mod(scale, 2.0))) offset = 0.0;
+    
+    vec2 co = (vTexCoord * params.SourceSize.xy - vec2(0.0, offset * SCANLINE_OFFSET)) * params.SourceSize.zw;
+    vec3 col_glow = filter_gaussian(Source, co, params.SourceSize.xy);
+    vec3 col_soft = filter_lanczos(Source, co, params.SourceSize.xy, SHARPNESS_IMAGE);
+    vec3 col_sharp = filter_lanczos(Source, co, params.SourceSize.xy, SHARPNESS_EDGES);
+    vec3 col = sqrt(col_sharp * col_soft);
+
+    col *= get_scanline_weight(fract(co.y * params.SourceSize.y), col_soft);
+    col_glow = saturate(col_glow - col);
+    col += col_glow * col_glow * GLOW_HALATION;
+    col = mix(col, col * get_mask_weight(vTexCoord.x) * MASK_COLORS, MASK_STRENGTH);
+    col += col_glow * GLOW_DIFFUSION;
+    col = pow(col * BRIGHTNESS, vec3(1.0 / GAMMA_OUTPUT));
+   FragColor = vec4(col, 1.0);
+}

data/shader/crt_frag.spv

@@ -0,0 +1,453 @@
+{0x07230203,0x00010300,0x000d000b,0x000004fd,
+0x00000000,0x00020011,0x00000001,0x0006000b,
+0x00000001,0x4c534c47,0x6474732e,0x3035342e,
+0x00000000,0x0003000e,0x00000000,0x00000001,
+0x0007000f,0x00000004,0x00000004,0x6e69616d,
+0x00000000,0x000001ba,0x0000021a,0x00030010,
+0x00000004,0x00000007,0x00030047,0x00000185,
+0x00000002,0x00050048,0x00000185,0x00000000,
+0x00000023,0x00000000,0x00050048,0x00000185,
+0x00000001,0x00000023,0x00000010,0x00040047,
+0x000001ba,0x0000001e,0x00000000,0x00040047,
+0x000001ca,0x00000021,0x00000000,0x00040047,
+0x000001ca,0x00000022,0x00000000,0x00040047,
+0x0000021a,0x0000001e,0x00000000,0x00020013,
+0x00000002,0x00030021,0x00000003,0x00000002,
+0x00030016,0x00000006,0x00000020,0x00090019,
+0x00000007,0x00000006,0x00000001,0x00000000,
+0x00000000,0x00000000,0x00000001,0x00000000,
+0x0003001b,0x00000008,0x00000007,0x00040020,
+0x00000009,0x00000000,0x00000008,0x00040017,
+0x0000000a,0x00000006,0x00000002,0x00040017,
+0x0000000c,0x00000006,0x00000003,0x00040017,
+0x00000037,0x00000006,0x00000004,0x0004002b,
+0x00000006,0x0000003a,0x4019999a,0x0006002c,
+0x0000000c,0x0000003b,0x0000003a,0x0000003a,
+0x0000003a,0x0004002b,0x00000006,0x00000049,
+0x3f800000,0x0004002b,0x00000006,0x0000004a,
+0x00000000,0x0004002b,0x00000006,0x00000068,
+0xbf800000,0x00040015,0x0000006b,0x00000020,
+0x00000001,0x0004002b,0x0000006b,0x0000006c,
+0x00000000,0x00040015,0x0000006f,0x00000020,
+0x00000000,0x0004002b,0x0000006f,0x00000070,
+0x00000000,0x0004002b,0x0000006b,0x00000074,
+0x00000001,0x0004002b,0x0000006f,0x00000077,
+0x00000001,0x0004002b,0x00000006,0x000000a1,
+0x3f000000,0x0005002c,0x0000000a,0x000000fc,
+0x000000a1,0x0000004a,0x0004002b,0x00000006,
+0x00000101,0x3a83126f,0x0005002c,0x0000000a,
+0x00000102,0x000000a1,0x00000101,0x0004002b,
+0x00000006,0x0000010b,0x40490fdb,0x0004002b,
+0x00000006,0x00000116,0x40000000,0x0004002b,
+0x00000006,0x0000011c,0x3727c5ac,0x0007002c,
+0x00000037,0x0000012c,0x00000049,0x00000049,
+0x00000049,0x00000049,0x00040018,0x00000149,
+0x00000037,0x00000004,0x0006002c,0x0000000c,
+0x00000165,0x000000a1,0x000000a1,0x000000a1,
+0x0004002b,0x00000006,0x00000166,0x3fc00000,
+0x0006002c,0x0000000c,0x00000167,0x00000166,
+0x00000166,0x00000166,0x0004002b,0x00000006,
+0x00000169,0x3ecccccd,0x0006002c,0x0000000c,
+0x0000016a,0x00000169,0x00000169,0x00000169,
+0x0004001e,0x00000185,0x00000037,0x00000037,
+0x00040020,0x00000186,0x00000009,0x00000185,
+0x0004003b,0x00000186,0x00000187,0x00000009,
+0x00040020,0x00000188,0x00000009,0x00000006,
+0x00020014,0x00000196,0x0006002c,0x0000000c,
+0x0000019a,0x00000049,0x0000004a,0x00000049,
+0x0006002c,0x0000000c,0x000001a1,0x0000004a,
+0x00000049,0x0000004a,0x0006002c,0x0000000c,
+0x000001a4,0x0000004a,0x0000004a,0x00000049,
+0x0004002b,0x0000006f,0x000001aa,0x00000003,
+0x00040020,0x000001b9,0x00000001,0x0000000a,
+0x0004003b,0x000001b9,0x000001ba,0x00000001,
+0x00040020,0x000001bc,0x00000009,0x00000037,
+0x0004003b,0x00000009,0x000001ca,0x00000000,
+0x0004002b,0x00000006,0x000001dc,0x40400000,
+0x0004002b,0x00000006,0x000001ff,0x3dcccccd,
+0x00040020,0x00000206,0x00000001,0x00000006,
+0x0004002b,0x00000006,0x0000020c,0x3e99999a,
+0x0004002b,0x00000006,0x00000210,0x3d4ccccd,
+0x0004002b,0x00000006,0x00000216,0x3ed55555,
+0x0006002c,0x0000000c,0x00000217,0x00000216,
+0x00000216,0x00000216,0x00040020,0x00000219,
+0x00000003,0x00000037,0x0004003b,0x00000219,
+0x0000021a,0x00000003,0x0005002c,0x0000000a,
+0x000004f3,0x000000a1,0x000000a1,0x0007002c,
+0x00000037,0x000004f4,0x0000011c,0x0000011c,
+0x0000011c,0x0000011c,0x0006002c,0x0000000c,
+0x000004f6,0x00000116,0x00000116,0x00000116,
+0x0006002c,0x0000000c,0x000004f7,0x00000049,
+0x00000049,0x00000049,0x0006002c,0x0000000c,
+0x000004f8,0x0000004a,0x0000004a,0x0000004a,
+0x0006002c,0x0000000c,0x000004f9,0x0000020c,
+0x0000020c,0x0000020c,0x0007002c,0x00000037,
+0x000004fa,0x000000a1,0x000000a1,0x000000a1,
+0x000000a1,0x0004002b,0x00000006,0x000004fb,
+0x3eaaaaab,0x00050036,0x00000002,0x00000004,
+0x00000000,0x00000003,0x000200f8,0x00000005,
+0x00060041,0x00000188,0x000001a8,0x00000187,
+0x00000074,0x00000077,0x0004003d,0x00000006,
+0x000001a9,0x000001a8,0x00060041,0x00000188,
+0x000001ab,0x00000187,0x0000006c,0x000001aa,
+0x0004003d,0x00000006,0x000001ac,0x000001ab,
+0x00050085,0x00000006,0x000001ad,0x000001a9,
+0x000001ac,0x0006000c,0x00000006,0x000001ae,
+0x00000001,0x00000008,0x000001ad,0x00050088,
+0x00000006,0x000001b2,0x000000a1,0x000001ae,
+0x0005008d,0x00000006,0x000001b4,0x000001ae,
+0x00000116,0x000500b7,0x00000196,0x000001b5,
+0x000001b4,0x0000004a,0x000600a9,0x00000006,
+0x000004fc,0x000001b5,0x0000004a,0x000001b2,
+0x0004003d,0x0000000a,0x000001bb,0x000001ba,
+0x00050041,0x000001bc,0x000001bd,0x00000187,
+0x0000006c,0x0004003d,0x00000037,0x000001be,
+0x000001bd,0x0007004f,0x0000000a,0x000001bf,
+0x000001be,0x000001be,0x00000000,0x00000001,
+0x00050085,0x0000000a,0x000001c0,0x000001bb,
+0x000001bf,0x00050050,0x0000000a,0x000001c3,
+0x0000004a,0x000004fc,0x00050083,0x0000000a,
+0x000001c4,0x000001c0,0x000001c3,0x0007004f,
+0x0000000a,0x000001c7,0x000001be,0x000001be,
+0x00000002,0x00000003,0x00050085,0x0000000a,
+0x000001c8,0x000001c4,0x000001c7,0x00050051,
+0x00000006,0x00000249,0x000001be,0x00000000,
+0x00050088,0x00000006,0x0000024a,0x00000049,
+0x00000249,0x00050050,0x0000000a,0x0000024b,
+0x0000024a,0x0000004a,0x00050051,0x00000006,
+0x0000024d,0x000001be,0x00000001,0x00050088,
+0x00000006,0x0000024e,0x00000049,0x0000024d,
+0x00050050,0x0000000a,0x0000024f,0x0000004a,
+0x0000024e,0x00050085,0x0000000a,0x00000252,
+0x000001c8,0x000001bf,0x0006000c,0x0000000a,
+0x00000254,0x00000001,0x00000008,0x00000252,
+0x00050081,0x0000000a,0x00000256,0x00000254,
+0x000004f3,0x00050088,0x0000000a,0x00000258,
+0x00000256,0x000001bf,0x0006000c,0x0000000a,
+0x0000025a,0x00000001,0x0000000a,0x00000252,
+0x00050083,0x0000000a,0x0000025c,0x0000025a,
+0x000004f3,0x0005008e,0x0000000a,0x0000025d,
+0x0000025c,0x00000068,0x00050083,0x0000000a,
+0x00000260,0x00000258,0x0000024f,0x0004003d,
+0x00000008,0x0000028a,0x000001ca,0x00050083,
+0x0000000a,0x0000028d,0x00000260,0x0000024b,
+0x00050057,0x00000037,0x0000028e,0x0000028a,
+0x0000028d,0x0008004f,0x0000000c,0x0000028f,
+0x0000028e,0x0000028e,0x00000000,0x00000001,
+0x00000002,0x0007000c,0x0000000c,0x00000290,
+0x00000001,0x0000001a,0x0000028f,0x0000003b,
+0x00050057,0x00000037,0x00000293,0x0000028a,
+0x00000260,0x0008004f,0x0000000c,0x00000294,
+0x00000293,0x00000293,0x00000000,0x00000001,
+0x00000002,0x0007000c,0x0000000c,0x00000295,
+0x00000001,0x0000001a,0x00000294,0x0000003b,
+0x00050081,0x0000000a,0x00000299,0x00000260,
+0x0000024b,0x00050057,0x00000037,0x0000029a,
+0x0000028a,0x00000299,0x0008004f,0x0000000c,
+0x0000029b,0x0000029a,0x0000029a,0x00000000,
+0x00000001,0x00000002,0x0007000c,0x0000000c,
+0x0000029c,0x00000001,0x0000001a,0x0000029b,
+0x0000003b,0x00050083,0x0000000a,0x000002af,
+0x00000258,0x0000024b,0x00050057,0x00000037,
+0x000002b0,0x0000028a,0x000002af,0x0008004f,
+0x0000000c,0x000002b1,0x000002b0,0x000002b0,
+0x00000000,0x00000001,0x00000002,0x0007000c,
+0x0000000c,0x000002b2,0x00000001,0x0000001a,
+0x000002b1,0x0000003b,0x00050057,0x00000037,
+0x000002b5,0x0000028a,0x00000258,0x0008004f,
+0x0000000c,0x000002b6,0x000002b5,0x000002b5,
+0x00000000,0x00000001,0x00000002,0x0007000c,
+0x0000000c,0x000002b7,0x00000001,0x0000001a,
+0x000002b6,0x0000003b,0x00050081,0x0000000a,
+0x000002bb,0x00000258,0x0000024b,0x00050057,
+0x00000037,0x000002bc,0x0000028a,0x000002bb,
+0x0008004f,0x0000000c,0x000002bd,0x000002bc,
+0x000002bc,0x00000000,0x00000001,0x00000002,
+0x0007000c,0x0000000c,0x000002be,0x00000001,
+0x0000001a,0x000002bd,0x0000003b,0x00050081,
+0x0000000a,0x00000268,0x00000258,0x0000024f,
+0x00050083,0x0000000a,0x000002d1,0x00000268,
+0x0000024b,0x00050057,0x00000037,0x000002d2,
+0x0000028a,0x000002d1,0x0008004f,0x0000000c,
+0x000002d3,0x000002d2,0x000002d2,0x00000000,
+0x00000001,0x00000002,0x0007000c,0x0000000c,
+0x000002d4,0x00000001,0x0000001a,0x000002d3,
+0x0000003b,0x00050057,0x00000037,0x000002d7,
+0x0000028a,0x00000268,0x0008004f,0x0000000c,
+0x000002d8,0x000002d7,0x000002d7,0x00000000,
+0x00000001,0x00000002,0x0007000c,0x0000000c,
+0x000002d9,0x00000001,0x0000001a,0x000002d8,
+0x0000003b,0x00050081,0x0000000a,0x000002dd,
+0x00000268,0x0000024b,0x00050057,0x00000037,
+0x000002de,0x0000028a,0x000002dd,0x0008004f,
+0x0000000c,0x000002df,0x000002de,0x000002de,
+0x00000000,0x00000001,0x00000002,0x0007000c,
+0x0000000c,0x000002e0,0x00000001,0x0000001a,
+0x000002df,0x0000003b,0x00050051,0x00000006,
+0x0000026d,0x0000025d,0x00000000,0x00050083,
+0x00000006,0x000002f3,0x0000026d,0x00000049,
+0x00050081,0x00000006,0x000002f6,0x0000026d,
+0x00000049,0x00060050,0x0000000c,0x000002f7,
+0x000002f3,0x0000026d,0x000002f6,0x00050085,
+0x0000000c,0x000002fa,0x000002f7,0x000004f6,
+0x00050085,0x0000000c,0x000002fd,0x000002fa,
+0x000002fa,0x0005008e,0x0000000c,0x000002fe,
+0x000002fd,0x00000068,0x0006000c,0x0000000c,
+0x000002ff,0x00000001,0x0000001d,0x000002fe,
+0x00050051,0x00000006,0x00000303,0x000002ff,
+0x00000000,0x0005008e,0x0000000c,0x00000304,
+0x00000290,0x00000303,0x00050051,0x00000006,
+0x00000308,0x000002ff,0x00000001,0x0005008e,
+0x0000000c,0x00000309,0x00000295,0x00000308,
+0x00050081,0x0000000c,0x0000030a,0x00000304,
+0x00000309,0x00050051,0x00000006,0x0000030e,
+0x000002ff,0x00000002,0x0005008e,0x0000000c,
+0x0000030f,0x0000029c,0x0000030e,0x00050081,
+0x0000000c,0x00000310,0x0000030a,0x0000030f,
+0x00050081,0x00000006,0x00000315,0x00000303,
+0x00000308,0x00050081,0x00000006,0x00000318,
+0x00000315,0x0000030e,0x00060050,0x0000000c,
+0x00000319,0x00000318,0x00000318,0x00000318,
+0x00050088,0x0000000c,0x0000031a,0x00000310,
+0x00000319,0x0005008e,0x0000000c,0x00000331,
+0x000002b2,0x00000303,0x0005008e,0x0000000c,
+0x00000336,0x000002b7,0x00000308,0x00050081,
+0x0000000c,0x00000337,0x00000331,0x00000336,
+0x0005008e,0x0000000c,0x0000033c,0x000002be,
+0x0000030e,0x00050081,0x0000000c,0x0000033d,
+0x00000337,0x0000033c,0x00050088,0x0000000c,
+0x00000347,0x0000033d,0x00000319,0x0005008e,
+0x0000000c,0x0000035e,0x000002d4,0x00000303,
+0x0005008e,0x0000000c,0x00000363,0x000002d9,
+0x00000308,0x00050081,0x0000000c,0x00000364,
+0x0000035e,0x00000363,0x0005008e,0x0000000c,
+0x00000369,0x000002e0,0x0000030e,0x00050081,
+0x0000000c,0x0000036a,0x00000364,0x00000369,
+0x00050088,0x0000000c,0x00000374,0x0000036a,
+0x00000319,0x00050051,0x00000006,0x00000286,
+0x0000025d,0x00000001,0x00050083,0x00000006,
+0x0000037a,0x00000286,0x00000049,0x00050081,
+0x00000006,0x0000037d,0x00000286,0x00000049,
+0x00060050,0x0000000c,0x0000037e,0x0000037a,
+0x00000286,0x0000037d,0x00050085,0x0000000c,
+0x00000381,0x0000037e,0x000004f6,0x00050085,
+0x0000000c,0x00000384,0x00000381,0x00000381,
+0x0005008e,0x0000000c,0x00000385,0x00000384,
+0x00000068,0x0006000c,0x0000000c,0x00000386,
+0x00000001,0x0000001d,0x00000385,0x00050051,
+0x00000006,0x0000038a,0x00000386,0x00000000,
+0x0005008e,0x0000000c,0x0000038b,0x0000031a,
+0x0000038a,0x00050051,0x00000006,0x0000038f,
+0x00000386,0x00000001,0x0005008e,0x0000000c,
+0x00000390,0x00000347,0x0000038f,0x00050081,
+0x0000000c,0x00000391,0x0000038b,0x00000390,
+0x00050051,0x00000006,0x00000395,0x00000386,
+0x00000002,0x0005008e,0x0000000c,0x00000396,
+0x00000374,0x00000395,0x00050081,0x0000000c,
+0x00000397,0x00000391,0x00000396,0x00050081,
+0x00000006,0x0000039c,0x0000038a,0x0000038f,
+0x00050081,0x00000006,0x0000039f,0x0000039c,
+0x00000395,0x00060050,0x0000000c,0x000003a0,
+0x0000039f,0x0000039f,0x0000039f,0x00050088,
+0x0000000c,0x000003a1,0x00000397,0x000003a0,
+0x00060052,0x0000000a,0x000004e1,0x00000249,
+0x000001bf,0x00000000,0x00050085,0x0000000a,
+0x000003b6,0x000001c8,0x000004e1,0x00050083,
+0x0000000a,0x000003b7,0x000003b6,0x000000fc,
+0x0006000c,0x0000000a,0x000003b9,0x00000001,
+0x00000008,0x000003b7,0x00050081,0x0000000a,
+0x000003ba,0x000003b9,0x00000102,0x00050088,
+0x0000000a,0x000003bc,0x000003ba,0x000004e1,
+0x0006000c,0x0000000a,0x000003be,0x00000001,
+0x0000000a,0x000003b7,0x00050051,0x00000006,
+0x000003c0,0x000003be,0x00000000,0x00050081,
+0x00000006,0x000003c1,0x000003c0,0x00000049,
+0x00050083,0x00000006,0x000003c6,0x000003c0,
+0x00000049,0x00050083,0x00000006,0x000003c9,
+0x000003c0,0x00000116,0x00070050,0x00000037,
+0x000003ca,0x000003c1,0x000003c0,0x000003c6,
+0x000003c9,0x0005008e,0x00000037,0x000003cb,
+0x000003ca,0x0000010b,0x0006000c,0x00000037,
+0x000003cd,0x00000001,0x00000004,0x000003cb,
+0x0007000c,0x00000037,0x000003cf,0x00000001,
+0x00000028,0x000003cd,0x000004f4,0x0006000c,
+0x00000037,0x000003d1,0x00000001,0x0000000d,
+0x000003cf,0x0005008e,0x00000037,0x000003d2,
+0x000003d1,0x00000116,0x00050085,0x00000037,
+0x000003d5,0x000003cf,0x000004fa,0x0006000c,
+0x00000037,0x000003d6,0x00000001,0x0000000d,
+0x000003d5,0x00050085,0x00000037,0x000003d7,
+0x000003d2,0x000003d6,0x00050085,0x00000037,
+0x000003da,0x000003cf,0x000003cf,0x00050088,
+0x00000037,0x000003db,0x000003d7,0x000003da,
+0x00050094,0x00000006,0x000003dd,0x000003db,
+0x0000012c,0x00070050,0x00000037,0x000003df,
+0x000003dd,0x000003dd,0x000003dd,0x000003dd,
+0x00050088,0x00000037,0x000003e0,0x000003db,
+0x000003df,0x00050057,0x00000037,0x000003e3,
+0x0000028a,0x000003bc,0x0008004f,0x0000000c,
+0x000003e4,0x000003e3,0x000003e3,0x00000000,
+0x00000001,0x00000002,0x0007000c,0x0000000c,
+0x000003e5,0x00000001,0x0000001a,0x000003e4,
+0x0000003b,0x00050051,0x00000006,0x000003e6,
+0x000003e5,0x00000000,0x00050051,0x00000006,
+0x000003e7,0x000003e5,0x00000001,0x00050051,
+0x00000006,0x000003e8,0x000003e5,0x00000002,
+0x00050081,0x0000000a,0x000003ed,0x000003bc,
+0x0000024b,0x00050057,0x00000037,0x000003ee,
+0x0000028a,0x000003ed,0x0008004f,0x0000000c,
+0x000003ef,0x000003ee,0x000003ee,0x00000000,
+0x00000001,0x00000002,0x0007000c,0x0000000c,
+0x000003f0,0x00000001,0x0000001a,0x000003ef,
+0x0000003b,0x00050051,0x00000006,0x000003f1,
+0x000003f0,0x00000000,0x00050051,0x00000006,
+0x000003f2,0x000003f0,0x00000001,0x00050051,
+0x00000006,0x000003f3,0x000003f0,0x00000002,
+0x00070050,0x00000037,0x00000407,0x000003e6,
+0x000003e7,0x000003e8,0x00000049,0x00070050,
+0x00000037,0x00000409,0x000003f1,0x000003f2,
+0x000003f3,0x00000049,0x00070050,0x00000149,
+0x0000040b,0x00000407,0x00000407,0x00000409,
+0x00000409,0x00050091,0x00000037,0x0000040d,
+0x0000040b,0x000003e0,0x0008004f,0x0000000c,
+0x0000040e,0x0000040d,0x0000040d,0x00000000,
+0x00000001,0x00000002,0x00050085,0x00000006,
+0x0000041b,0x00000249,0x000001dc,0x00060052,
+0x0000000a,0x000004e9,0x0000041b,0x000001bf,
+0x00000000,0x00050088,0x00000006,0x0000041f,
+0x000004fb,0x00000249,0x00050050,0x0000000a,
+0x00000420,0x0000041f,0x0000004a,0x00050085,
+0x0000000a,0x00000423,0x000001c8,0x000004e9,
+0x00050083,0x0000000a,0x00000424,0x00000423,
+0x000000fc,0x0006000c,0x0000000a,0x00000426,
+0x00000001,0x00000008,0x00000424,0x00050081,
+0x0000000a,0x00000427,0x00000426,0x00000102,
+0x00050088,0x0000000a,0x00000429,0x00000427,
+0x000004e9,0x0006000c,0x0000000a,0x0000042b,
+0x00000001,0x0000000a,0x00000424,0x00050051,
+0x00000006,0x0000042d,0x0000042b,0x00000000,
+0x00050081,0x00000006,0x0000042e,0x0000042d,
+0x00000049,0x00050083,0x00000006,0x00000433,
+0x0000042d,0x00000049,0x00050083,0x00000006,
+0x00000436,0x0000042d,0x00000116,0x00070050,
+0x00000037,0x00000437,0x0000042e,0x0000042d,
+0x00000433,0x00000436,0x0005008e,0x00000037,
+0x00000438,0x00000437,0x0000010b,0x0006000c,
+0x00000037,0x0000043a,0x00000001,0x00000004,
+0x00000438,0x0007000c,0x00000037,0x0000043c,
+0x00000001,0x00000028,0x0000043a,0x000004f4,
+0x0006000c,0x00000037,0x0000043e,0x00000001,
+0x0000000d,0x0000043c,0x0005008e,0x00000037,
+0x0000043f,0x0000043e,0x00000116,0x00050085,
+0x00000037,0x00000442,0x0000043c,0x000004fa,
+0x0006000c,0x00000037,0x00000443,0x00000001,
+0x0000000d,0x00000442,0x00050085,0x00000037,
+0x00000444,0x0000043f,0x00000443,0x00050085,
+0x00000037,0x00000447,0x0000043c,0x0000043c,
+0x00050088,0x00000037,0x00000448,0x00000444,
+0x00000447,0x00050094,0x00000006,0x0000044a,
+0x00000448,0x0000012c,0x00070050,0x00000037,
+0x0000044c,0x0000044a,0x0000044a,0x0000044a,
+0x0000044a,0x00050088,0x00000037,0x0000044d,
+0x00000448,0x0000044c,0x00050057,0x00000037,
+0x00000450,0x0000028a,0x00000429,0x0008004f,
+0x0000000c,0x00000451,0x00000450,0x00000450,
+0x00000000,0x00000001,0x00000002,0x0007000c,
+0x0000000c,0x00000452,0x00000001,0x0000001a,
+0x00000451,0x0000003b,0x00050051,0x00000006,
+0x00000453,0x00000452,0x00000000,0x00050051,
+0x00000006,0x00000454,0x00000452,0x00000001,
+0x00050051,0x00000006,0x00000455,0x00000452,
+0x00000002,0x00050081,0x0000000a,0x0000045a,
+0x00000429,0x00000420,0x00050057,0x00000037,
+0x0000045b,0x0000028a,0x0000045a,0x0008004f,
+0x0000000c,0x0000045c,0x0000045b,0x0000045b,
+0x00000000,0x00000001,0x00000002,0x0007000c,
+0x0000000c,0x0000045d,0x00000001,0x0000001a,
+0x0000045c,0x0000003b,0x00050051,0x00000006,
+0x0000045e,0x0000045d,0x00000000,0x00050051,
+0x00000006,0x0000045f,0x0000045d,0x00000001,
+0x00050051,0x00000006,0x00000460,0x0000045d,
+0x00000002,0x00070050,0x00000037,0x00000474,
+0x00000453,0x00000454,0x00000455,0x00000049,
+0x00070050,0x00000037,0x00000476,0x0000045e,
+0x0000045f,0x00000460,0x00000049,0x00070050,
+0x00000149,0x00000478,0x00000474,0x00000474,
+0x00000476,0x00000476,0x00050091,0x00000037,
+0x0000047a,0x00000478,0x0000044d,0x0008004f,
+0x0000000c,0x0000047b,0x0000047a,0x0000047a,
+0x00000000,0x00000001,0x00000002,0x00050085,
+0x0000000c,0x000001e8,0x0000047b,0x0000040e,
+0x0006000c,0x0000000c,0x000001e9,0x00000001,
+0x0000001f,0x000001e8,0x00050051,0x00000006,
+0x000001eb,0x000001c8,0x00000001,0x00060041,
+0x00000188,0x000001ec,0x00000187,0x0000006c,
+0x00000077,0x0004003d,0x00000006,0x000001ed,
+0x000001ec,0x00050085,0x00000006,0x000001ee,
+0x000001eb,0x000001ed,0x0006000c,0x00000006,
+0x000001ef,0x00000001,0x0000000a,0x000001ee,
+0x0007000c,0x0000000c,0x00000482,0x00000001,
+0x0000001a,0x0000040e,0x0000016a,0x0008000c,
+0x0000000c,0x00000483,0x00000001,0x0000002e,
+0x00000165,0x00000167,0x00000482,0x00050088,
+0x0000000c,0x00000486,0x000004f6,0x00000483,
+0x0005008e,0x0000000c,0x00000488,0x00000486,
+0x000000a1,0x0005008e,0x0000000c,0x0000048b,
+0x00000486,0x000001ef,0x00050083,0x0000000c,
+0x0000048d,0x0000048b,0x00000488,0x0006000c,
+0x0000000c,0x0000048e,0x00000001,0x00000004,
+0x0000048d,0x00050083,0x0000000c,0x00000490,
+0x000004f7,0x0000048e,0x0008000c,0x0000000c,
+0x00000493,0x00000001,0x00000031,0x000004f8,
+0x000004f7,0x00000490,0x00050085,0x0000000c,
+0x00000495,0x00000493,0x00000488,0x00050085,
+0x0000000c,0x000001f5,0x000001e9,0x00000495,
+0x00050083,0x0000000c,0x000001f8,0x000003a1,
+0x000001f5,0x0008000c,0x0000000c,0x000001fb,
+0x00000001,0x0000002b,0x000001f8,0x000004f8,
+0x000004f7,0x00050085,0x0000000c,0x000001fe,
+0x000001fb,0x000001fb,0x0005008e,0x0000000c,
+0x00000200,0x000001fe,0x000001ff,0x00050081,
+0x0000000c,0x00000202,0x000001f5,0x00000200,
+0x00050041,0x00000206,0x00000207,0x000001ba,
+0x00000070,0x0004003d,0x00000006,0x00000208,
+0x00000207,0x000300f7,0x000004b3,0x00000000,
+0x000300fb,0x00000070,0x0000049b,0x000200f8,
+0x0000049b,0x00060041,0x00000188,0x0000049d,
+0x00000187,0x00000074,0x00000070,0x0004003d,
+0x00000006,0x0000049e,0x0000049d,0x00050085,
+0x00000006,0x0000049f,0x00000208,0x0000049e,
+0x0006000c,0x00000006,0x000004a7,0x00000001,
+0x00000008,0x0000049f,0x0005008d,0x00000006,
+0x000004a8,0x000004a7,0x00000116,0x000500b4,
+0x00000196,0x000004aa,0x000004a8,0x0000004a,
+0x000300f7,0x000004b2,0x00000000,0x000400fa,
+0x000004aa,0x000004ab,0x000004ac,0x000200f8,
+0x000004ac,0x000500b4,0x00000196,0x000004ae,
+0x000004a8,0x00000049,0x000300f7,0x000004b1,
+0x00000000,0x000400fa,0x000004ae,0x000004af,
+0x000004b0,0x000200f8,0x000004b0,0x000200f9,
+0x000004b3,0x000200f8,0x000004af,0x000200f9,
+0x000004b3,0x000200f8,0x000004b1,0x000100ff,
+0x000200f8,0x000004ab,0x000200f9,0x000004b3,
+0x000200f8,0x000004b2,0x000100ff,0x000200f8,
+0x000004b3,0x000900f5,0x0000000c,0x000004f1,
+0x0000019a,0x000004ab,0x000001a1,0x000004af,
+0x000001a4,0x000004b0,0x00050085,0x0000000c,
+0x0000020a,0x00000202,0x000004f1,0x0005008e,
+0x0000000c,0x0000020b,0x0000020a,0x00000116,
+0x0008000c,0x0000000c,0x0000020e,0x00000001,
+0x0000002e,0x00000202,0x0000020b,0x000004f9,
+0x0005008e,0x0000000c,0x00000211,0x000001fb,
+0x00000210,0x00050081,0x0000000c,0x00000213,
+0x0000020e,0x00000211,0x0005008e,0x0000000c,
+0x00000215,0x00000213,0x00000166,0x0007000c,
+0x0000000c,0x00000218,0x00000001,0x0000001a,
+0x00000215,0x00000217,0x00050051,0x00000006,
+0x0000021c,0x00000218,0x00000000,0x00050051,
+0x00000006,0x0000021d,0x00000218,0x00000001,
+0x00050051,0x00000006,0x0000021e,0x00000218,
+0x00000002,0x00070050,0x00000037,0x0000021f,
+0x0000021c,0x0000021d,0x0000021e,0x00000049,
+0x0003003e,0x0000021a,0x0000021f,0x000100fd,
+0x00010038}

data/shader/main.frag

@@ -0,0 +1,10 @@
+#version 450
+
+layout(location = 0) out vec4 FragColor;
+layout(set = 0, binding = 0) uniform sampler2D uTexture;
+layout(location = 0) in vec2 vUV;
+
+void main()
+{
+	FragColor = textureLod(uTexture, vUV, 0.0);
+}

data/shader/main.vert

@@ -0,0 +1,21 @@
+#version 450
+
+layout(location = 0) out vec2 vUV;
+
+void main()
+{
+	if (gl_VertexIndex == 0)
+	{
+		gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);
+	}
+	else if (gl_VertexIndex == 1)
+	{
+		gl_Position = vec4(-1.0, +3.0, 0.0, 1.0);
+	}
+	else
+	{
+		gl_Position = vec4(+3.0, -1.0, 0.0, 1.0);
+	}
+
+	vUV = gl_Position.xy * 0.5 + 0.5;
+}

data/shader/main_frag.spv

@@ -0,0 +1,32 @@
+{0x07230203,0x00010300,0x000d000b,0x00000015,
+0x00000000,0x00020011,0x00000001,0x0006000b,
+0x00000001,0x4c534c47,0x6474732e,0x3035342e,
+0x00000000,0x0003000e,0x00000000,0x00000001,
+0x0007000f,0x00000004,0x00000004,0x6e69616d,
+0x00000000,0x00000009,0x00000011,0x00030010,
+0x00000004,0x00000007,0x00040047,0x00000009,
+0x0000001e,0x00000000,0x00040047,0x0000000d,
+0x00000021,0x00000000,0x00040047,0x0000000d,
+0x00000022,0x00000000,0x00040047,0x00000011,
+0x0000001e,0x00000000,0x00020013,0x00000002,
+0x00030021,0x00000003,0x00000002,0x00030016,
+0x00000006,0x00000020,0x00040017,0x00000007,
+0x00000006,0x00000004,0x00040020,0x00000008,
+0x00000003,0x00000007,0x0004003b,0x00000008,
+0x00000009,0x00000003,0x00090019,0x0000000a,
+0x00000006,0x00000001,0x00000000,0x00000000,
+0x00000000,0x00000001,0x00000000,0x0003001b,
+0x0000000b,0x0000000a,0x00040020,0x0000000c,
+0x00000000,0x0000000b,0x0004003b,0x0000000c,
+0x0000000d,0x00000000,0x00040017,0x0000000f,
+0x00000006,0x00000002,0x00040020,0x00000010,
+0x00000001,0x0000000f,0x0004003b,0x00000010,
+0x00000011,0x00000001,0x0004002b,0x00000006,
+0x00000013,0x00000000,0x00050036,0x00000002,
+0x00000004,0x00000000,0x00000003,0x000200f8,
+0x00000005,0x0004003d,0x0000000b,0x0000000e,
+0x0000000d,0x0004003d,0x0000000f,0x00000012,
+0x00000011,0x00070058,0x00000007,0x00000014,
+0x0000000e,0x00000012,0x00000002,0x00000013,
+0x0003003e,0x00000009,0x00000014,0x000100fd,
+0x00010038}

data/shader/main_vert.spv

@@ -0,0 +1,72 @@
+{0x07230203,0x00010300,0x000d000b,0x00000034,
+0x00000000,0x00020011,0x00000001,0x0006000b,
+0x00000001,0x4c534c47,0x6474732e,0x3035342e,
+0x00000000,0x0003000e,0x00000000,0x00000001,
+0x0008000f,0x00000000,0x00000004,0x6e69616d,
+0x00000000,0x00000008,0x00000016,0x0000002b,
+0x00040047,0x00000008,0x0000000b,0x0000002a,
+0x00030047,0x00000014,0x00000002,0x00050048,
+0x00000014,0x00000000,0x0000000b,0x00000000,
+0x00050048,0x00000014,0x00000001,0x0000000b,
+0x00000001,0x00050048,0x00000014,0x00000002,
+0x0000000b,0x00000003,0x00050048,0x00000014,
+0x00000003,0x0000000b,0x00000004,0x00040047,
+0x0000002b,0x0000001e,0x00000000,0x00020013,
+0x00000002,0x00030021,0x00000003,0x00000002,
+0x00040015,0x00000006,0x00000020,0x00000001,
+0x00040020,0x00000007,0x00000001,0x00000006,
+0x0004003b,0x00000007,0x00000008,0x00000001,
+0x0004002b,0x00000006,0x0000000a,0x00000000,
+0x00020014,0x0000000b,0x00030016,0x0000000f,
+0x00000020,0x00040017,0x00000010,0x0000000f,
+0x00000004,0x00040015,0x00000011,0x00000020,
+0x00000000,0x0004002b,0x00000011,0x00000012,
+0x00000001,0x0004001c,0x00000013,0x0000000f,
+0x00000012,0x0006001e,0x00000014,0x00000010,
+0x0000000f,0x00000013,0x00000013,0x00040020,
+0x00000015,0x00000003,0x00000014,0x0004003b,
+0x00000015,0x00000016,0x00000003,0x0004002b,
+0x0000000f,0x00000017,0xbf800000,0x0004002b,
+0x0000000f,0x00000018,0x00000000,0x0004002b,
+0x0000000f,0x00000019,0x3f800000,0x0007002c,
+0x00000010,0x0000001a,0x00000017,0x00000017,
+0x00000018,0x00000019,0x00040020,0x0000001b,
+0x00000003,0x00000010,0x0004002b,0x00000006,
+0x0000001f,0x00000001,0x0004002b,0x0000000f,
+0x00000023,0x40400000,0x0007002c,0x00000010,
+0x00000024,0x00000017,0x00000023,0x00000018,
+0x00000019,0x0007002c,0x00000010,0x00000027,
+0x00000023,0x00000017,0x00000018,0x00000019,
+0x00040017,0x00000029,0x0000000f,0x00000002,
+0x00040020,0x0000002a,0x00000003,0x00000029,
+0x0004003b,0x0000002a,0x0000002b,0x00000003,
+0x0004002b,0x0000000f,0x0000002f,0x3f000000,
+0x0005002c,0x00000029,0x00000033,0x0000002f,
+0x0000002f,0x00050036,0x00000002,0x00000004,
+0x00000000,0x00000003,0x000200f8,0x00000005,
+0x0004003d,0x00000006,0x00000009,0x00000008,
+0x000500aa,0x0000000b,0x0000000c,0x00000009,
+0x0000000a,0x000300f7,0x0000000e,0x00000000,
+0x000400fa,0x0000000c,0x0000000d,0x0000001d,
+0x000200f8,0x0000000d,0x00050041,0x0000001b,
+0x0000001c,0x00000016,0x0000000a,0x0003003e,
+0x0000001c,0x0000001a,0x000200f9,0x0000000e,
+0x000200f8,0x0000001d,0x000500aa,0x0000000b,
+0x00000020,0x00000009,0x0000001f,0x000300f7,
+0x00000022,0x00000000,0x000400fa,0x00000020,
+0x00000021,0x00000026,0x000200f8,0x00000021,
+0x00050041,0x0000001b,0x00000025,0x00000016,
+0x0000000a,0x0003003e,0x00000025,0x00000024,
+0x000200f9,0x00000022,0x000200f8,0x00000026,
+0x00050041,0x0000001b,0x00000028,0x00000016,
+0x0000000a,0x0003003e,0x00000028,0x00000027,
+0x000200f9,0x00000022,0x000200f8,0x00000022,
+0x000200f9,0x0000000e,0x000200f8,0x0000000e,
+0x00050041,0x0000001b,0x0000002c,0x00000016,
+0x0000000a,0x0004003d,0x00000010,0x0000002d,
+0x0000002c,0x0007004f,0x00000029,0x0000002e,
+0x0000002d,0x0000002d,0x00000000,0x00000001,
+0x0005008e,0x00000029,0x00000030,0x0000002e,
+0x0000002f,0x00050081,0x00000029,0x00000032,
+0x00000030,0x00000033,0x0003003e,0x0000002b,
+0x00000032,0x000100fd,0x00010038}

data/shader/output.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+glslc -O crt-aperture.frag -o crt_frag.spv --target-env=vulkan1.1 -mfmt=c
+glslc -O main.frag -o main_frag.spv --target-env=vulkan1.1 -mfmt=c
+glslc -O main.vert -o main_vert.spv --target-env=vulkan1.1 -mfmt=c

parallel-rdp/interface.cpp

@@ -3,7 +3,9 @@
 #include "rdp_device.hpp"
 #include "interface.hpp"
 #include "spirv.hpp"
+#include "spirv_crt.hpp"
 #include <SDL3/SDL_vulkan.h>
+#include <SDL3_ttf/SDL_ttf.h>
 
 using namespace Vulkan;
 
@@ -51,35 +53,55 @@ enum vi_registers
 	VI_REGS_COUNT
 };
 
-static bool fullscreen;
-static bool integer_scaling;
-static SDL_Window *window;
-static RDP::CommandProcessor *processor;
-static SDL_WSIPlatform *wsi_platform;
-static WSI *wsi;
-static uint32_t cmd_data[0x00040000 >> 2];
-static int cmd_cur;
-static int cmd_ptr;
-static CALL_BACK callback;
-static GFX_INFO gfx_info;
-static uint32_t region;
-static bool crop_letterbox;
-
 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;
-	uint32_t framebuffer_size;
-	uint32_t depthbuffer_size;
-	uint8_t depthbuffer_enabled;
+	bool depth_buffer_enabled;
 } FrameBufferInfo;
 
-static uint8_t *rdram_dirty;
-static uint64_t sync_signal;
-static FrameBufferInfo frame_buffer_info;
+typedef struct
+{
+	uint32_t cmd_data[0x00040000 >> 2];
+	int cmd_cur;
+	int cmd_ptr;
+	uint32_t region;
+	FrameBufferInfo frame_buffer_info;
+} RDP_DEVICE;
+
+static SDL_Window *window;
+static RDP::CommandProcessor *processor;
+static SDL_WSIPlatform *wsi_platform;
+static WSI *wsi;
+
+static RDP_DEVICE rdp_device;
+static bool crop_letterbox;
+static CALL_BACK callback;
+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;
+
+#define MESSAGE_TIME 3000 // 3 seconds
+
+typedef struct
+{
+	float SourceSize[4];
+	float OutputSize[4];
+} Push;
 
 static const unsigned cmd_len_lut[64] = {
 	1,
@@ -152,6 +174,7 @@ bool sdl_event_filter(void *userdata, SDL_Event *event)
 {
 	if (event->type == SDL_EVENT_WINDOW_CLOSE_REQUESTED)
 	{
+		callback.paused = false;
 		callback.emu_running = false;
 	}
 	else if (event->type == SDL_EVENT_WINDOW_RESIZED && callback.emu_running)
@@ -165,8 +188,8 @@ bool sdl_event_filter(void *userdata, SDL_Event *event)
 		case SDL_SCANCODE_RETURN:
 			if (event->key.mod & SDL_KMOD_ALT)
 			{
-				fullscreen = !fullscreen;
-				SDL_SetWindowFullscreen(window, fullscreen);
+				gfx_info.fullscreen = !gfx_info.fullscreen;
+				SDL_SetWindowFullscreen(window, gfx_info.fullscreen);
 			}
 			break;
 		case SDL_SCANCODE_F:
@@ -175,8 +198,14 @@ bool sdl_event_filter(void *userdata, SDL_Event *event)
 				callback.enable_speedlimiter = !callback.enable_speedlimiter;
 			}
 			break;
+		case SDL_SCANCODE_P:
+			if (event->key.mod & SDL_KMOD_ALT)
+			{
+				callback.paused = !callback.paused;
+			}
+			break;
 		case SDL_SCANCODE_ESCAPE:
-			if (fullscreen)
+			if (gfx_info.fullscreen)
 				callback.emu_running = false;
 			break;
 		case SDL_SCANCODE_F4:
@@ -188,6 +217,33 @@ bool sdl_event_filter(void *userdata, SDL_Event *event)
 		case SDL_SCANCODE_F7:
 			callback.load_state = true;
 			break;
+		case SDL_SCANCODE_LEFTBRACKET:
+			callback.lower_volume = true;
+			break;
+		case SDL_SCANCODE_RIGHTBRACKET:
+			callback.raise_volume = true;
+			break;
+		case SDL_SCANCODE_SLASH:
+			callback.frame_advance = true;
+			break;
+		case SDL_SCANCODE_0:
+		case SDL_SCANCODE_1:
+		case SDL_SCANCODE_2:
+		case SDL_SCANCODE_3:
+		case SDL_SCANCODE_4:
+		case SDL_SCANCODE_5:
+		case SDL_SCANCODE_6:
+		case SDL_SCANCODE_7:
+		case SDL_SCANCODE_8:
+		case SDL_SCANCODE_9:
+			if (event->key.mod & SDL_KMOD_ALT)
+			{
+				if (event->key.scancode == SDL_SCANCODE_0)
+					callback.save_state_slot = 0;
+				else
+					callback.save_state_slot = event->key.scancode - SDL_SCANCODE_1 + 1;
+			}
+			break;
 		default:
 			break;
 		}
@@ -196,36 +252,60 @@ bool sdl_event_filter(void *userdata, SDL_Event *event)
 	return 0;
 }
 
-void rdp_new_processor(GFX_INFO _gfx_info, uint32_t upscale)
+void rdp_new_processor(GFX_INFO _gfx_info)
 {
-	memset(&frame_buffer_info, 0, sizeof(FrameBufferInfo));
-	sync_signal = 0;
-	memset(rdram_dirty, 0, gfx_info.RDRAM_SIZE / 8);
-
 	gfx_info = _gfx_info;
+
+	sync_signal = 0;
+	rdram_dirty.assign(gfx_info.RDRAM_SIZE >> 3, false);
+
 	if (processor)
 	{
 		delete processor;
 	}
 	RDP::CommandProcessorFlags flags = 0;
 
-	if (upscale == 2)
+	if (gfx_info.upscale == 2)
 	{
 		flags |= RDP::COMMAND_PROCESSOR_FLAG_SUPER_SAMPLED_DITHER_BIT;
 		flags |= RDP::COMMAND_PROCESSOR_FLAG_UPSCALING_2X_BIT;
 	}
-	else if (upscale == 4)
+	else if (gfx_info.upscale == 4)
 	{
 		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);
 }
 
-void rdp_init(void *_window, GFX_INFO _gfx_info, uint32_t _upscale, bool _integer_scaling, bool _fullscreen)
+static ImageHandle create_message_image(Vulkan::Device &device, int width, const char *message)
 {
+	SDL_Color fg = {255, 255, 255, 255};
+	SDL_Color bg = {0, 0, 0, 0};
+	SDL_Surface *surface = TTF_RenderText_LCD_Wrapped(message_font, message, 0, fg, bg, width);
+	ImageCreateInfo info = ImageCreateInfo::immutable_2d_image(surface->w, surface->h, VK_FORMAT_B8G8R8A8_UNORM, false);
+	ImageInitialData initial_data = {};
+	initial_data.data = surface->pixels;
+	initial_data.row_length = surface->pitch / 4;
+	initial_data.image_height = surface->h;
+
+	ImageHandle handle = device.create_image(info, &initial_data);
+	SDL_DestroySurface(surface);
+	return handle;
+}
+
+void rdp_init(void *_window, GFX_INFO _gfx_info, const void *font, size_t font_size)
+{
+	memset(&rdp_device, 0, sizeof(RDP_DEVICE));
+
 	window = (SDL_Window *)_window;
+	SDL_SyncWindow(window);
 	bool result = SDL_AddEventWatch(sdl_event_filter, nullptr);
 	if (!result)
 	{
@@ -234,8 +314,18 @@ void rdp_init(void *_window, GFX_INFO _gfx_info, uint32_t _upscale, bool _intege
 	}
 
 	gfx_info = _gfx_info;
-	fullscreen = _fullscreen;
-	integer_scaling = _integer_scaling;
+
+	if (gfx_info.crt)
+	{
+		fragment_spirv = crt_fragment_spirv;
+		fragment_size = sizeof(crt_fragment_spirv);
+	}
+	else
+	{
+		fragment_spirv = plain_fragment_spirv;
+		fragment_size = sizeof(plain_fragment_spirv);
+	}
+
 	bool window_vsync = 0;
 	wsi = new WSI;
 	wsi_platform = new SDL_WSIPlatform;
@@ -247,39 +337,51 @@ void rdp_init(void *_window, GFX_INFO _gfx_info, uint32_t _upscale, bool _intege
 	if (!::Vulkan::Context::init_loader((PFN_vkGetInstanceProcAddr)SDL_Vulkan_GetVkGetInstanceProcAddr()))
 	{
 		rdp_close();
+		return;
 	}
 	if (!wsi->init_simple(1, handles))
 	{
 		rdp_close();
+		return;
 	}
 
-	rdram_dirty = (uint8_t *)malloc(gfx_info.RDRAM_SIZE / 8);
-	rdp_new_processor(gfx_info, _upscale);
+	rdp_new_processor(gfx_info);
 
 	if (!processor->device_is_supported())
 	{
-		delete processor;
-		delete wsi;
-		processor = nullptr;
 		rdp_close();
+		return;
 	}
+
+	message_font = TTF_OpenFontIO(SDL_IOFromConstMem(font, font_size), true, 30.0);
+	if (!message_font)
+	{
+		rdp_close();
+		return;
+	}
+
 	wsi->begin_frame();
 
 	callback.emu_running = true;
 	callback.enable_speedlimiter = true;
+	callback.paused = false;
+	callback.save_state_slot = 0;
 	crop_letterbox = false;
+
+	messages = std::queue<std::string>();
+	message_timer = 0;
 }
 
 void rdp_close()
 {
-	if (rdram_dirty)
+	if (wsi)
+		wsi->end_frame();
+
+	if (message_font)
 	{
-		free(rdram_dirty);
-		rdram_dirty = nullptr;
+		TTF_CloseFont(message_font);
+		message_font = nullptr;
 	}
-
-	wsi->end_frame();
-
 	if (processor)
 	{
 		delete processor;
@@ -297,15 +399,14 @@ void rdp_close()
 	}
 }
 
-static void calculate_viewport(float *x, float *y, float *width, float *height)
+static void calculate_viewport(float *x, float *y, float *width, float *height, uint32_t display_height)
 {
-	const int32_t display_width = gfx_info.widescreen ? (gfx_info.PAL ? 512 : 426) : (gfx_info.PAL ? 384 : 320);
-	const int32_t display_height = gfx_info.PAL ? 288 : 240;
+	uint32_t display_width = gfx_info.widescreen ? display_height * 16 / 9 : display_height * 4 / 3;
 
 	int w, h;
 	SDL_GetWindowSize(window, &w, &h);
 
-	if (integer_scaling)
+	if (gfx_info.integer_scaling)
 	{
 		// Integer scaling path
 		int scale_x = w / display_width;
@@ -320,6 +421,13 @@ static void calculate_viewport(float *x, float *y, float *width, float *height)
 
 		*width = scaled_width;
 		*height = scaled_height;
+
+		// Center the viewport
+		int integer_x = (w - *width) / 2.0f;
+		int integer_y = (h - *height) / 2.0f;
+
+		*x = integer_x;
+		*y = integer_y;
 	}
 	else
 	{
@@ -330,11 +438,11 @@ static void calculate_viewport(float *x, float *y, float *width, float *height)
 
 		*width = display_width * scale;
 		*height = display_height * scale;
-	}
 
-	// Center the viewport
-	*x = (w - *width) / 2.0f;
-	*y = (h - *height) / 2.0f;
+		// Center the viewport
+		*x = (w - *width) / 2.0f;
+		*y = (h - *height) / 2.0f;
+	}
 }
 
 static void render_frame(Vulkan::Device &device)
@@ -361,15 +469,16 @@ static void render_frame(Vulkan::Device &device)
 
 	Vulkan::ImageHandle image = processor->scanout(options);
 
-	// Normally reflection is automated.
 	Vulkan::ResourceLayout vertex_layout = {};
 	Vulkan::ResourceLayout fragment_layout = {};
 	fragment_layout.output_mask = 1 << 0;
 	fragment_layout.sets[0].sampled_image_mask = 1 << 0;
+	if (gfx_info.crt)
+		fragment_layout.push_constant_size = sizeof(Push);
 
 	// This request is cached.
 	auto *program = device.request_program(vertex_spirv, sizeof(vertex_spirv),
-										   fragment_spirv, sizeof(fragment_spirv),
+										   fragment_spirv, fragment_size,
 										   &vertex_layout,
 										   &fragment_layout);
 
@@ -379,9 +488,6 @@ static void render_frame(Vulkan::Device &device)
 		auto rp = device.get_swapchain_render_pass(Vulkan::SwapchainRenderPass::ColorOnly);
 		cmd->begin_render_pass(rp);
 
-		VkViewport vp = cmd->get_viewport();
-		calculate_viewport(&vp.x, &vp.y, &vp.width, &vp.height);
-
 		cmd->set_program(program);
 
 		// Basic default render state.
@@ -392,11 +498,43 @@ static void render_frame(Vulkan::Device &device)
 		// If we don't have an image, we just get a cleared screen in the render pass.
 		if (image)
 		{
-			cmd->set_texture(0, 0, image->get_view(), Vulkan::StockSampler::LinearClamp);
+			VkViewport vp = cmd->get_viewport();
+			calculate_viewport(&vp.x, &vp.y, &vp.width, &vp.height, image->get_height() / gfx_info.upscale);
+
+			if (gfx_info.crt)
+			{
+				// Set shader parameters
+				Push push = {
+					{float(image->get_width()), float(image->get_height()), 1.0f / float(image->get_width()), 1.0f / float(image->get_height())},
+					{vp.width, vp.height, 1.0f / vp.width, 1.0f / vp.height},
+				};
+				cmd->push_constants(&push, 0, sizeof(push));
+			}
+
+			cmd->set_texture(0, 0, image->get_view(), Vulkan::StockSampler::NearestClamp);
 			cmd->set_viewport(vp);
 			// The vertices are constants in the shader.
 			// Draws fullscreen quad using oversized triangle.
 			cmd->draw(3);
+
+			if (!messages.empty())
+			{
+				Vulkan::ImageHandle message_image = create_message_image(device, vp.width, messages.front().c_str());
+				cmd->set_texture(0, 0, message_image->get_view(), Vulkan::StockSampler::NearestClamp);
+				vp.x = vp.x + (vp.width - message_image->get_width()) / 2;
+				vp.y = vp.y + vp.height - message_image->get_height();
+				vp.height = message_image->get_height();
+				vp.width = message_image->get_width();
+				cmd->set_viewport(vp);
+
+				cmd->draw(3);
+
+				if (SDL_GetTicks() > message_timer)
+				{
+					messages.pop();
+					message_timer = SDL_GetTicks() + MESSAGE_TIME;
+				}
+			}
 		}
 
 		cmd->end_render_pass();
@@ -409,10 +547,14 @@ 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();
 }
@@ -422,42 +564,73 @@ CALL_BACK rdp_check_callback()
 	CALL_BACK return_value = callback;
 	callback.save_state = false;
 	callback.load_state = false;
+	callback.lower_volume = false;
+	callback.raise_volume = false;
+	callback.frame_advance = false;
 	return return_value;
 }
 
-void rdp_check_framebuffers(uint32_t address)
+void rdp_check_framebuffers(uint32_t address, uint32_t length)
 {
-	if (sync_signal && rdram_dirty[address >> 3])
+	if (sync_signal)
 	{
-		processor->wait_for_timeline(sync_signal);
-		memset(rdram_dirty, 0, gfx_info.RDRAM_SIZE / 8);
-		sync_signal = 0;
+		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;
+		}
 	}
 }
 
-void rdp_full_sync()
+size_t rdp_state_size()
+{
+	return sizeof(RDP_DEVICE);
+}
+
+void rdp_save_state(uint8_t *state)
 {
 	processor->wait_for_timeline(processor->signal_timeline());
+	memcpy(state, &rdp_device, sizeof(RDP_DEVICE));
 }
 
-void calculate_buffer_size()
+void rdp_load_state(const uint8_t *state)
 {
-	switch (frame_buffer_info.framebuffer_pixel_size)
+	memcpy(&rdp_device, state, sizeof(RDP_DEVICE));
+}
+
+void rdp_onscreen_message(const char *_message)
+{
+	if (messages.empty())
+		message_timer = SDL_GetTicks() + MESSAGE_TIME;
+	messages.push(_message);
+}
+
+uint32_t pixel_size(uint32_t pixel_type, uint32_t area)
+{
+	switch (pixel_type)
 	{
 	case 0:
-		frame_buffer_info.framebuffer_size = (frame_buffer_info.framebuffer_width * frame_buffer_info.framebuffer_height / 2) >> 3;
-		break;
+		return area / 2;
 	case 1:
-		frame_buffer_info.framebuffer_size = (frame_buffer_info.framebuffer_width * frame_buffer_info.framebuffer_height) >> 3;
-		break;
+		return area;
 	case 2:
-		frame_buffer_info.framebuffer_size = (frame_buffer_info.framebuffer_width * frame_buffer_info.framebuffer_height * 2) >> 3;
-		break;
+		return area * 2;
 	case 3:
-		frame_buffer_info.framebuffer_size = (frame_buffer_info.framebuffer_width * frame_buffer_info.framebuffer_height * 4) >> 3;
-		break;
+		return area * 4;
+	default:
+		printf("Invalid pixel size: %u\n", pixel_type);
+		return 0;
 	}
-	frame_buffer_info.depthbuffer_size = (frame_buffer_info.framebuffer_width * frame_buffer_info.framebuffer_height * 2) >> 3;
 }
 
 uint64_t rdp_process_commands()
@@ -471,7 +644,7 @@ uint64_t rdp_process_commands()
 		return interrupt_timer;
 
 	length = unsigned(length) >> 3;
-	if ((cmd_ptr + length) & ~(0x0003FFFF >> 3))
+	if ((rdp_device.cmd_ptr + length) & ~(0x0003FFFF >> 3))
 		return interrupt_timer;
 
 	uint32_t offset = DP_CURRENT;
@@ -480,10 +653,10 @@ uint64_t rdp_process_commands()
 		do
 		{
 			offset &= 0xFF8;
-			cmd_data[2 * cmd_ptr + 0] = SDL_Swap32BE(*reinterpret_cast<const uint32_t *>(gfx_info.DMEM + offset));
-			cmd_data[2 * cmd_ptr + 1] = SDL_Swap32BE(*reinterpret_cast<const uint32_t *>(gfx_info.DMEM + offset + 4));
+			rdp_device.cmd_data[2 * rdp_device.cmd_ptr + 0] = SDL_Swap32BE(*reinterpret_cast<const uint32_t *>(gfx_info.DMEM + offset));
+			rdp_device.cmd_data[2 * rdp_device.cmd_ptr + 1] = SDL_Swap32BE(*reinterpret_cast<const uint32_t *>(gfx_info.DMEM + offset + 4));
 			offset += sizeof(uint64_t);
-			cmd_ptr++;
+			rdp_device.cmd_ptr++;
 		} while (--length > 0);
 	}
 	else
@@ -497,89 +670,143 @@ uint64_t rdp_process_commands()
 			do
 			{
 				offset &= 0xFFFFF8;
-				cmd_data[2 * cmd_ptr + 0] = *reinterpret_cast<const uint32_t *>(gfx_info.RDRAM + offset);
-				cmd_data[2 * cmd_ptr + 1] = *reinterpret_cast<const uint32_t *>(gfx_info.RDRAM + offset + 4);
+				rdp_device.cmd_data[2 * rdp_device.cmd_ptr + 0] = *reinterpret_cast<const uint32_t *>(gfx_info.RDRAM + offset);
+				rdp_device.cmd_data[2 * rdp_device.cmd_ptr + 1] = *reinterpret_cast<const uint32_t *>(gfx_info.RDRAM + offset + 4);
 				offset += sizeof(uint64_t);
-				cmd_ptr++;
+				rdp_device.cmd_ptr++;
 			} while (--length > 0);
 		}
 	}
 
-	while (cmd_cur - cmd_ptr < 0)
+	while (rdp_device.cmd_cur - rdp_device.cmd_ptr < 0)
 	{
-		uint32_t w1 = cmd_data[2 * cmd_cur];
-		uint32_t w2 = cmd_data[2 * cmd_cur + 1];
+		uint32_t w1 = rdp_device.cmd_data[2 * rdp_device.cmd_cur];
+		uint32_t w2 = rdp_device.cmd_data[2 * rdp_device.cmd_cur + 1];
 		uint32_t command = (w1 >> 24) & 63;
 		int cmd_length = cmd_len_lut[command];
 
-		if (cmd_ptr - cmd_cur - cmd_length < 0)
+		if (rdp_device.cmd_ptr - rdp_device.cmd_cur - cmd_length < 0)
 		{
 			*gfx_info.DPC_START_REG = *gfx_info.DPC_CURRENT_REG = *gfx_info.DPC_END_REG;
 			return interrupt_timer;
 		}
 
 		if (command >= 8)
-			processor->enqueue_command(cmd_length * 2, &cmd_data[2 * cmd_cur]);
+			processor->enqueue_command(cmd_length * 2, &rdp_device.cmd_data[2 * rdp_device.cmd_cur]);
 
-		if ((RDP::Op(command) >= RDP::Op::FillTriangle && RDP::Op(command) <= RDP::Op::ShadeTextureZBufferTriangle) ||
-			RDP::Op(command) == RDP::Op::TextureRectangle ||
-			RDP::Op(command) == RDP::Op::TextureRectangleFlip ||
-			RDP::Op(command) == RDP::Op::FillRectangle)
+		switch (RDP::Op(command))
 		{
-			if (!rdram_dirty[frame_buffer_info.framebuffer_address])
+		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])
 			{
-				for (uint32_t i = frame_buffer_info.framebuffer_address; i < frame_buffer_info.framebuffer_address + frame_buffer_info.framebuffer_size; ++i)
-				{
-					rdram_dirty[i] = 1;
-				}
+				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 (frame_buffer_info.depthbuffer_enabled && !rdram_dirty[frame_buffer_info.depthbuffer_address])
+			if (rdp_device.frame_buffer_info.depth_buffer_enabled)
 			{
-				for (uint32_t i = frame_buffer_info.depthbuffer_address; i < frame_buffer_info.depthbuffer_address + frame_buffer_info.depthbuffer_size; ++i)
+				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])
 				{
-					rdram_dirty[i] = 1;
+					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);
 				}
 			}
 		}
-		else if (RDP::Op(command) == RDP::Op::SetOtherModes)
+		break;
+		case RDP::Op::LoadTLut:
+		case RDP::Op::LoadTile:
 		{
-			frame_buffer_info.depthbuffer_enabled = (w2 >> 5) & 1;
+			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);
+			}
 		}
-		else if (RDP::Op(command) == RDP::Op::SetColorImage)
+		break;
+		case RDP::Op::LoadBlock:
 		{
-			frame_buffer_info.framebuffer_address = (w2 & 0x00FFFFFF) >> 3;
-			frame_buffer_info.framebuffer_pixel_size = (w1 >> 19) & 0x3;
-			frame_buffer_info.framebuffer_width = (w1 & 0x3FF) + 1;
-			calculate_buffer_size();
+			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);
+			}
 		}
-		else if (RDP::Op(command) == RDP::Op::SetMaskImage)
-		{
-			frame_buffer_info.depthbuffer_address = (w2 & 0x00FFFFFF) >> 3;
-		}
-		else if (RDP::Op(command) == RDP::Op::SetScissor)
+		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;
 			uint32_t upper_left_y = (w1 & 0xFFF) >> 2;
 			uint32_t lower_right_x = ((w2 >> 12) & 0xFFF) >> 2;
 			uint32_t lower_right_y = (w2 & 0xFFF) >> 2;
-			region = (lower_right_x - upper_left_x) * (lower_right_y - upper_left_y);
-			frame_buffer_info.framebuffer_height = lower_right_y;
-			calculate_buffer_size();
+			if (lower_right_x > upper_left_x && lower_right_y > upper_left_y)
+			{
+				rdp_device.region = (lower_right_x - upper_left_x) * (lower_right_y - upper_left_y);
+			}
+			else
+			{
+				rdp_device.region = 0;
+			}
+
+			rdp_device.frame_buffer_info.framebuffer_y_offset = upper_left_y;
+			rdp_device.frame_buffer_info.framebuffer_height = lower_right_y - upper_left_y;
 		}
-		else if (RDP::Op(command) == RDP::Op::SyncFull)
+		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:
 			sync_signal = processor->signal_timeline();
-			interrupt_timer = region;
+
+			interrupt_timer = rdp_device.region;
 			if (interrupt_timer == 0)
 				interrupt_timer = 5000;
+			break;
+		default:
+			break;
 		}
 
-		cmd_cur += cmd_length;
+		rdp_device.cmd_cur += cmd_length;
 	}
 
-	cmd_ptr = 0;
-	cmd_cur = 0;
+	rdp_device.cmd_ptr = 0;
+	rdp_device.cmd_cur = 0;
 	*gfx_info.DPC_CURRENT_REG = *gfx_info.DPC_END_REG;
 
 	return interrupt_timer;

parallel-rdp/interface.hpp

@@ -2,6 +2,7 @@
 
 #ifdef __cplusplus
 #include <cstdint>
+#include <stddef.h>
 
 extern "C"
 {
@@ -18,6 +19,10 @@ extern "C"
 		uint32_t *DPC_STATUS_REG;
 		bool PAL;
 		bool widescreen;
+		bool fullscreen;
+		bool integer_scaling;
+		uint32_t upscale;
+		bool crt;
 	} GFX_INFO;
 
 	typedef struct
@@ -26,17 +31,26 @@ extern "C"
 		bool save_state;
 		bool load_state;
 		bool enable_speedlimiter;
+		bool lower_volume;
+		bool raise_volume;
+		bool paused;
+		bool frame_advance;
+		uint32_t save_state_slot;
 	} CALL_BACK;
 
-	void rdp_init(void *_window, GFX_INFO _gfx_info, uint32_t _upscale, bool _integer_scaling, bool _fullscreen);
+	void rdp_init(void *_window, GFX_INFO _gfx_info, const void *font, size_t font_size);
 	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_new_processor(GFX_INFO _gfx_info, uint32_t _upscale);
-	void rdp_check_framebuffers(uint32_t address);
-	void rdp_full_sync();
+	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);
 
 #ifdef __cplusplus
 }

parallel-rdp/spirv.hpp

@@ -1,19 +1,19 @@
 #pragma once
 
 static const uint32_t vertex_spirv[] =
-	{0x07230203, 0x00010000, 0x000d000a, 0x00000034,
+	{0x07230203, 0x00010300, 0x000d000b, 0x00000034,
 	 0x00000000, 0x00020011, 0x00000001, 0x0006000b,
 	 0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e,
 	 0x00000000, 0x0003000e, 0x00000000, 0x00000001,
 	 0x0008000f, 0x00000000, 0x00000004, 0x6e69616d,
 	 0x00000000, 0x00000008, 0x00000016, 0x0000002b,
 	 0x00040047, 0x00000008, 0x0000000b, 0x0000002a,
-	 0x00050048, 0x00000014, 0x00000000, 0x0000000b,
-	 0x00000000, 0x00050048, 0x00000014, 0x00000001,
-	 0x0000000b, 0x00000001, 0x00050048, 0x00000014,
-	 0x00000002, 0x0000000b, 0x00000003, 0x00050048,
-	 0x00000014, 0x00000003, 0x0000000b, 0x00000004,
-	 0x00030047, 0x00000014, 0x00000002, 0x00040047,
+	 0x00030047, 0x00000014, 0x00000002, 0x00050048,
+	 0x00000014, 0x00000000, 0x0000000b, 0x00000000,
+	 0x00050048, 0x00000014, 0x00000001, 0x0000000b,
+	 0x00000001, 0x00050048, 0x00000014, 0x00000002,
+	 0x0000000b, 0x00000003, 0x00050048, 0x00000014,
+	 0x00000003, 0x0000000b, 0x00000004, 0x00040047,
 	 0x0000002b, 0x0000001e, 0x00000000, 0x00020013,
 	 0x00000002, 0x00030021, 0x00000003, 0x00000002,
 	 0x00040015, 0x00000006, 0x00000020, 0x00000001,
@@ -74,8 +74,8 @@ static const uint32_t vertex_spirv[] =
 	 0x00000030, 0x00000033, 0x0003003e, 0x0000002b,
 	 0x00000032, 0x000100fd, 0x00010038};
 
-static const uint32_t fragment_spirv[] =
-	{0x07230203, 0x00010000, 0x000d000a, 0x00000015,
+static const uint32_t plain_fragment_spirv[] =
+	{0x07230203, 0x00010300, 0x000d000b, 0x00000015,
 	 0x00000000, 0x00020011, 0x00000001, 0x0006000b,
 	 0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e,
 	 0x00000000, 0x0003000e, 0x00000000, 0x00000001,
@@ -83,8 +83,8 @@ static const uint32_t fragment_spirv[] =
 	 0x00000000, 0x00000009, 0x00000011, 0x00030010,
 	 0x00000004, 0x00000007, 0x00040047, 0x00000009,
 	 0x0000001e, 0x00000000, 0x00040047, 0x0000000d,
-	 0x00000022, 0x00000000, 0x00040047, 0x0000000d,
-	 0x00000021, 0x00000000, 0x00040047, 0x00000011,
+	 0x00000021, 0x00000000, 0x00040047, 0x0000000d,
+	 0x00000022, 0x00000000, 0x00040047, 0x00000011,
 	 0x0000001e, 0x00000000, 0x00020013, 0x00000002,
 	 0x00030021, 0x00000003, 0x00000002, 0x00030016,
 	 0x00000006, 0x00000020, 0x00040017, 0x00000007,

parallel-rdp/spirv_crt.hpp

@@ -0,0 +1,456 @@
+#pragma once
+
+static const uint32_t crt_fragment_spirv[] =
+	{0x07230203, 0x00010300, 0x000d000b, 0x000004fd,
+	 0x00000000, 0x00020011, 0x00000001, 0x0006000b,
+	 0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e,
+	 0x00000000, 0x0003000e, 0x00000000, 0x00000001,
+	 0x0007000f, 0x00000004, 0x00000004, 0x6e69616d,
+	 0x00000000, 0x000001ba, 0x0000021a, 0x00030010,
+	 0x00000004, 0x00000007, 0x00030047, 0x00000185,
+	 0x00000002, 0x00050048, 0x00000185, 0x00000000,
+	 0x00000023, 0x00000000, 0x00050048, 0x00000185,
+	 0x00000001, 0x00000023, 0x00000010, 0x00040047,
+	 0x000001ba, 0x0000001e, 0x00000000, 0x00040047,
+	 0x000001ca, 0x00000021, 0x00000000, 0x00040047,
+	 0x000001ca, 0x00000022, 0x00000000, 0x00040047,
+	 0x0000021a, 0x0000001e, 0x00000000, 0x00020013,
+	 0x00000002, 0x00030021, 0x00000003, 0x00000002,
+	 0x00030016, 0x00000006, 0x00000020, 0x00090019,
+	 0x00000007, 0x00000006, 0x00000001, 0x00000000,
+	 0x00000000, 0x00000000, 0x00000001, 0x00000000,
+	 0x0003001b, 0x00000008, 0x00000007, 0x00040020,
+	 0x00000009, 0x00000000, 0x00000008, 0x00040017,
+	 0x0000000a, 0x00000006, 0x00000002, 0x00040017,
+	 0x0000000c, 0x00000006, 0x00000003, 0x00040017,
+	 0x00000037, 0x00000006, 0x00000004, 0x0004002b,
+	 0x00000006, 0x0000003a, 0x4019999a, 0x0006002c,
+	 0x0000000c, 0x0000003b, 0x0000003a, 0x0000003a,
+	 0x0000003a, 0x0004002b, 0x00000006, 0x00000049,
+	 0x3f800000, 0x0004002b, 0x00000006, 0x0000004a,
+	 0x00000000, 0x0004002b, 0x00000006, 0x00000068,
+	 0xbf800000, 0x00040015, 0x0000006b, 0x00000020,
+	 0x00000001, 0x0004002b, 0x0000006b, 0x0000006c,
+	 0x00000000, 0x00040015, 0x0000006f, 0x00000020,
+	 0x00000000, 0x0004002b, 0x0000006f, 0x00000070,
+	 0x00000000, 0x0004002b, 0x0000006b, 0x00000074,
+	 0x00000001, 0x0004002b, 0x0000006f, 0x00000077,
+	 0x00000001, 0x0004002b, 0x00000006, 0x000000a1,
+	 0x3f000000, 0x0005002c, 0x0000000a, 0x000000fc,
+	 0x000000a1, 0x0000004a, 0x0004002b, 0x00000006,
+	 0x00000101, 0x3a83126f, 0x0005002c, 0x0000000a,
+	 0x00000102, 0x000000a1, 0x00000101, 0x0004002b,
+	 0x00000006, 0x0000010b, 0x40490fdb, 0x0004002b,
+	 0x00000006, 0x00000116, 0x40000000, 0x0004002b,
+	 0x00000006, 0x0000011c, 0x3727c5ac, 0x0007002c,
+	 0x00000037, 0x0000012c, 0x00000049, 0x00000049,
+	 0x00000049, 0x00000049, 0x00040018, 0x00000149,
+	 0x00000037, 0x00000004, 0x0006002c, 0x0000000c,
+	 0x00000165, 0x000000a1, 0x000000a1, 0x000000a1,
+	 0x0004002b, 0x00000006, 0x00000166, 0x3fc00000,
+	 0x0006002c, 0x0000000c, 0x00000167, 0x00000166,
+	 0x00000166, 0x00000166, 0x0004002b, 0x00000006,
+	 0x00000169, 0x3ecccccd, 0x0006002c, 0x0000000c,
+	 0x0000016a, 0x00000169, 0x00000169, 0x00000169,
+	 0x0004001e, 0x00000185, 0x00000037, 0x00000037,
+	 0x00040020, 0x00000186, 0x00000009, 0x00000185,
+	 0x0004003b, 0x00000186, 0x00000187, 0x00000009,
+	 0x00040020, 0x00000188, 0x00000009, 0x00000006,
+	 0x00020014, 0x00000196, 0x0006002c, 0x0000000c,
+	 0x0000019a, 0x00000049, 0x0000004a, 0x00000049,
+	 0x0006002c, 0x0000000c, 0x000001a1, 0x0000004a,
+	 0x00000049, 0x0000004a, 0x0006002c, 0x0000000c,
+	 0x000001a4, 0x0000004a, 0x0000004a, 0x00000049,
+	 0x0004002b, 0x0000006f, 0x000001aa, 0x00000003,
+	 0x00040020, 0x000001b9, 0x00000001, 0x0000000a,
+	 0x0004003b, 0x000001b9, 0x000001ba, 0x00000001,
+	 0x00040020, 0x000001bc, 0x00000009, 0x00000037,
+	 0x0004003b, 0x00000009, 0x000001ca, 0x00000000,
+	 0x0004002b, 0x00000006, 0x000001dc, 0x40400000,
+	 0x0004002b, 0x00000006, 0x000001ff, 0x3dcccccd,
+	 0x00040020, 0x00000206, 0x00000001, 0x00000006,
+	 0x0004002b, 0x00000006, 0x0000020c, 0x3e99999a,
+	 0x0004002b, 0x00000006, 0x00000210, 0x3d4ccccd,
+	 0x0004002b, 0x00000006, 0x00000216, 0x3ed55555,
+	 0x0006002c, 0x0000000c, 0x00000217, 0x00000216,
+	 0x00000216, 0x00000216, 0x00040020, 0x00000219,
+	 0x00000003, 0x00000037, 0x0004003b, 0x00000219,
+	 0x0000021a, 0x00000003, 0x0005002c, 0x0000000a,
+	 0x000004f3, 0x000000a1, 0x000000a1, 0x0007002c,
+	 0x00000037, 0x000004f4, 0x0000011c, 0x0000011c,
+	 0x0000011c, 0x0000011c, 0x0006002c, 0x0000000c,
+	 0x000004f6, 0x00000116, 0x00000116, 0x00000116,
+	 0x0006002c, 0x0000000c, 0x000004f7, 0x00000049,
+	 0x00000049, 0x00000049, 0x0006002c, 0x0000000c,
+	 0x000004f8, 0x0000004a, 0x0000004a, 0x0000004a,
+	 0x0006002c, 0x0000000c, 0x000004f9, 0x0000020c,
+	 0x0000020c, 0x0000020c, 0x0007002c, 0x00000037,
+	 0x000004fa, 0x000000a1, 0x000000a1, 0x000000a1,
+	 0x000000a1, 0x0004002b, 0x00000006, 0x000004fb,
+	 0x3eaaaaab, 0x00050036, 0x00000002, 0x00000004,
+	 0x00000000, 0x00000003, 0x000200f8, 0x00000005,
+	 0x00060041, 0x00000188, 0x000001a8, 0x00000187,
+	 0x00000074, 0x00000077, 0x0004003d, 0x00000006,
+	 0x000001a9, 0x000001a8, 0x00060041, 0x00000188,
+	 0x000001ab, 0x00000187, 0x0000006c, 0x000001aa,
+	 0x0004003d, 0x00000006, 0x000001ac, 0x000001ab,
+	 0x00050085, 0x00000006, 0x000001ad, 0x000001a9,
+	 0x000001ac, 0x0006000c, 0x00000006, 0x000001ae,
+	 0x00000001, 0x00000008, 0x000001ad, 0x00050088,
+	 0x00000006, 0x000001b2, 0x000000a1, 0x000001ae,
+	 0x0005008d, 0x00000006, 0x000001b4, 0x000001ae,
+	 0x00000116, 0x000500b7, 0x00000196, 0x000001b5,
+	 0x000001b4, 0x0000004a, 0x000600a9, 0x00000006,
+	 0x000004fc, 0x000001b5, 0x0000004a, 0x000001b2,
+	 0x0004003d, 0x0000000a, 0x000001bb, 0x000001ba,
+	 0x00050041, 0x000001bc, 0x000001bd, 0x00000187,
+	 0x0000006c, 0x0004003d, 0x00000037, 0x000001be,
+	 0x000001bd, 0x0007004f, 0x0000000a, 0x000001bf,
+	 0x000001be, 0x000001be, 0x00000000, 0x00000001,
+	 0x00050085, 0x0000000a, 0x000001c0, 0x000001bb,
+	 0x000001bf, 0x00050050, 0x0000000a, 0x000001c3,
+	 0x0000004a, 0x000004fc, 0x00050083, 0x0000000a,
+	 0x000001c4, 0x000001c0, 0x000001c3, 0x0007004f,
+	 0x0000000a, 0x000001c7, 0x000001be, 0x000001be,
+	 0x00000002, 0x00000003, 0x00050085, 0x0000000a,
+	 0x000001c8, 0x000001c4, 0x000001c7, 0x00050051,
+	 0x00000006, 0x00000249, 0x000001be, 0x00000000,
+	 0x00050088, 0x00000006, 0x0000024a, 0x00000049,
+	 0x00000249, 0x00050050, 0x0000000a, 0x0000024b,
+	 0x0000024a, 0x0000004a, 0x00050051, 0x00000006,
+	 0x0000024d, 0x000001be, 0x00000001, 0x00050088,
+	 0x00000006, 0x0000024e, 0x00000049, 0x0000024d,
+	 0x00050050, 0x0000000a, 0x0000024f, 0x0000004a,
+	 0x0000024e, 0x00050085, 0x0000000a, 0x00000252,
+	 0x000001c8, 0x000001bf, 0x0006000c, 0x0000000a,
+	 0x00000254, 0x00000001, 0x00000008, 0x00000252,
+	 0x00050081, 0x0000000a, 0x00000256, 0x00000254,
+	 0x000004f3, 0x00050088, 0x0000000a, 0x00000258,
+	 0x00000256, 0x000001bf, 0x0006000c, 0x0000000a,
+	 0x0000025a, 0x00000001, 0x0000000a, 0x00000252,
+	 0x00050083, 0x0000000a, 0x0000025c, 0x0000025a,
+	 0x000004f3, 0x0005008e, 0x0000000a, 0x0000025d,
+	 0x0000025c, 0x00000068, 0x00050083, 0x0000000a,
+	 0x00000260, 0x00000258, 0x0000024f, 0x0004003d,
+	 0x00000008, 0x0000028a, 0x000001ca, 0x00050083,
+	 0x0000000a, 0x0000028d, 0x00000260, 0x0000024b,
+	 0x00050057, 0x00000037, 0x0000028e, 0x0000028a,
+	 0x0000028d, 0x0008004f, 0x0000000c, 0x0000028f,
+	 0x0000028e, 0x0000028e, 0x00000000, 0x00000001,
+	 0x00000002, 0x0007000c, 0x0000000c, 0x00000290,
+	 0x00000001, 0x0000001a, 0x0000028f, 0x0000003b,
+	 0x00050057, 0x00000037, 0x00000293, 0x0000028a,
+	 0x00000260, 0x0008004f, 0x0000000c, 0x00000294,
+	 0x00000293, 0x00000293, 0x00000000, 0x00000001,
+	 0x00000002, 0x0007000c, 0x0000000c, 0x00000295,
+	 0x00000001, 0x0000001a, 0x00000294, 0x0000003b,
+	 0x00050081, 0x0000000a, 0x00000299, 0x00000260,
+	 0x0000024b, 0x00050057, 0x00000037, 0x0000029a,
+	 0x0000028a, 0x00000299, 0x0008004f, 0x0000000c,
+	 0x0000029b, 0x0000029a, 0x0000029a, 0x00000000,
+	 0x00000001, 0x00000002, 0x0007000c, 0x0000000c,
+	 0x0000029c, 0x00000001, 0x0000001a, 0x0000029b,
+	 0x0000003b, 0x00050083, 0x0000000a, 0x000002af,
+	 0x00000258, 0x0000024b, 0x00050057, 0x00000037,
+	 0x000002b0, 0x0000028a, 0x000002af, 0x0008004f,
+	 0x0000000c, 0x000002b1, 0x000002b0, 0x000002b0,
+	 0x00000000, 0x00000001, 0x00000002, 0x0007000c,
+	 0x0000000c, 0x000002b2, 0x00000001, 0x0000001a,
+	 0x000002b1, 0x0000003b, 0x00050057, 0x00000037,
+	 0x000002b5, 0x0000028a, 0x00000258, 0x0008004f,
+	 0x0000000c, 0x000002b6, 0x000002b5, 0x000002b5,
+	 0x00000000, 0x00000001, 0x00000002, 0x0007000c,
+	 0x0000000c, 0x000002b7, 0x00000001, 0x0000001a,
+	 0x000002b6, 0x0000003b, 0x00050081, 0x0000000a,
+	 0x000002bb, 0x00000258, 0x0000024b, 0x00050057,
+	 0x00000037, 0x000002bc, 0x0000028a, 0x000002bb,
+	 0x0008004f, 0x0000000c, 0x000002bd, 0x000002bc,
+	 0x000002bc, 0x00000000, 0x00000001, 0x00000002,
+	 0x0007000c, 0x0000000c, 0x000002be, 0x00000001,
+	 0x0000001a, 0x000002bd, 0x0000003b, 0x00050081,
+	 0x0000000a, 0x00000268, 0x00000258, 0x0000024f,
+	 0x00050083, 0x0000000a, 0x000002d1, 0x00000268,
+	 0x0000024b, 0x00050057, 0x00000037, 0x000002d2,
+	 0x0000028a, 0x000002d1, 0x0008004f, 0x0000000c,
+	 0x000002d3, 0x000002d2, 0x000002d2, 0x00000000,
+	 0x00000001, 0x00000002, 0x0007000c, 0x0000000c,
+	 0x000002d4, 0x00000001, 0x0000001a, 0x000002d3,
+	 0x0000003b, 0x00050057, 0x00000037, 0x000002d7,
+	 0x0000028a, 0x00000268, 0x0008004f, 0x0000000c,
+	 0x000002d8, 0x000002d7, 0x000002d7, 0x00000000,
+	 0x00000001, 0x00000002, 0x0007000c, 0x0000000c,
+	 0x000002d9, 0x00000001, 0x0000001a, 0x000002d8,
+	 0x0000003b, 0x00050081, 0x0000000a, 0x000002dd,
+	 0x00000268, 0x0000024b, 0x00050057, 0x00000037,
+	 0x000002de, 0x0000028a, 0x000002dd, 0x0008004f,
+	 0x0000000c, 0x000002df, 0x000002de, 0x000002de,
+	 0x00000000, 0x00000001, 0x00000002, 0x0007000c,
+	 0x0000000c, 0x000002e0, 0x00000001, 0x0000001a,
+	 0x000002df, 0x0000003b, 0x00050051, 0x00000006,
+	 0x0000026d, 0x0000025d, 0x00000000, 0x00050083,
+	 0x00000006, 0x000002f3, 0x0000026d, 0x00000049,
+	 0x00050081, 0x00000006, 0x000002f6, 0x0000026d,
+	 0x00000049, 0x00060050, 0x0000000c, 0x000002f7,
+	 0x000002f3, 0x0000026d, 0x000002f6, 0x00050085,
+	 0x0000000c, 0x000002fa, 0x000002f7, 0x000004f6,
+	 0x00050085, 0x0000000c, 0x000002fd, 0x000002fa,
+	 0x000002fa, 0x0005008e, 0x0000000c, 0x000002fe,
+	 0x000002fd, 0x00000068, 0x0006000c, 0x0000000c,
+	 0x000002ff, 0x00000001, 0x0000001d, 0x000002fe,
+	 0x00050051, 0x00000006, 0x00000303, 0x000002ff,
+	 0x00000000, 0x0005008e, 0x0000000c, 0x00000304,
+	 0x00000290, 0x00000303, 0x00050051, 0x00000006,
+	 0x00000308, 0x000002ff, 0x00000001, 0x0005008e,
+	 0x0000000c, 0x00000309, 0x00000295, 0x00000308,
+	 0x00050081, 0x0000000c, 0x0000030a, 0x00000304,
+	 0x00000309, 0x00050051, 0x00000006, 0x0000030e,
+	 0x000002ff, 0x00000002, 0x0005008e, 0x0000000c,
+	 0x0000030f, 0x0000029c, 0x0000030e, 0x00050081,
+	 0x0000000c, 0x00000310, 0x0000030a, 0x0000030f,
+	 0x00050081, 0x00000006, 0x00000315, 0x00000303,
+	 0x00000308, 0x00050081, 0x00000006, 0x00000318,
+	 0x00000315, 0x0000030e, 0x00060050, 0x0000000c,
+	 0x00000319, 0x00000318, 0x00000318, 0x00000318,
+	 0x00050088, 0x0000000c, 0x0000031a, 0x00000310,
+	 0x00000319, 0x0005008e, 0x0000000c, 0x00000331,
+	 0x000002b2, 0x00000303, 0x0005008e, 0x0000000c,
+	 0x00000336, 0x000002b7, 0x00000308, 0x00050081,
+	 0x0000000c, 0x00000337, 0x00000331, 0x00000336,
+	 0x0005008e, 0x0000000c, 0x0000033c, 0x000002be,
+	 0x0000030e, 0x00050081, 0x0000000c, 0x0000033d,
+	 0x00000337, 0x0000033c, 0x00050088, 0x0000000c,
+	 0x00000347, 0x0000033d, 0x00000319, 0x0005008e,
+	 0x0000000c, 0x0000035e, 0x000002d4, 0x00000303,
+	 0x0005008e, 0x0000000c, 0x00000363, 0x000002d9,
+	 0x00000308, 0x00050081, 0x0000000c, 0x00000364,
+	 0x0000035e, 0x00000363, 0x0005008e, 0x0000000c,
+	 0x00000369, 0x000002e0, 0x0000030e, 0x00050081,
+	 0x0000000c, 0x0000036a, 0x00000364, 0x00000369,
+	 0x00050088, 0x0000000c, 0x00000374, 0x0000036a,
+	 0x00000319, 0x00050051, 0x00000006, 0x00000286,
+	 0x0000025d, 0x00000001, 0x00050083, 0x00000006,
+	 0x0000037a, 0x00000286, 0x00000049, 0x00050081,
+	 0x00000006, 0x0000037d, 0x00000286, 0x00000049,
+	 0x00060050, 0x0000000c, 0x0000037e, 0x0000037a,
+	 0x00000286, 0x0000037d, 0x00050085, 0x0000000c,
+	 0x00000381, 0x0000037e, 0x000004f6, 0x00050085,
+	 0x0000000c, 0x00000384, 0x00000381, 0x00000381,
+	 0x0005008e, 0x0000000c, 0x00000385, 0x00000384,
+	 0x00000068, 0x0006000c, 0x0000000c, 0x00000386,
+	 0x00000001, 0x0000001d, 0x00000385, 0x00050051,
+	 0x00000006, 0x0000038a, 0x00000386, 0x00000000,
+	 0x0005008e, 0x0000000c, 0x0000038b, 0x0000031a,
+	 0x0000038a, 0x00050051, 0x00000006, 0x0000038f,
+	 0x00000386, 0x00000001, 0x0005008e, 0x0000000c,
+	 0x00000390, 0x00000347, 0x0000038f, 0x00050081,
+	 0x0000000c, 0x00000391, 0x0000038b, 0x00000390,
+	 0x00050051, 0x00000006, 0x00000395, 0x00000386,
+	 0x00000002, 0x0005008e, 0x0000000c, 0x00000396,
+	 0x00000374, 0x00000395, 0x00050081, 0x0000000c,
+	 0x00000397, 0x00000391, 0x00000396, 0x00050081,
+	 0x00000006, 0x0000039c, 0x0000038a, 0x0000038f,
+	 0x00050081, 0x00000006, 0x0000039f, 0x0000039c,
+	 0x00000395, 0x00060050, 0x0000000c, 0x000003a0,
+	 0x0000039f, 0x0000039f, 0x0000039f, 0x00050088,
+	 0x0000000c, 0x000003a1, 0x00000397, 0x000003a0,
+	 0x00060052, 0x0000000a, 0x000004e1, 0x00000249,
+	 0x000001bf, 0x00000000, 0x00050085, 0x0000000a,
+	 0x000003b6, 0x000001c8, 0x000004e1, 0x00050083,
+	 0x0000000a, 0x000003b7, 0x000003b6, 0x000000fc,
+	 0x0006000c, 0x0000000a, 0x000003b9, 0x00000001,
+	 0x00000008, 0x000003b7, 0x00050081, 0x0000000a,
+	 0x000003ba, 0x000003b9, 0x00000102, 0x00050088,
+	 0x0000000a, 0x000003bc, 0x000003ba, 0x000004e1,
+	 0x0006000c, 0x0000000a, 0x000003be, 0x00000001,
+	 0x0000000a, 0x000003b7, 0x00050051, 0x00000006,
+	 0x000003c0, 0x000003be, 0x00000000, 0x00050081,
+	 0x00000006, 0x000003c1, 0x000003c0, 0x00000049,
+	 0x00050083, 0x00000006, 0x000003c6, 0x000003c0,
+	 0x00000049, 0x00050083, 0x00000006, 0x000003c9,
+	 0x000003c0, 0x00000116, 0x00070050, 0x00000037,
+	 0x000003ca, 0x000003c1, 0x000003c0, 0x000003c6,
+	 0x000003c9, 0x0005008e, 0x00000037, 0x000003cb,
+	 0x000003ca, 0x0000010b, 0x0006000c, 0x00000037,
+	 0x000003cd, 0x00000001, 0x00000004, 0x000003cb,
+	 0x0007000c, 0x00000037, 0x000003cf, 0x00000001,
+	 0x00000028, 0x000003cd, 0x000004f4, 0x0006000c,
+	 0x00000037, 0x000003d1, 0x00000001, 0x0000000d,
+	 0x000003cf, 0x0005008e, 0x00000037, 0x000003d2,
+	 0x000003d1, 0x00000116, 0x00050085, 0x00000037,
+	 0x000003d5, 0x000003cf, 0x000004fa, 0x0006000c,
+	 0x00000037, 0x000003d6, 0x00000001, 0x0000000d,
+	 0x000003d5, 0x00050085, 0x00000037, 0x000003d7,
+	 0x000003d2, 0x000003d6, 0x00050085, 0x00000037,
+	 0x000003da, 0x000003cf, 0x000003cf, 0x00050088,
+	 0x00000037, 0x000003db, 0x000003d7, 0x000003da,
+	 0x00050094, 0x00000006, 0x000003dd, 0x000003db,
+	 0x0000012c, 0x00070050, 0x00000037, 0x000003df,
+	 0x000003dd, 0x000003dd, 0x000003dd, 0x000003dd,
+	 0x00050088, 0x00000037, 0x000003e0, 0x000003db,
+	 0x000003df, 0x00050057, 0x00000037, 0x000003e3,
+	 0x0000028a, 0x000003bc, 0x0008004f, 0x0000000c,
+	 0x000003e4, 0x000003e3, 0x000003e3, 0x00000000,
+	 0x00000001, 0x00000002, 0x0007000c, 0x0000000c,
+	 0x000003e5, 0x00000001, 0x0000001a, 0x000003e4,
+	 0x0000003b, 0x00050051, 0x00000006, 0x000003e6,
+	 0x000003e5, 0x00000000, 0x00050051, 0x00000006,
+	 0x000003e7, 0x000003e5, 0x00000001, 0x00050051,
+	 0x00000006, 0x000003e8, 0x000003e5, 0x00000002,
+	 0x00050081, 0x0000000a, 0x000003ed, 0x000003bc,
+	 0x0000024b, 0x00050057, 0x00000037, 0x000003ee,
+	 0x0000028a, 0x000003ed, 0x0008004f, 0x0000000c,
+	 0x000003ef, 0x000003ee, 0x000003ee, 0x00000000,
+	 0x00000001, 0x00000002, 0x0007000c, 0x0000000c,
+	 0x000003f0, 0x00000001, 0x0000001a, 0x000003ef,
+	 0x0000003b, 0x00050051, 0x00000006, 0x000003f1,
+	 0x000003f0, 0x00000000, 0x00050051, 0x00000006,
+	 0x000003f2, 0x000003f0, 0x00000001, 0x00050051,
+	 0x00000006, 0x000003f3, 0x000003f0, 0x00000002,
+	 0x00070050, 0x00000037, 0x00000407, 0x000003e6,
+	 0x000003e7, 0x000003e8, 0x00000049, 0x00070050,
+	 0x00000037, 0x00000409, 0x000003f1, 0x000003f2,
+	 0x000003f3, 0x00000049, 0x00070050, 0x00000149,
+	 0x0000040b, 0x00000407, 0x00000407, 0x00000409,
+	 0x00000409, 0x00050091, 0x00000037, 0x0000040d,
+	 0x0000040b, 0x000003e0, 0x0008004f, 0x0000000c,
+	 0x0000040e, 0x0000040d, 0x0000040d, 0x00000000,
+	 0x00000001, 0x00000002, 0x00050085, 0x00000006,
+	 0x0000041b, 0x00000249, 0x000001dc, 0x00060052,
+	 0x0000000a, 0x000004e9, 0x0000041b, 0x000001bf,
+	 0x00000000, 0x00050088, 0x00000006, 0x0000041f,
+	 0x000004fb, 0x00000249, 0x00050050, 0x0000000a,
+	 0x00000420, 0x0000041f, 0x0000004a, 0x00050085,
+	 0x0000000a, 0x00000423, 0x000001c8, 0x000004e9,
+	 0x00050083, 0x0000000a, 0x00000424, 0x00000423,
+	 0x000000fc, 0x0006000c, 0x0000000a, 0x00000426,
+	 0x00000001, 0x00000008, 0x00000424, 0x00050081,
+	 0x0000000a, 0x00000427, 0x00000426, 0x00000102,
+	 0x00050088, 0x0000000a, 0x00000429, 0x00000427,
+	 0x000004e9, 0x0006000c, 0x0000000a, 0x0000042b,
+	 0x00000001, 0x0000000a, 0x00000424, 0x00050051,
+	 0x00000006, 0x0000042d, 0x0000042b, 0x00000000,
+	 0x00050081, 0x00000006, 0x0000042e, 0x0000042d,
+	 0x00000049, 0x00050083, 0x00000006, 0x00000433,
+	 0x0000042d, 0x00000049, 0x00050083, 0x00000006,
+	 0x00000436, 0x0000042d, 0x00000116, 0x00070050,
+	 0x00000037, 0x00000437, 0x0000042e, 0x0000042d,
+	 0x00000433, 0x00000436, 0x0005008e, 0x00000037,
+	 0x00000438, 0x00000437, 0x0000010b, 0x0006000c,
+	 0x00000037, 0x0000043a, 0x00000001, 0x00000004,
+	 0x00000438, 0x0007000c, 0x00000037, 0x0000043c,
+	 0x00000001, 0x00000028, 0x0000043a, 0x000004f4,
+	 0x0006000c, 0x00000037, 0x0000043e, 0x00000001,
+	 0x0000000d, 0x0000043c, 0x0005008e, 0x00000037,
+	 0x0000043f, 0x0000043e, 0x00000116, 0x00050085,
+	 0x00000037, 0x00000442, 0x0000043c, 0x000004fa,
+	 0x0006000c, 0x00000037, 0x00000443, 0x00000001,
+	 0x0000000d, 0x00000442, 0x00050085, 0x00000037,
+	 0x00000444, 0x0000043f, 0x00000443, 0x00050085,
+	 0x00000037, 0x00000447, 0x0000043c, 0x0000043c,
+	 0x00050088, 0x00000037, 0x00000448, 0x00000444,
+	 0x00000447, 0x00050094, 0x00000006, 0x0000044a,
+	 0x00000448, 0x0000012c, 0x00070050, 0x00000037,
+	 0x0000044c, 0x0000044a, 0x0000044a, 0x0000044a,
+	 0x0000044a, 0x00050088, 0x00000037, 0x0000044d,
+	 0x00000448, 0x0000044c, 0x00050057, 0x00000037,
+	 0x00000450, 0x0000028a, 0x00000429, 0x0008004f,
+	 0x0000000c, 0x00000451, 0x00000450, 0x00000450,
+	 0x00000000, 0x00000001, 0x00000002, 0x0007000c,
+	 0x0000000c, 0x00000452, 0x00000001, 0x0000001a,
+	 0x00000451, 0x0000003b, 0x00050051, 0x00000006,
+	 0x00000453, 0x00000452, 0x00000000, 0x00050051,
+	 0x00000006, 0x00000454, 0x00000452, 0x00000001,
+	 0x00050051, 0x00000006, 0x00000455, 0x00000452,
+	 0x00000002, 0x00050081, 0x0000000a, 0x0000045a,
+	 0x00000429, 0x00000420, 0x00050057, 0x00000037,
+	 0x0000045b, 0x0000028a, 0x0000045a, 0x0008004f,
+	 0x0000000c, 0x0000045c, 0x0000045b, 0x0000045b,
+	 0x00000000, 0x00000001, 0x00000002, 0x0007000c,
+	 0x0000000c, 0x0000045d, 0x00000001, 0x0000001a,
+	 0x0000045c, 0x0000003b, 0x00050051, 0x00000006,
+	 0x0000045e, 0x0000045d, 0x00000000, 0x00050051,
+	 0x00000006, 0x0000045f, 0x0000045d, 0x00000001,
+	 0x00050051, 0x00000006, 0x00000460, 0x0000045d,
+	 0x00000002, 0x00070050, 0x00000037, 0x00000474,
+	 0x00000453, 0x00000454, 0x00000455, 0x00000049,
+	 0x00070050, 0x00000037, 0x00000476, 0x0000045e,
+	 0x0000045f, 0x00000460, 0x00000049, 0x00070050,
+	 0x00000149, 0x00000478, 0x00000474, 0x00000474,
+	 0x00000476, 0x00000476, 0x00050091, 0x00000037,
+	 0x0000047a, 0x00000478, 0x0000044d, 0x0008004f,
+	 0x0000000c, 0x0000047b, 0x0000047a, 0x0000047a,
+	 0x00000000, 0x00000001, 0x00000002, 0x00050085,
+	 0x0000000c, 0x000001e8, 0x0000047b, 0x0000040e,
+	 0x0006000c, 0x0000000c, 0x000001e9, 0x00000001,
+	 0x0000001f, 0x000001e8, 0x00050051, 0x00000006,
+	 0x000001eb, 0x000001c8, 0x00000001, 0x00060041,
+	 0x00000188, 0x000001ec, 0x00000187, 0x0000006c,
+	 0x00000077, 0x0004003d, 0x00000006, 0x000001ed,
+	 0x000001ec, 0x00050085, 0x00000006, 0x000001ee,
+	 0x000001eb, 0x000001ed, 0x0006000c, 0x00000006,
+	 0x000001ef, 0x00000001, 0x0000000a, 0x000001ee,
+	 0x0007000c, 0x0000000c, 0x00000482, 0x00000001,
+	 0x0000001a, 0x0000040e, 0x0000016a, 0x0008000c,
+	 0x0000000c, 0x00000483, 0x00000001, 0x0000002e,
+	 0x00000165, 0x00000167, 0x00000482, 0x00050088,
+	 0x0000000c, 0x00000486, 0x000004f6, 0x00000483,
+	 0x0005008e, 0x0000000c, 0x00000488, 0x00000486,
+	 0x000000a1, 0x0005008e, 0x0000000c, 0x0000048b,
+	 0x00000486, 0x000001ef, 0x00050083, 0x0000000c,
+	 0x0000048d, 0x0000048b, 0x00000488, 0x0006000c,
+	 0x0000000c, 0x0000048e, 0x00000001, 0x00000004,
+	 0x0000048d, 0x00050083, 0x0000000c, 0x00000490,
+	 0x000004f7, 0x0000048e, 0x0008000c, 0x0000000c,
+	 0x00000493, 0x00000001, 0x00000031, 0x000004f8,
+	 0x000004f7, 0x00000490, 0x00050085, 0x0000000c,
+	 0x00000495, 0x00000493, 0x00000488, 0x00050085,
+	 0x0000000c, 0x000001f5, 0x000001e9, 0x00000495,
+	 0x00050083, 0x0000000c, 0x000001f8, 0x000003a1,
+	 0x000001f5, 0x0008000c, 0x0000000c, 0x000001fb,
+	 0x00000001, 0x0000002b, 0x000001f8, 0x000004f8,
+	 0x000004f7, 0x00050085, 0x0000000c, 0x000001fe,
+	 0x000001fb, 0x000001fb, 0x0005008e, 0x0000000c,
+	 0x00000200, 0x000001fe, 0x000001ff, 0x00050081,
+	 0x0000000c, 0x00000202, 0x000001f5, 0x00000200,
+	 0x00050041, 0x00000206, 0x00000207, 0x000001ba,
+	 0x00000070, 0x0004003d, 0x00000006, 0x00000208,
+	 0x00000207, 0x000300f7, 0x000004b3, 0x00000000,
+	 0x000300fb, 0x00000070, 0x0000049b, 0x000200f8,
+	 0x0000049b, 0x00060041, 0x00000188, 0x0000049d,
+	 0x00000187, 0x00000074, 0x00000070, 0x0004003d,
+	 0x00000006, 0x0000049e, 0x0000049d, 0x00050085,
+	 0x00000006, 0x0000049f, 0x00000208, 0x0000049e,
+	 0x0006000c, 0x00000006, 0x000004a7, 0x00000001,
+	 0x00000008, 0x0000049f, 0x0005008d, 0x00000006,
+	 0x000004a8, 0x000004a7, 0x00000116, 0x000500b4,
+	 0x00000196, 0x000004aa, 0x000004a8, 0x0000004a,
+	 0x000300f7, 0x000004b2, 0x00000000, 0x000400fa,
+	 0x000004aa, 0x000004ab, 0x000004ac, 0x000200f8,
+	 0x000004ac, 0x000500b4, 0x00000196, 0x000004ae,
+	 0x000004a8, 0x00000049, 0x000300f7, 0x000004b1,
+	 0x00000000, 0x000400fa, 0x000004ae, 0x000004af,
+	 0x000004b0, 0x000200f8, 0x000004b0, 0x000200f9,
+	 0x000004b3, 0x000200f8, 0x000004af, 0x000200f9,
+	 0x000004b3, 0x000200f8, 0x000004b1, 0x000100ff,
+	 0x000200f8, 0x000004ab, 0x000200f9, 0x000004b3,
+	 0x000200f8, 0x000004b2, 0x000100ff, 0x000200f8,
+	 0x000004b3, 0x000900f5, 0x0000000c, 0x000004f1,
+	 0x0000019a, 0x000004ab, 0x000001a1, 0x000004af,
+	 0x000001a4, 0x000004b0, 0x00050085, 0x0000000c,
+	 0x0000020a, 0x00000202, 0x000004f1, 0x0005008e,
+	 0x0000000c, 0x0000020b, 0x0000020a, 0x00000116,
+	 0x0008000c, 0x0000000c, 0x0000020e, 0x00000001,
+	 0x0000002e, 0x00000202, 0x0000020b, 0x000004f9,
+	 0x0005008e, 0x0000000c, 0x00000211, 0x000001fb,
+	 0x00000210, 0x00050081, 0x0000000c, 0x00000213,
+	 0x0000020e, 0x00000211, 0x0005008e, 0x0000000c,
+	 0x00000215, 0x00000213, 0x00000166, 0x0007000c,
+	 0x0000000c, 0x00000218, 0x00000001, 0x0000001a,
+	 0x00000215, 0x00000217, 0x00050051, 0x00000006,
+	 0x0000021c, 0x00000218, 0x00000000, 0x00050051,
+	 0x00000006, 0x0000021d, 0x00000218, 0x00000001,
+	 0x00050051, 0x00000006, 0x0000021e, 0x00000218,
+	 0x00000002, 0x00070050, 0x00000037, 0x0000021f,
+	 0x0000021c, 0x0000021d, 0x0000021e, 0x00000049,
+	 0x0003003e, 0x0000021a, 0x0000021f, 0x000100fd,
+	 0x00010038};

parallel-rdp/wsi_platform.cpp

@@ -28,7 +28,7 @@ std::vector<const char *> SDL_WSIPlatform::get_instance_extensions()
 	}
 
 	std::vector<const char *> extensionNames;
-	for (int i = 0; i < extensionCount; ++i)
+	for (unsigned int i = 0; i < extensionCount; ++i)
 	{
 		extensionNames.push_back(extensions[i]);
 	}
@@ -56,7 +56,6 @@ bool SDL_WSIPlatform::alive(Vulkan::WSI &wsi)
 
 void SDL_WSIPlatform::poll_input()
 {
-	SDL_PumpEvents();
 }
 
 void SDL_WSIPlatform::poll_input_async(Granite::InputTrackerHandler *handler)

rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "1.94.0"

src/cheats.rs

@@ -0,0 +1,189 @@
+use crate::device;
+use crate::ui;
+
+#[derive(serde::Serialize, serde::Deserialize, Copy, Clone)]
+pub struct DecodedCheat {
+    code_type: u8,
+    address: u32,
+    data: u16,
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct Cheats {
+    pub cheats: Vec<Vec<DecodedCheat>>,
+    pub boot: bool,
+    pub enabled: bool,
+}
+
+pub fn init(
+    device: &mut device::Device,
+    cheat_settings: std::collections::HashMap<String, Option<String>>,
+) {
+    let cheats =
+        serde_json::from_slice::<ui::cheats::Cheats>(include_bytes!("../data/cheats.json"))
+            .unwrap()
+            .get(&ui::storage::get_game_crc(&device.cart.rom))
+            .cloned()
+            .unwrap_or_default();
+
+    let re = regex::Regex::new(r"\?+").unwrap();
+    for cheat_setting in cheat_settings.iter() {
+        if let Some(cheat_data) = cheats.get(cheat_setting.0) {
+            let mut option_value = None;
+            if let Some(option) = cheat_setting.1 {
+                if let Some(found_option_value) = cheat_data
+                    .options
+                    .as_ref()
+                    .cloned()
+                    .unwrap_or_default()
+                    .get(option)
+                {
+                    option_value = Some(found_option_value.to_string());
+                } else {
+                    panic!("Cheat option: {option} not found");
+                }
+            }
+
+            println!(
+                "Cheat: {} Option: {}",
+                cheat_setting.0,
+                cheat_setting.1.clone().unwrap_or("none".to_string())
+            );
+            let mut decoded_cheat: Vec<DecodedCheat> = vec![];
+            for code in cheat_data.data.iter() {
+                let mut result = code.clone();
+                if let Some(option_value) = option_value.as_ref() {
+                    result = re.replace_all(code, option_value).into_owned();
+                }
+                let mut split = result.split_whitespace();
+                let first_part = u32::from_str_radix(split.next().unwrap(), 16).unwrap();
+                decoded_cheat.push(DecodedCheat {
+                    code_type: (first_part >> 24) as u8,
+                    address: first_part & 0x00FFFFFF,
+                    data: u16::from_str_radix(split.next().unwrap(), 16).unwrap(),
+                });
+            }
+            device.cheats.cheats.push(decoded_cheat);
+        } else {
+            println!("Could not find cheat: {}", cheat_setting.0);
+        }
+    }
+
+    if !device.cheats.cheats.is_empty() {
+        device.cheats.enabled = true;
+        ui::video::onscreen_message(&device.ui, "Cheats enabled");
+    }
+}
+
+fn write_byte(device: &mut device::Device, cheat_line: &DecodedCheat) {
+    *device
+        .rdram
+        .mem
+        .get_mut(cheat_line.address as usize ^ device.byte_swap)
+        .unwrap_or(&mut 0) = cheat_line.data as u8;
+}
+
+fn write_half(device: &mut device::Device, cheat_line: &DecodedCheat) {
+    *device
+        .rdram
+        .mem
+        .get_mut(cheat_line.address as usize ^ device.byte_swap)
+        .unwrap_or(&mut 0) = (cheat_line.data >> 8) as u8;
+    *device
+        .rdram
+        .mem
+        .get_mut((cheat_line.address + 1) as usize ^ device.byte_swap)
+        .unwrap_or(&mut 0) = cheat_line.data as u8;
+}
+
+fn equal_byte(device: &mut device::Device, cheat_line: &DecodedCheat) -> bool {
+    let current_value = *device
+        .rdram
+        .mem
+        .get(cheat_line.address as usize ^ device.byte_swap)
+        .unwrap_or(&0);
+    current_value == (cheat_line.data as u8)
+}
+
+fn equal_half(device: &mut device::Device, cheat_line: &DecodedCheat) -> bool {
+    let current_value1 = *device
+        .rdram
+        .mem
+        .get(cheat_line.address as usize ^ device.byte_swap)
+        .unwrap_or(&0);
+    let current_value2 = *device
+        .rdram
+        .mem
+        .get((cheat_line.address + 1) as usize ^ device.byte_swap)
+        .unwrap_or(&0);
+    current_value1 == (cheat_line.data >> 8) as u8 && current_value2 == cheat_line.data as u8
+}
+
+pub fn execute_cheats(device: &mut device::Device, cheats: Vec<Vec<DecodedCheat>>) {
+    for cheat in cheats.iter() {
+        let mut valid = true;
+        let mut cheat_iter = cheat.iter().peekable();
+        while let Some(cheat_line) = cheat_iter.next() {
+            match cheat_line.code_type {
+                0x50 => {
+                    if valid {
+                        let mut expanded_cheat: Vec<DecodedCheat> = vec![];
+                        let compressed_cheat = *cheat_iter.peek().unwrap();
+                        let count = (cheat_line.address & 0xFF00) >> 8;
+                        let offset = cheat_line.address & 0xFF;
+                        for i in 0..count {
+                            let line = DecodedCheat {
+                                code_type: compressed_cheat.code_type,
+                                address: compressed_cheat.address + (i * offset),
+                                data: compressed_cheat.data
+                                    + (i as i16 * cheat_line.data as i16) as u16,
+                            };
+                            expanded_cheat.push(line);
+                        }
+                        execute_cheats(device, [expanded_cheat].to_vec());
+                    }
+                    valid = false; // skip the next line
+                }
+                0x80 | 0xA0 => {
+                    if valid {
+                        write_byte(device, cheat_line);
+                    }
+                    valid = true;
+                }
+                0x81 | 0xA1 => {
+                    if valid {
+                        write_half(device, cheat_line);
+                    }
+                    valid = true;
+                }
+                0xF0 => {
+                    if device.cheats.boot && valid {
+                        write_byte(device, cheat_line);
+                        valid = true;
+                    }
+                }
+                0xF1 => {
+                    if device.cheats.boot && valid {
+                        write_half(device, cheat_line);
+                        valid = true;
+                    }
+                }
+                0xD0 => {
+                    valid = equal_byte(device, cheat_line);
+                }
+                0xD1 => {
+                    valid = equal_half(device, cheat_line);
+                }
+                0xD2 => {
+                    valid = !equal_byte(device, cheat_line);
+                }
+                0xD3 => {
+                    valid = !equal_half(device, cheat_line);
+                }
+                0x88 | 0x89 | 0xD8 | 0xD9 | 0xDA | 0xDB => { /* GS button not emulated */ }
+                _ => panic!("Unknown cheat code type: {:X}", cheat_line.code_type),
+            }
+        }
+    }
+    device.cheats.boot = false;
+}

src/compat/aarch64.c

@@ -1,4 +1,4 @@
-#include "src/compat/sse2neon/v1.8.0/sse2neon.h"
+#include "src/compat/sse2neon/sse2neon.h"
 
 // Static wrappers
 

src/device.rs

@@ -10,9 +10,9 @@ include!(concat!(env!("OUT_DIR"), "/simd_bindings.rs"));
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
 
-use rand_chacha::rand_core::{RngCore, SeedableRng};
+use rand::{Rng, SeedableRng};
 
-use crate::{netplay, ui};
+use crate::{cheats, netplay, ui};
 use std::{collections::HashMap, fs, io::Read};
 
 pub mod ai;
@@ -44,9 +44,12 @@ pub mod tlb;
 pub mod unmapped;
 pub mod vi;
 
-pub fn run_game(device: &mut Device, rom_contents: Vec<u8>, fullscreen: bool, overclock: bool) {
-    device.ui.fullscreen = fullscreen;
-    device.cpu.overclock = overclock;
+pub fn run_game(device: &mut Device, rom_contents: Vec<u8>, game_settings: ui::gui::GameSettings) {
+    device.ui.video.fullscreen = game_settings.fullscreen;
+    device.cpu.overclock = game_settings.overclock;
+    if game_settings.disable_expansion_pak {
+        device.rdram.size = 0x400000;
+    }
 
     init_rng(device);
 
@@ -55,13 +58,13 @@ pub fn run_game(device: &mut Device, rom_contents: Vec<u8>, fullscreen: bool, ov
     // rdram pointer is shared with parallel-rdp
     rdram::init(device);
 
-    ui::audio::init(&mut device.ui, device.ai.freq);
     ui::video::init(device);
+    ui::audio::init(&mut device.ui, device.ai.freq);
     ui::input::init(&mut device.ui);
 
     mi::init(device);
     pif::init(device);
-    if device.ui.config.input.emulate_vru {
+    if device.ui.config.input.emulate_vru && device.netplay.is_none() {
         controller::vru::init(device);
     }
     memory::init(device);
@@ -74,36 +77,37 @@ pub fn run_game(device: &mut Device, rom_contents: Vec<u8>, fullscreen: bool, ov
     ui::storage::init(&mut device.ui, &device.cart.rom);
     ui::storage::load_saves(&mut device.ui, &mut device.netplay);
 
+    cheats::init(device, game_settings.cheats);
+
     cpu::run(device);
 
-    ui::input::close(&mut device.ui);
-    ui::video::close(&device.ui);
-    ui::audio::close(&mut device.ui);
     ui::storage::write_saves(device);
+    ui::input::close(&mut device.ui);
+    ui::audio::close(&mut device.ui);
+    ui::video::close(&device.ui);
 }
 
-fn set_rng() -> rand_chacha::ChaCha8Rng {
-    rand_chacha::ChaCha8Rng::from_os_rng()
+fn set_rng() -> rand::rngs::Xoshiro256PlusPlus {
+    rand::rngs::Xoshiro256PlusPlus::try_from_rng(&mut rand::rngs::SysRng).unwrap()
 }
 
 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 {
             rng_seed = netplay::receive_rng(netplay);
         }
     }
-    device.rng = rand_chacha::ChaCha8Rng::seed_from_u64(rng_seed);
+    device.rng = rand::rngs::Xoshiro256PlusPlus::seed_from_u64(rng_seed);
 }
 
-fn swap_rom(contents: Vec<u8>) -> Vec<u8> {
+fn swap_rom(contents: Vec<u8>) -> Option<Vec<u8>> {
     let test = u32::from_be_bytes(contents[0..4].try_into().unwrap());
     if test == 0x80371240 {
         // z64
-        contents
+        Some(contents)
     } else if test == 0x37804012 {
         // v64
         let mut data: Vec<u8> = vec![0; contents.len()];
@@ -111,7 +115,7 @@ fn swap_rom(contents: Vec<u8>) -> Vec<u8> {
             let temp = u16::from_ne_bytes(contents[i..i + 2].try_into().unwrap());
             data[i..i + 2].copy_from_slice(&temp.to_be_bytes());
         }
-        return data;
+        Some(data)
     } else if test == 0x40123780 {
         // n64
         let mut data: Vec<u8> = vec![0; contents.len()];
@@ -119,14 +123,13 @@ fn swap_rom(contents: Vec<u8>) -> Vec<u8> {
             let temp = u32::from_ne_bytes(contents[i..i + 4].try_into().unwrap());
             data[i..i + 4].copy_from_slice(&temp.to_be_bytes());
         }
-        return data;
+        Some(data)
     } else {
-        let data: Vec<u8> = vec![];
-        data
+        None
     }
 }
 
-pub fn get_rom_contents(file_path: &std::path::Path) -> Vec<u8> {
+pub fn get_rom_contents(file_path: &std::path::Path) -> Option<Vec<u8>> {
     let mut contents = vec![];
     if file_path.extension().unwrap().eq_ignore_ascii_case("zip") {
         let zip_file = fs::File::open(file_path).unwrap();
@@ -147,12 +150,12 @@ pub fn get_rom_contents(file_path: &std::path::Path) -> Vec<u8> {
         }
     } else if file_path.extension().unwrap().eq_ignore_ascii_case("7z") {
         let mut archive =
-            sevenz_rust::SevenZReader::open(file_path, sevenz_rust::Password::empty()).unwrap();
+            sevenz_rust2::ArchiveReader::open(file_path, sevenz_rust2::Password::empty()).unwrap();
 
         let mut found = false;
         archive
             .for_each_entries(
-                &mut |entry: &sevenz_rust::SevenZArchiveEntry, reader: &mut dyn std::io::Read| {
+                &mut |entry: &sevenz_rust2::ArchiveEntry, reader: &mut dyn std::io::Read| {
                     let name = entry.name().to_ascii_lowercase();
                     if !found
                         && (name.ends_with("z64") || name.ends_with("n64") || name.ends_with("v64"))
@@ -173,7 +176,11 @@ pub fn get_rom_contents(file_path: &std::path::Path) -> Vec<u8> {
         contents = fs::read(file_path).expect("Should have been able to read the file");
     }
 
-    swap_rom(contents)
+    if contents.is_empty() {
+        None
+    } else {
+        swap_rom(contents)
+    }
 }
 
 #[derive(serde::Serialize, serde::Deserialize)]
@@ -182,7 +189,7 @@ pub struct Device {
     pub netplay: Option<netplay::Netplay>,
     #[serde(skip, default = "ui::Ui::default")]
     pub ui: ui::Ui,
-    byte_swap: usize,
+    pub byte_swap: usize,
     pub save_state: bool,
     pub load_state: bool,
     pub cpu: cpu::Cpu,
@@ -199,10 +206,10 @@ pub struct Device {
     pub si: si::Si,
     pub ri: ri::Ri,
     #[serde(skip, default = "set_rng")]
-    pub rng: rand_chacha::ChaCha8Rng,
+    pub rng: rand::rngs::Xoshiro256PlusPlus,
     pub vru: controller::vru::Vru,
-    pub vru_window: controller::vru::VruWindow,
     pub transferpaks: [controller::transferpak::TransferPak; 4],
+    pub cheats: cheats::Cheats,
 }
 
 pub fn zero_m128i() -> __m128i {
@@ -338,6 +345,7 @@ impl Device {
                     sector: 0,
                     buffer: vec![0; 8192],
                     writeback_sector: vec![0; 256],
+                    usb_buffer: vec![],
                 },
                 flashram: cart::sram::Flashram {
                     status: 0,
@@ -348,7 +356,7 @@ impl Device {
                 },
             },
             memory: memory::Memory {
-                fast_read: [unmapped::read_mem; 0x2000],
+                fast_read: [unmapped::read_mem_fast; 0x2000],
                 memory_map_read: [unmapped::read_mem; 0x2000],
                 memory_map_write: [unmapped::write_mem; 0x2000],
                 icache: [cache::ICache {
@@ -473,11 +481,6 @@ impl Device {
                 limit_freq: 2,
                 limit_freq_check: std::time::Instant::now(),
             },
-            vru_window: controller::vru::VruWindow {
-                window_notifier: None,
-                word_receiver: None,
-                gui_ctx: None,
-            },
             vru: controller::vru::Vru {
                 status: 0,
                 voice_state: 0,
@@ -495,6 +498,11 @@ impl Device {
                 controller::transferpak::TransferPak::default(),
                 controller::transferpak::TransferPak::default(),
             ],
+            cheats: cheats::Cheats {
+                cheats: vec![],
+                boot: true,
+                enabled: false,
+            },
         }
     }
 }

src/device/ai.rs

@@ -27,7 +27,7 @@ pub struct AiDma {
     pub duration: u64,
 }
 
-fn get_remaining_dma_length(device: &mut device::Device) -> u64 {
+fn get_remaining_dma_length(device: &device::Device) -> u64 {
     if device.ai.fifo[0].duration == 0 {
         return 0;
     }
@@ -45,11 +45,10 @@ fn get_remaining_dma_length(device: &mut device::Device) -> u64 {
 }
 
 fn get_dma_duration(device: &device::Device) -> u64 {
-    let samples_per_sec = device.vi.clock / (1 + device.ai.regs[AI_DACRATE_REG as usize]) as u64;
     let bytes_per_sample = 4; /* XXX: assume 16bit stereo - should depends on bitrate instead */
     let length = (device.ai.regs[AI_LEN_REG as usize] & !7) as u64;
 
-    length * (device.cpu.clock_rate / (bytes_per_sample * samples_per_sec))
+    (length * device.cpu.clock_rate) / (bytes_per_sample * device.ai.freq)
 }
 
 fn do_dma(device: &mut device::Device) {
@@ -146,8 +145,8 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
         AI_DACRATE_REG => {
             if device.ai.regs[reg as usize] != value & mask {
                 device.ai.freq = device.vi.clock / (1 + (value & mask)) as u64;
-                ui::audio::close(&mut device.ui);
-                ui::audio::init(&mut device.ui, device.ai.freq)
+                ui::audio::close_game_audio(&mut device.ui);
+                ui::audio::init_game_audio(&mut device.ui, device.ai.freq)
             }
             device::memory::masked_write_32(&mut device.ai.regs[reg as usize], value, mask)
         }

src/device/cache.rs

@@ -30,54 +30,14 @@ pub fn icache_writeback(device: &mut device::Device, line_index: usize) {
     let cache_address = ((device.memory.icache[line_index].tag
         | (device.memory.icache[line_index].index) as u32)
         & 0x1ffffffc) as u64;
-    device.memory.memory_map_write[(cache_address >> 16) as usize](
-        device,
-        cache_address,
-        device.memory.icache[line_index].words[0],
-        0xFFFFFFFF,
-    );
-    device.memory.memory_map_write[(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x4,
-        device.memory.icache[line_index].words[1],
-        0xFFFFFFFF,
-    );
-    device.memory.memory_map_write[(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x8,
-        device.memory.icache[line_index].words[2],
-        0xFFFFFFFF,
-    );
-    device.memory.memory_map_write[(cache_address >> 16) as usize](
-        device,
-        cache_address | 0xC,
-        device.memory.icache[line_index].words[3],
-        0xFFFFFFFF,
-    );
-    device.memory.memory_map_write[(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x10,
-        device.memory.icache[line_index].words[4],
-        0xFFFFFFFF,
-    );
-    device.memory.memory_map_write[(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x14,
-        device.memory.icache[line_index].words[5],
-        0xFFFFFFFF,
-    );
-    device.memory.memory_map_write[(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x18,
-        device.memory.icache[line_index].words[6],
-        0xFFFFFFFF,
-    );
-    device.memory.memory_map_write[(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x1C,
-        device.memory.icache[line_index].words[7],
-        0xFFFFFFFF,
-    );
+    for i in 0..8 {
+        device.memory.memory_map_write[(cache_address >> 16) as usize](
+            device,
+            cache_address | (i * 4),
+            device.memory.icache[line_index].words[i as usize],
+            0xFFFFFFFF,
+        );
+    }
 }
 
 pub fn icache_fill(device: &mut device::Device, line_index: usize, phys_address: u64) {
@@ -88,71 +48,17 @@ pub fn icache_fill(device: &mut device::Device, line_index: usize, phys_address:
     let cache_address = ((device.memory.icache[line_index].tag
         | (device.memory.icache[line_index].index) as u32)
         & 0x1ffffffc) as u64;
-    device.memory.icache[line_index].words[0] = device.memory.memory_map_read
-        [(cache_address >> 16) as usize](
-        device,
-        cache_address,
-        device::memory::AccessSize::Icache,
-    );
-    device.memory.icache[line_index].words[1] = device.memory.memory_map_read
-        [(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x4,
-        device::memory::AccessSize::Icache,
-    );
-    device.memory.icache[line_index].words[2] = device.memory.memory_map_read
-        [(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x8,
-        device::memory::AccessSize::Icache,
-    );
-    device.memory.icache[line_index].words[3] = device.memory.memory_map_read
-        [(cache_address >> 16) as usize](
-        device,
-        cache_address | 0xC,
-        device::memory::AccessSize::Icache,
-    );
-    device.memory.icache[line_index].words[4] = device.memory.memory_map_read
-        [(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x10,
-        device::memory::AccessSize::Icache,
-    );
-    device.memory.icache[line_index].words[5] = device.memory.memory_map_read
-        [(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x14,
-        device::memory::AccessSize::Icache,
-    );
-    device.memory.icache[line_index].words[6] = device.memory.memory_map_read
-        [(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x18,
-        device::memory::AccessSize::Icache,
-    );
-    device.memory.icache[line_index].words[7] = device.memory.memory_map_read
-        [(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x1C,
-        device::memory::AccessSize::Icache,
-    );
+    for i in 0..8 {
+        device.memory.icache[line_index].words[i as usize] = device.memory.memory_map_read
+            [(cache_address >> 16) as usize](
+            device,
+            cache_address | (i * 4),
+            device::memory::AccessSize::Icache,
+        );
 
-    device.memory.icache[line_index].instruction[0] =
-        device::cpu::decode_opcode(device, device.memory.icache[line_index].words[0]);
-    device.memory.icache[line_index].instruction[1] =
-        device::cpu::decode_opcode(device, device.memory.icache[line_index].words[1]);
-    device.memory.icache[line_index].instruction[2] =
-        device::cpu::decode_opcode(device, device.memory.icache[line_index].words[2]);
-    device.memory.icache[line_index].instruction[3] =
-        device::cpu::decode_opcode(device, device.memory.icache[line_index].words[3]);
-    device.memory.icache[line_index].instruction[4] =
-        device::cpu::decode_opcode(device, device.memory.icache[line_index].words[4]);
-    device.memory.icache[line_index].instruction[5] =
-        device::cpu::decode_opcode(device, device.memory.icache[line_index].words[5]);
-    device.memory.icache[line_index].instruction[6] =
-        device::cpu::decode_opcode(device, device.memory.icache[line_index].words[6]);
-    device.memory.icache[line_index].instruction[7] =
-        device::cpu::decode_opcode(device, device.memory.icache[line_index].words[7]);
+        device.memory.icache[line_index].instruction[i as usize] =
+            device::cpu::decode_opcode(device, device.memory.icache[line_index].words[i as usize]);
+    }
 }
 
 pub fn icache_fetch(device: &mut device::Device, phys_address: u64) {
@@ -180,30 +86,15 @@ pub fn dcache_writeback(device: &mut device::Device, line_index: usize) {
     let cache_address = ((device.memory.dcache[line_index].tag
         | (device.memory.dcache[line_index].index) as u32)
         & 0x1ffffffc) as u64;
-    device.memory.memory_map_write[(cache_address >> 16) as usize](
-        device,
-        cache_address,
-        device.memory.dcache[line_index].words[0],
-        0xFFFFFFFF,
-    );
-    device.memory.memory_map_write[(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x4,
-        device.memory.dcache[line_index].words[1],
-        0xFFFFFFFF,
-    );
-    device.memory.memory_map_write[(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x8,
-        device.memory.dcache[line_index].words[2],
-        0xFFFFFFFF,
-    );
-    device.memory.memory_map_write[(cache_address >> 16) as usize](
-        device,
-        cache_address | 0xC,
-        device.memory.dcache[line_index].words[3],
-        0xFFFFFFFF,
-    );
+
+    for i in 0..4 {
+        device.memory.memory_map_write[(cache_address >> 16) as usize](
+            device,
+            cache_address | (i * 4),
+            device.memory.dcache[line_index].words[i as usize],
+            0xFFFFFFFF,
+        );
+    }
 }
 
 fn dcache_fill(device: &mut device::Device, line_index: usize, phys_address: u64) {
@@ -216,30 +107,15 @@ fn dcache_fill(device: &mut device::Device, line_index: usize, phys_address: u64
     let cache_address = ((device.memory.dcache[line_index].tag
         | (device.memory.dcache[line_index].index) as u32)
         & 0x1ffffffc) as u64;
-    device.memory.dcache[line_index].words[0] = device.memory.memory_map_read
-        [(cache_address >> 16) as usize](
-        device,
-        cache_address,
-        device::memory::AccessSize::Dcache,
-    );
-    device.memory.dcache[line_index].words[1] = device.memory.memory_map_read
-        [(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x4,
-        device::memory::AccessSize::Dcache,
-    );
-    device.memory.dcache[line_index].words[2] = device.memory.memory_map_read
-        [(cache_address >> 16) as usize](
-        device,
-        cache_address | 0x8,
-        device::memory::AccessSize::Dcache,
-    );
-    device.memory.dcache[line_index].words[3] = device.memory.memory_map_read
-        [(cache_address >> 16) as usize](
-        device,
-        cache_address | 0xC,
-        device::memory::AccessSize::Dcache,
-    );
+
+    for i in 0..4 {
+        device.memory.dcache[line_index].words[i as usize] = device.memory.memory_map_read
+            [(cache_address >> 16) as usize](
+            device,
+            cache_address | (i * 4),
+            device::memory::AccessSize::Dcache,
+        );
+    }
 }
 
 pub fn dcache_read(device: &mut device::Device, phys_address: u64) -> u32 {

src/device/cart.rs

@@ -21,16 +21,6 @@ const JDT_EEPROM_16K: u16 = 0xc000; /* 16k EEPROM */
 const EEPROM_BLOCK_SIZE: usize = 8;
 pub const EEPROM_MAX_SIZE: usize = 0x800;
 
-#[derive(serde::Serialize, serde::Deserialize)]
-pub enum CicType {
-    CicNus6101,
-    CicNus6102,
-    CicNus6103,
-    CicNus6105,
-    CicNus6106,
-    CicNus5167,
-}
-
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct AfRtc {
     pub control: u16,
@@ -63,12 +53,14 @@ pub fn process(device: &mut device::Device, channel: usize) {
             let eeprom_type;
             if device
                 .ui
+                .storage
                 .save_type
                 .contains(&ui::storage::SaveTypes::Eeprom16k)
             {
                 eeprom_type = JDT_EEPROM_16K;
             } else if device
                 .ui
+                .storage
                 .save_type
                 .contains(&ui::storage::SaveTypes::Eeprom4k)
             {
@@ -124,8 +116,14 @@ pub fn process(device: &mut device::Device, channel: usize) {
 }
 
 pub fn format_eeprom(device: &mut device::Device) {
-    if device.ui.saves.eeprom.data.len() < EEPROM_MAX_SIZE {
-        device.ui.saves.eeprom.data.resize(EEPROM_MAX_SIZE, 0xFF)
+    if device.ui.storage.saves.eeprom.data.len() < EEPROM_MAX_SIZE {
+        device
+            .ui
+            .storage
+            .saves
+            .eeprom
+            .data
+            .resize(EEPROM_MAX_SIZE, 0xFF)
     }
 }
 
@@ -134,8 +132,9 @@ fn eeprom_read_block(device: &mut device::Device, block: usize, offset: usize) {
 
     format_eeprom(device);
 
-    device.pif.ram[offset..offset + EEPROM_BLOCK_SIZE]
-        .copy_from_slice(&device.ui.saves.eeprom.data[address..address + EEPROM_BLOCK_SIZE]);
+    device.pif.ram[offset..offset + EEPROM_BLOCK_SIZE].copy_from_slice(
+        &device.ui.storage.saves.eeprom.data[address..address + EEPROM_BLOCK_SIZE],
+    );
 }
 
 fn eeprom_write_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
@@ -143,12 +142,12 @@ fn eeprom_write_block(device: &mut device::Device, block: usize, offset: usize,
 
     format_eeprom(device);
 
-    device.ui.saves.eeprom.data[address..address + EEPROM_BLOCK_SIZE]
+    device.ui.storage.saves.eeprom.data[address..address + EEPROM_BLOCK_SIZE]
         .copy_from_slice(&device.pif.ram[offset..offset + EEPROM_BLOCK_SIZE]);
 
     device.pif.ram[status] = 0x00;
 
-    device.ui.saves.eeprom.written = true
+    ui::storage::schedule_save(device, ui::storage::SaveTypes::Eeprom4k);
 }
 
 fn time2data(device: &mut device::Device, offset: usize) {

src/device/cart/rom.rs

@@ -1,13 +1,21 @@
 use crate::device;
 use crate::netplay;
+use crate::ui;
 use sha2::{Digest, Sha256};
 
-const CART_MASK: usize = 0xFFFFFFF;
+pub const CART_MASK: usize = 0xFFFFFFF;
 
-fn read_cart_word(device: &mut device::Device, address: usize) -> u32 {
+fn read_cart_word(device: &device::Device, address: usize) -> u32 {
     let mut data: [u8; 4] = [0; 4];
     for i in 0..4 {
-        if let Some(value) = device.ui.saves.romsave.data.get(&(address as u32 + i)) {
+        if let Some(value) = device
+            .ui
+            .storage
+            .saves
+            .romsave
+            .data
+            .get(&(address as u32 + i))
+        {
             data[i as usize] = *value;
         } else {
             data[i as usize] = *device.cart.rom.get(address + i as usize).unwrap_or(&0);
@@ -17,7 +25,7 @@ fn read_cart_word(device: &mut device::Device, address: usize) -> u32 {
 }
 
 pub fn read_mem_fast(
-    device: &mut device::Device,
+    device: &device::Device,
     address: u64,
     _access_size: device::memory::AccessSize,
 ) -> u32 {
@@ -43,21 +51,20 @@ pub fn read_mem(
 }
 
 pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u32) {
-    if device.cart.sc64.cfg[device::cart::sc64::SC64_ROM_WRITE_ENABLE as usize] != 0
-        && device.cart.sc64.cfg[device::cart::sc64::SC64_BOOTLOADER_SWITCH as usize] == 0
-    {
+    if device.cart.sc64.cfg[device::cart::sc64::SC64_ROM_WRITE_ENABLE as usize] != 0 {
         let masked_address = address as usize & CART_MASK;
         let mut data = read_cart_word(device, masked_address);
         device::memory::masked_write_32(&mut data, value, mask);
         for (i, item) in data.to_be_bytes().iter().enumerate() {
             device
                 .ui
+                .storage
                 .saves
                 .romsave
                 .data
                 .insert((masked_address + i) as u32, *item);
         }
-        device.ui.saves.romsave.written = true;
+        ui::storage::schedule_save(device, ui::storage::SaveTypes::Romsave);
     }
 
     device.cart.latch = value & mask;
@@ -74,19 +81,21 @@ pub fn dma_read(
     mut dram_addr: u32,
     length: u32,
 ) -> u64 {
-    if device.cart.sc64.cfg[device::cart::sc64::SC64_ROM_WRITE_ENABLE as usize] != 0
-        && device.cart.sc64.cfg[device::cart::sc64::SC64_BOOTLOADER_SWITCH as usize] == 0
-    {
+    if device.cart.sc64.cfg[device::cart::sc64::SC64_ROM_WRITE_ENABLE as usize] != 0 {
         dram_addr &= device::rdram::RDRAM_MASK as u32;
         cart_addr &= CART_MASK as u32;
 
         for i in 0..length {
-            device.ui.saves.romsave.data.insert(
+            device.ui.storage.saves.romsave.data.insert(
                 cart_addr + i,
-                device.rdram.mem[(dram_addr + i) as usize ^ device.byte_swap],
+                *device
+                    .rdram
+                    .mem
+                    .get((dram_addr + i) as usize ^ device.byte_swap)
+                    .unwrap_or(&0),
             );
         }
-        device.ui.saves.romsave.written = true;
+        ui::storage::schedule_save(device, ui::storage::SaveTypes::Romsave);
     }
 
     device::pi::calculate_cycles(device, 1, length)
@@ -104,11 +113,18 @@ pub fn dma_write(
     let mut i = dram_addr;
     let mut j = cart_addr;
     while i < dram_addr + length {
-        if device.ui.saves.romsave.data.contains_key(&j) {
-            device.rdram.mem[i as usize ^ device.byte_swap] = device.ui.saves.romsave.data[&j];
+        if let Some(value) = device.ui.storage.saves.romsave.data.get(&j) {
+            *device
+                .rdram
+                .mem
+                .get_mut(i as usize ^ device.byte_swap)
+                .unwrap_or(&mut 0) = *value;
         } else {
-            device.rdram.mem[i as usize ^ device.byte_swap] =
-                *device.cart.rom.get(j as usize).unwrap_or(&0);
+            *device
+                .rdram
+                .mem
+                .get_mut(i as usize ^ device.byte_swap)
+                .unwrap_or(&mut 0) = *device.cart.rom.get(j as usize).unwrap_or(&0);
         }
         i += 1;
         j += 1;
@@ -120,8 +136,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 {
@@ -174,11 +189,10 @@ fn set_cic(device: &mut device::Device) {
         "53C0088FB777870D0AF32F0251E964030E2E8B72E830C26042FD191169508C05" => {
             device.cart.cic_seed = 0xdd; // CicNus5167
             device.cart.sc64.cfg[device::cart::sc64::SC64_ROM_WRITE_ENABLE as usize] = 1;
-            device.cart.sc64.cfg[device::cart::sc64::SC64_BOOTLOADER_SWITCH as usize] = 0;
         }
         _ => {
             device.cart.cic_seed = 0x3F; // CicNus6102
-            println!("unknown IPL3 {}", hash)
+            //println!("unknown IPL3 {}", hash)
         }
     }
 }

src/device/cart/sc64.rs

@@ -28,12 +28,13 @@ pub struct Sc64 {
     pub cfg: [u32; SC64_CFG_COUNT as usize],
     pub sector: u32,
     pub writeback_sector: Vec<u32>,
+    pub usb_buffer: Vec<u8>,
 }
 
 fn format_sdcard(device: &mut device::Device) {
-    if device.ui.saves.sdcard.data.is_empty() {
-        device.ui.saves.sdcard.data.resize(SDCARD_SIZE, 0);
-        let buf = std::io::Cursor::new(&mut device.ui.saves.sdcard.data);
+    if device.ui.storage.saves.sdcard.data.is_empty() {
+        device.ui.storage.saves.sdcard.data.resize(SDCARD_SIZE, 0);
+        let buf = std::io::Cursor::new(&mut device.ui.storage.saves.sdcard.data);
         fatfs::format_volume(buf, fatfs::FormatVolumeOptions::new()).unwrap();
     }
 }
@@ -51,7 +52,7 @@ pub fn read_regs(
     match reg as u32 {
         SC64_SCR_REG | SC64_DATA0_REG | SC64_DATA1_REG => device.cart.sc64.regs[reg as usize],
         SC64_IDENTIFIER_REG => 0x53437632,
-        _ => panic!("unknown read reg {} address {:#x}", reg, address),
+        _ => panic!("unknown read reg {reg} address {address:#x}"),
     }
 }
 
@@ -93,8 +94,8 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
                         if device.cart.sc64.regs[SC64_DATA0_REG as usize] == SC64_SAVE_TYPE {
                             // if save type is being written, we are probably booting a game using the flash cart menu
                             // we shouldn't write saves to disk in this case (they are written to the SD card)
-                            device.ui.saves.write_to_disk = false;
-                            device.ui.save_type =
+                            device.ui.storage.saves.write_to_disk = false;
+                            device.ui.storage.save_type =
                                 match device.cart.sc64.regs[SC64_DATA1_REG as usize] {
                                     0 => {
                                         vec![]
@@ -155,23 +156,26 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
                         let mut i = 0;
 
                         while i < length {
-                            if offset + i < device.ui.saves.sdcard.data.len() {
-                                let data = u32::from_be_bytes(
-                                    device.ui.saves.sdcard.data[(offset + i)..(offset + i + 4)]
-                                        .try_into()
-                                        .unwrap(),
-                                );
+                            let data = u32::from_be_bytes(
+                                device
+                                    .ui
+                                    .storage
+                                    .saves
+                                    .sdcard
+                                    .data
+                                    .get((offset + i)..(offset + i + 4))
+                                    .unwrap_or(&[0; 4])
+                                    .try_into()
+                                    .unwrap_or_default(),
+                            );
 
-                                device::memory::data_write(
-                                    device,
-                                    address + i as u64,
-                                    data,
-                                    0xFFFFFFFF,
-                                    false,
-                                );
-                            } else {
-                                panic!("sd card read out of bounds")
-                            }
+                            device::memory::data_write(
+                                device,
+                                address + i as u64,
+                                data,
+                                0xFFFFFFFF,
+                                false,
+                            );
                             i += 4;
                         }
                     }
@@ -186,25 +190,152 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
                         let mut i = 0;
 
                         while i < length {
-                            if offset + i < device.ui.saves.sdcard.data.len() {
-                                let data = device::memory::data_read(
-                                    device,
-                                    address + i as u64,
-                                    device::memory::AccessSize::Word,
-                                    false,
-                                )
-                                .to_be_bytes();
-                                device.ui.saves.sdcard.data[(offset + i)..(offset + i + 4)]
-                                    .copy_from_slice(&data);
-                            } else {
-                                panic!("sd card write out of bounds")
-                            }
+                            let data = device::memory::data_read(
+                                device,
+                                address + i as u64,
+                                device::memory::AccessSize::Word,
+                                false,
+                            )
+                            .to_be_bytes();
+                            device
+                                .ui
+                                .storage
+                                .saves
+                                .sdcard
+                                .data
+                                .get_mut((offset + i)..(offset + i + 4))
+                                .unwrap_or(&mut [0; 4])
+                                .copy_from_slice(&data);
                             i += 4;
                         }
-                        device.ui.saves.sdcard.written = true;
+                        ui::storage::schedule_save(device, ui::storage::SaveTypes::Sdcard);
+                    }
+                    'U' => {
+                        device.cart.sc64.regs[SC64_DATA0_REG as usize] = 0;
+                    }
+                    'u' => {
+                        // used to notify the game that there is data to read
+                        if let Some(cart_rx) = device.ui.usb.cart_rx.as_mut() {
+                            match cart_rx.try_recv() {
+                                Ok(data) => {
+                                    device.cart.sc64.regs[SC64_DATA0_REG as usize] =
+                                        data.data_type & 0xFF; // read_status/type
+                                    device.cart.sc64.regs[SC64_DATA1_REG as usize] =
+                                        data.data_size & 0xFFFFFF; // length
+                                    device.cart.sc64.usb_buffer = data.data; // store the data to be read
+                                }
+                                Err(err) => {
+                                    match err {
+                                        tokio::sync::broadcast::error::TryRecvError::Lagged(_) => {
+                                            panic!("cart_rx lagged: {err}");
+                                        }
+                                        _ => {
+                                            device.cart.sc64.regs[SC64_DATA0_REG as usize] = 0; // read_status/type
+                                            device.cart.sc64.regs[SC64_DATA1_REG as usize] = 0; // length
+                                        }
+                                    }
+                                }
+                            }
+                        } else {
+                            device.cart.sc64.regs[SC64_DATA0_REG as usize] = 0; // read_status/type
+                            device.cart.sc64.regs[SC64_DATA1_REG as usize] = 0; // length
+                        }
+                    }
+                    'M' => {
+                        // Send data from from flashcart to USB
+                        let address =
+                            device.cart.sc64.regs[SC64_DATA0_REG as usize] as u64 & 0x1FFFFFFF;
+                        let length =
+                            device.cart.sc64.regs[SC64_DATA1_REG as usize] as usize & 0xFFFFFF;
+
+                        if let Some(usb_tx) = device.ui.usb.usb_tx.as_mut() {
+                            let mut usb_buffer = vec![0; length];
+
+                            let mut i = 0;
+
+                            if address < device.rdram.size as u64 {
+                                while i < length {
+                                    *usb_buffer.get_mut(i).unwrap_or(&mut 0) = *device
+                                        .rdram
+                                        .mem
+                                        .get((address as usize + i) ^ device.byte_swap)
+                                        .unwrap_or(&0);
+                                    i += 1;
+                                }
+                            } else if address >= device::memory::MM_CART_ROM as u64
+                                && address < device::memory::MM_PIF_MEM as u64
+                            {
+                                while i < length {
+                                    *usb_buffer.get_mut(i).unwrap_or(&mut 0) = *device
+                                        .ui
+                                        .storage
+                                        .saves
+                                        .romsave
+                                        .data
+                                        .get(
+                                            &(((address as usize + i)
+                                                & device::cart::rom::CART_MASK)
+                                                as u32),
+                                        )
+                                        .unwrap_or(
+                                            device
+                                                .cart
+                                                .rom
+                                                .get(
+                                                    (address as usize + i)
+                                                        & device::cart::rom::CART_MASK,
+                                                )
+                                                .unwrap_or(&0),
+                                        );
+                                    i += 1;
+                                }
+                            } else {
+                                panic!("Unknown address {address:#x} for SC64 M command");
+                            }
+
+                            ui::usb::send_to_usb(
+                                usb_tx,
+                                ui::usb::UsbData {
+                                    data: usb_buffer,
+                                    data_type: device.cart.sc64.regs[SC64_DATA1_REG as usize] >> 24,
+                                    data_size: device.cart.sc64.regs[SC64_DATA1_REG as usize]
+                                        & 0xFFFFFF,
+                                },
+                            );
+                        }
+                    }
+                    'm' => {
+                        // Receive data from USB to flashcart
+                        let address =
+                            device.cart.sc64.regs[SC64_DATA0_REG as usize] as u64 & 0x1FFFFFFF;
+                        let length = device.cart.sc64.regs[SC64_DATA1_REG as usize] as usize;
+
+                        let mut i = 0;
+
+                        if address < device.rdram.size as u64 {
+                            while i < length {
+                                *device
+                                    .rdram
+                                    .mem
+                                    .get_mut((address as usize + i) ^ device.byte_swap)
+                                    .unwrap_or(&mut 0) =
+                                    *device.cart.sc64.usb_buffer.get(i).unwrap_or(&0);
+                                i += 1;
+                            }
+                        } else if address >= device::memory::MM_CART_ROM as u64
+                            && address < device::memory::MM_PIF_MEM as u64
+                        {
+                            while i < length {
+                                device.ui.storage.saves.romsave.data.insert(
+                                    ((address as usize + i) & device::cart::rom::CART_MASK) as u32,
+                                    *device.cart.sc64.usb_buffer.get(i).unwrap_or(&0),
+                                );
+                                i += 1;
+                            }
+                        } else {
+                            panic!("Unknown address {address:#x} for SC64 m command");
+                        }
                     }
-                    'U' | 'u' => {} // USB status, ignored
-                    'M' | 'm' => {} // USB read/write, ignored
                     'w' => {
                         // SD card writeback pending
                         device.cart.sc64.regs[SC64_DATA0_REG as usize] = 0;
@@ -248,7 +379,7 @@ pub fn read_mem(
         device::cart::format_eeprom(device);
         let masked_address = address as usize & SC64_EEPROM_MASK;
         u32::from_be_bytes(
-            device.ui.saves.eeprom.data[masked_address..masked_address + 4]
+            device.ui.storage.saves.eeprom.data[masked_address..masked_address + 4]
                 .try_into()
                 .unwrap(),
         )
@@ -267,14 +398,14 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
         device::cart::format_eeprom(device);
         let masked_address = address as usize & SC64_EEPROM_MASK;
         let mut data = u32::from_be_bytes(
-            device.ui.saves.eeprom.data[masked_address..masked_address + 4]
+            device.ui.storage.saves.eeprom.data[masked_address..masked_address + 4]
                 .try_into()
                 .unwrap(),
         );
         device::memory::masked_write_32(&mut data, value, mask);
-        device.ui.saves.eeprom.data[masked_address..masked_address + 4]
+        device.ui.storage.saves.eeprom.data[masked_address..masked_address + 4]
             .copy_from_slice(&data.to_be_bytes());
-        device.ui.saves.eeprom.written = true
+        ui::storage::schedule_save(device, ui::storage::SaveTypes::Eeprom4k);
     } else {
         let masked_address = address as usize & SC64_BUFFER_MASK;
         let mut data = u32::from_be_bytes(
@@ -298,8 +429,8 @@ pub fn dma_read(
     let buffer = if cart_addr & 0x2000 != 0 {
         device::cart::format_eeprom(device);
         cart_addr &= SC64_EEPROM_MASK as u32;
-        device.ui.saves.eeprom.written = true;
-        &mut device.ui.saves.eeprom.data
+        ui::storage::schedule_save(device, ui::storage::SaveTypes::Eeprom4k);
+        &mut device.ui.storage.saves.eeprom.data
     } else {
         cart_addr &= SC64_BUFFER_MASK as u32;
         &mut device.cart.sc64.buffer
@@ -307,8 +438,12 @@ pub fn dma_read(
     let mut i = dram_addr;
     let mut j = cart_addr;
 
-    while i < dram_addr + length && i < device.rdram.size {
-        buffer[j as usize] = device.rdram.mem[i as usize ^ device.byte_swap];
+    while i < dram_addr + length {
+        *buffer.get_mut(j as usize).unwrap_or(&mut 0) = *device
+            .rdram
+            .mem
+            .get(i as usize ^ device.byte_swap)
+            .unwrap_or(&0);
         i += 1;
         j += 1;
     }
@@ -326,7 +461,7 @@ pub fn dma_write(
     let buffer = if cart_addr & 0x2000 != 0 {
         device::cart::format_eeprom(device);
         cart_addr &= SC64_EEPROM_MASK as u32;
-        &device.ui.saves.eeprom.data
+        &device.ui.storage.saves.eeprom.data
     } else {
         cart_addr &= SC64_BUFFER_MASK as u32;
         &device.cart.sc64.buffer
@@ -334,8 +469,12 @@ pub fn dma_write(
     let mut i = dram_addr;
     let mut j = cart_addr;
 
-    while i < dram_addr + length && i < device.rdram.size {
-        device.rdram.mem[i as usize ^ device.byte_swap] = buffer[j as usize];
+    while i < dram_addr + length {
+        *device
+            .rdram
+            .mem
+            .get_mut(i as usize ^ device.byte_swap)
+            .unwrap_or(&mut 0) = *buffer.get(j as usize).unwrap_or(&0);
         i += 1;
         j += 1;
     }

src/device/cart/sram.rs

@@ -29,14 +29,20 @@ pub struct Flashram {
 }
 
 fn format_sram(device: &mut device::Device) {
-    if device.ui.saves.sram.data.len() < SRAM_SIZE {
-        device.ui.saves.sram.data.resize(SRAM_SIZE, 0xFF)
+    if device.ui.storage.saves.sram.data.len() < SRAM_SIZE {
+        device.ui.storage.saves.sram.data.resize(SRAM_SIZE, 0xFF)
     }
 }
 
 fn format_flash(device: &mut device::Device) {
-    if device.ui.saves.flash.data.len() < FLASHRAM_SIZE {
-        device.ui.saves.flash.data.resize(FLASHRAM_SIZE, 0xFF)
+    if device.ui.storage.saves.flash.data.len() < FLASHRAM_SIZE {
+        device
+            .ui
+            .storage
+            .saves
+            .flash
+            .data
+            .resize(FLASHRAM_SIZE, 0xFF)
     }
 }
 
@@ -46,7 +52,7 @@ fn read_mem_sram(device: &mut device::Device, address: u64) -> u32 {
     format_sram(device);
 
     u32::from_be_bytes(
-        device.ui.saves.sram.data[masked_address..masked_address + 4]
+        device.ui.storage.saves.sram.data[masked_address..masked_address + 4]
             .try_into()
             .unwrap(),
     )
@@ -60,7 +66,7 @@ fn read_mem_flash(device: &device::Device, address: u64) -> u32 {
     {
         /* flashram MMIO read are not supported except for the "dummy" read @0x0000 done before DMA.
          * returns a "dummy" value. */
-        return 0;
+        0
     } else {
         /* other accesses are not implemented */
         panic!("unknown flashram read")
@@ -75,7 +81,12 @@ pub fn read_mem(
     let cycles = device::pi::calculate_cycles(device, 2, 4);
     device::cop0::add_cycles(device, cycles);
 
-    if device.ui.save_type.contains(&ui::storage::SaveTypes::Sram) {
+    if device
+        .ui
+        .storage
+        .save_type
+        .contains(&ui::storage::SaveTypes::Sram)
+    {
         read_mem_sram(device, address)
     } else {
         read_mem_flash(device, address)
@@ -88,15 +99,15 @@ fn write_mem_sram(device: &mut device::Device, address: u64, value: u32, mask: u
     format_sram(device);
 
     let mut data = u32::from_be_bytes(
-        device.ui.saves.sram.data[masked_address..masked_address + 4]
+        device.ui.storage.saves.sram.data[masked_address..masked_address + 4]
             .try_into()
             .unwrap(),
     );
     device::memory::masked_write_32(&mut data, value, mask);
-    device.ui.saves.sram.data[masked_address..masked_address + 4]
+    device.ui.storage.saves.sram.data[masked_address..masked_address + 4]
         .copy_from_slice(&data.to_be_bytes());
 
-    device.ui.saves.sram.written = true
+    ui::storage::schedule_save(device, ui::storage::SaveTypes::Sram);
 }
 
 fn write_mem_flash(device: &mut device::Device, address: u64, value: u32, mask: u32) {
@@ -114,7 +125,12 @@ fn write_mem_flash(device: &mut device::Device, address: u64, value: u32, mask:
 }
 
 pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u32) {
-    if device.ui.save_type.contains(&ui::storage::SaveTypes::Sram) {
+    if device
+        .ui
+        .storage
+        .save_type
+        .contains(&ui::storage::SaveTypes::Sram)
+    {
         write_mem_sram(device, address, value, mask)
     } else {
         write_mem_flash(device, address, value, mask)
@@ -134,13 +150,24 @@ fn dma_read_sram(device: &mut device::Device, mut cart_addr: u32, mut dram_addr:
 
     format_sram(device);
 
-    while i < dram_addr + length && i < device.rdram.size {
-        device.ui.saves.sram.data[j as usize] = device.rdram.mem[i as usize ^ device.byte_swap];
+    while i < dram_addr + length {
+        *device
+            .ui
+            .storage
+            .saves
+            .sram
+            .data
+            .get_mut(j as usize)
+            .unwrap_or(&mut 0) = *device
+            .rdram
+            .mem
+            .get(i as usize ^ device.byte_swap)
+            .unwrap_or(&0);
         i += 1;
         j += 1;
     }
 
-    device.ui.saves.sram.written = true
+    ui::storage::schedule_save(device, ui::storage::SaveTypes::Sram);
 }
 
 fn dma_read_flash(device: &mut device::Device, cart_addr: u32, dram_addr: u32, length: u32) {
@@ -152,8 +179,11 @@ fn dma_read_flash(device: &mut device::Device, cart_addr: u32, dram_addr: u32, l
     {
         /* load page buf using DMA */
         for i in 0..length {
-            device.cart.flashram.page_buf[i as usize] =
-                device.rdram.mem[(dram_addr + i) as usize ^ device.byte_swap];
+            device.cart.flashram.page_buf[i as usize] = *device
+                .rdram
+                .mem
+                .get((dram_addr + i) as usize ^ device.byte_swap)
+                .unwrap_or(&0);
         }
     } else {
         /* other accesses are not implemented */
@@ -163,7 +193,12 @@ fn dma_read_flash(device: &mut device::Device, cart_addr: u32, dram_addr: u32, l
 
 // cart is big endian, rdram is native endian
 pub fn dma_read(device: &mut device::Device, cart_addr: u32, dram_addr: u32, length: u32) -> u64 {
-    if device.ui.save_type.contains(&ui::storage::SaveTypes::Sram) {
+    if device
+        .ui
+        .storage
+        .save_type
+        .contains(&ui::storage::SaveTypes::Sram)
+    {
         dma_read_sram(device, cart_addr, dram_addr, length)
     } else {
         dma_read_flash(device, cart_addr, dram_addr, length)
@@ -184,8 +219,19 @@ fn dma_write_sram(
 
     format_sram(device);
 
-    while i < dram_addr + length && i < device.rdram.size {
-        device.rdram.mem[i as usize ^ device.byte_swap] = device.ui.saves.sram.data[j as usize];
+    while i < dram_addr + length {
+        *device
+            .rdram
+            .mem
+            .get_mut(i as usize ^ device.byte_swap)
+            .unwrap_or(&mut 0) = *device
+            .ui
+            .storage
+            .saves
+            .sram
+            .data
+            .get(j as usize)
+            .unwrap_or(&0);
         i += 1;
         j += 1;
     }
@@ -204,10 +250,18 @@ fn dma_write_flash(
         && device.cart.flashram.mode == FlashramMode::ReadSiliconId
     {
         /* read Silicon ID using DMA */
-        device.rdram.mem[dram_addr as usize..dram_addr as usize + 4]
+        device
+            .rdram
+            .mem
+            .get_mut(dram_addr as usize..dram_addr as usize + 4)
+            .unwrap_or(&mut [0; 4])
             .copy_from_slice(&device.cart.flashram.silicon_id[0].to_ne_bytes());
         dram_addr += 4;
-        device.rdram.mem[dram_addr as usize..dram_addr as usize + 4]
+        device
+            .rdram
+            .mem
+            .get_mut(dram_addr as usize..dram_addr as usize + 4)
+            .unwrap_or(&mut [0; 4])
             .copy_from_slice(&device.cart.flashram.silicon_id[1].to_ne_bytes());
     } else if (cart_addr & 0x1ffff) < 0x10000
         && device.cart.flashram.mode == FlashramMode::ReadArray
@@ -227,8 +281,11 @@ fn dma_write_flash(
 
         /* do actual DMA */
         for i in 0..length {
-            device.rdram.mem[(dram_addr + i) as usize ^ device.byte_swap] =
-                device.ui.saves.flash.data[(cart_addr + i) as usize];
+            *device
+                .rdram
+                .mem
+                .get_mut((dram_addr + i) as usize ^ device.byte_swap)
+                .unwrap_or(&mut 0) = device.ui.storage.saves.flash.data[(cart_addr + i) as usize];
         }
     } else {
         /* other accesses are not implemented */
@@ -238,7 +295,12 @@ fn dma_write_flash(
 
 // cart is big endian, rdram is native endian
 pub fn dma_write(device: &mut device::Device, cart_addr: u32, dram_addr: u32, length: u32) -> u64 {
-    if device.ui.save_type.contains(&ui::storage::SaveTypes::Sram) {
+    if device
+        .ui
+        .storage
+        .save_type
+        .contains(&ui::storage::SaveTypes::Sram)
+    {
         dma_write_sram(device, cart_addr, dram_addr, length)
     } else {
         dma_write_flash(device, cart_addr, dram_addr, length)
@@ -267,14 +329,14 @@ fn flashram_command(device: &mut device::Device, command: u32) {
             if device.cart.flashram.mode == FlashramMode::SectorErase {
                 let offset: usize = (device.cart.flashram.erase_page & 0xff80) as usize * 128;
                 for i in 0..128 * 128 {
-                    device.ui.saves.flash.data[offset + i] = 0xFF;
+                    device.ui.storage.saves.flash.data[offset + i] = 0xFF;
                 }
-                device.ui.saves.flash.written = true
+                ui::storage::schedule_save(device, ui::storage::SaveTypes::Flash);
             } else if device.cart.flashram.mode == FlashramMode::ChipErase {
                 for i in 0..FLASHRAM_SIZE {
-                    device.ui.saves.flash.data[i] = 0xFF;
+                    device.ui.storage.saves.flash.data[i] = 0xFF;
                 }
-                device.ui.saves.flash.written = true
+                ui::storage::schedule_save(device, ui::storage::SaveTypes::Flash);
             } else {
                 panic!("Unexpected flash erase command")
             }
@@ -292,9 +354,9 @@ fn flashram_command(device: &mut device::Device, command: u32) {
             /* program selected page */
             let offset: usize = (command & 0xffff) as usize * 128;
             for i in 0..128 {
-                device.ui.saves.flash.data[offset + i] = device.cart.flashram.page_buf[i];
+                device.ui.storage.saves.flash.data[offset + i] = device.cart.flashram.page_buf[i];
             }
-            device.ui.saves.flash.written = true;
+            ui::storage::schedule_save(device, ui::storage::SaveTypes::Flash);
 
             /* clear program busy flag, set program success flag, transition to status mode */
             device.cart.flashram.status &= !0x01;

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(&mut device.ui, channel)
-            } else {
-                if device.netplay.as_ref().unwrap().player_number as usize == channel {
-                    let local_input = ui::input::get(&mut device.ui, 0);
-                    netplay::send_input(device.netplay.as_ref().unwrap(), local_input);
+            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(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());
@@ -96,7 +95,7 @@ pub fn process(device: &mut device::Device, channel: usize) {
             device.pif.channels[channel].rx_buf.unwrap(),
             channel,
         ),
-        _ => println!("unknown controller command {}", cmd),
+        _ => println!("unknown controller command {cmd}"),
     }
 }
 
@@ -111,8 +110,8 @@ fn pak_read_block(
         ((device.pif.ram[addr_acrc] as u16) << 8) | (device.pif.ram[addr_acrc + 1] & 0xe0) as u16;
     let handler = device.pif.channels[channel].pak_handler;
 
-    if handler.is_some() {
-        (handler.unwrap().read)(device, channel, address, data, PAK_CHUNK_SIZE);
+    if let Some(handler) = handler {
+        (handler.read)(device, channel, address, data, PAK_CHUNK_SIZE);
         device.pif.ram[dcrc] = data_crc(device, data, PAK_CHUNK_SIZE)
     } else {
         device.pif.ram[dcrc] = !data_crc(device, data, PAK_CHUNK_SIZE)
@@ -130,8 +129,8 @@ fn pak_write_block(
         ((device.pif.ram[addr_acrc] as u16) << 8) | (device.pif.ram[addr_acrc + 1] & 0xe0) as u16;
     let handler = device.pif.channels[channel].pak_handler;
 
-    if handler.is_some() {
-        (handler.unwrap().write)(device, channel, address, data, PAK_CHUNK_SIZE);
+    if let Some(handler) = handler {
+        (handler.write)(device, channel, address, data, PAK_CHUNK_SIZE);
         device.pif.ram[dcrc] = data_crc(device, data, PAK_CHUNK_SIZE)
     } else {
         device.pif.ram[dcrc] = !data_crc(device, data, PAK_CHUNK_SIZE)
@@ -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() {
-                device::ui::input::set_rumble(&mut device.ui, i, 0);
-            } else if device.netplay.as_ref().unwrap().player_number as usize == i {
-                device::ui::input::set_rumble(&mut device.ui, 0, 0);
+            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);
             }
 
             let new_pak_type = match channel.change_pak {
@@ -189,20 +190,22 @@ pub fn pak_switch_event(device: &mut device::Device) {
                     write: device::controller::mempak::write,
                     pak_type: new_pak_type,
                 });
+                ui::video::onscreen_message(&device.ui, "MemPak selected");
             } else if new_pak_type == PakType::RumblePak {
                 channel.pak_handler = Some(device::controller::PakHandler {
                     read: device::controller::rumble::read,
                     write: device::controller::rumble::write,
                     pak_type: new_pak_type,
                 });
+                ui::video::onscreen_message(&device.ui, "RumblePak selected");
             } else if new_pak_type == PakType::TransferPak {
                 channel.pak_handler = Some(device::controller::PakHandler {
                     read: device::controller::transferpak::read,
                     write: device::controller::transferpak::write,
                     pak_type: new_pak_type,
                 });
+                ui::video::onscreen_message(&device.ui, "TransferPak selected");
             }
-            ui::audio::play_pak_switch(&mut device.ui, new_pak_type);
             channel.change_pak = PakType::None;
         }
     }

src/device/controller/gbcart.rs

@@ -8,6 +8,7 @@ pub struct GbCart {
     pub ram: Vec<u8>,
     pub cart_type: device::controller::gbcart::CartType,
     pub ram_enabled: bool,
+    pub mbc1_mode: bool,
     pub ram_bank: u16,
     pub rom_bank: u32,
     pub set_latch: bool,
@@ -21,13 +22,85 @@ pub struct GbCart {
 pub enum CartType {
     #[default]
     None,
+    MBC1RamBatt,
     MBC3RamBatt,
     MBC3RamBattRtc,
     MBC5RamBatt,
 }
 
-fn write_mbc3(
+fn write_mbc1(
+    pif_ram: &[u8],
+    cart: &mut device::controller::gbcart::GbCart,
+    address: u16,
+    data: usize,
+    size: usize,
+) {
+    let value = pif_ram[data + size - 1];
+    if address < 0x2000 {
+        cart.ram_enabled = value & 0xf == 0xa;
+    } else if address < 0x4000 {
+        let bank = value & 0x1f;
+        cart.rom_bank = bank as u32;
+        if cart.rom_bank == 0 {
+            cart.rom_bank = 1;
+        }
+    } else if address < 0x6000 {
+        cart.ram_bank = (value & 0x3) as u16;
+    } else if address < 0x8000 {
+        cart.mbc1_mode = (value & 0x1) != 0;
+    } else if (0xa000..0xc000).contains(&address) {
+        if !cart.ram_enabled {
+            return;
+        }
+        if cart.mbc1_mode {
+            let banked_address = address - 0xA000 + (cart.ram_bank * 0x2000);
+            cart.ram[banked_address as usize..banked_address as usize + size]
+                .copy_from_slice(&pif_ram[data..data + size]);
+        } else {
+            let banked_address = address - 0xA000;
+            cart.ram[banked_address as usize..banked_address as usize + size]
+                .copy_from_slice(&pif_ram[data..data + size]);
+        }
+    }
+}
+
+fn read_mbc1(
     pif_ram: &mut [u8],
+    cart: &device::controller::gbcart::GbCart,
+    address: u16,
+    data: usize,
+    size: usize,
+) {
+    if address < 0x4000 {
+        let banked_address = address & 0x3FFF;
+        pif_ram[data..data + size]
+            .copy_from_slice(&cart.rom[banked_address as usize..banked_address as usize + size]);
+    } else if address < 0x8000 {
+        let banked_address = address as u32 - 0x4000 + (cart.rom_bank * 0x4000);
+        pif_ram[data..data + size]
+            .copy_from_slice(&cart.rom[banked_address as usize..banked_address as usize + size]);
+    } else if (0xa000..0xc000).contains(&address) {
+        if !cart.ram_enabled {
+            for i in 0..size {
+                pif_ram[data + i] = 0xff;
+            }
+            return;
+        }
+        if cart.ram_bank > 3 {
+            for i in 0..size {
+                pif_ram[data + i] = 0;
+            }
+        } else {
+            let banked_address = address - 0xA000 + (cart.ram_bank * 0x2000);
+            pif_ram[data..data + size].copy_from_slice(
+                &cart.ram[banked_address as usize..banked_address as usize + size],
+            );
+        }
+    }
+}
+
+fn write_mbc3(
+    pif_ram: &[u8],
     cart: &mut device::controller::gbcart::GbCart,
     address: u16,
     data: usize,
@@ -82,13 +155,13 @@ fn write_mbc3(
             }
         }
     } else {
-        panic!("Unsupported write address {:x}", address);
+        panic!("Unsupported write address {address:x}");
     }
 }
 
 fn read_mbc3(
     pif_ram: &mut [u8],
-    cart: &mut device::controller::gbcart::GbCart,
+    cart: &device::controller::gbcart::GbCart,
     address: u16,
     data: usize,
     size: usize,
@@ -135,12 +208,12 @@ fn read_mbc3(
             }
         }
     } else {
-        panic!("Unsupported read address {:x}", address);
+        panic!("Unsupported read address {address:x}");
     }
 }
 
 fn write_mbc5(
-    pif_ram: &mut [u8],
+    pif_ram: &[u8],
     cart: &mut device::controller::gbcart::GbCart,
     address: u16,
     data: usize,
@@ -158,7 +231,7 @@ fn write_mbc5(
     } else if address < 0x6000 {
         cart.ram_bank = (value & 0xf) as u16;
     } else if address < 0xa000 {
-        println!("Unknown MBC5 write address {:x}", address);
+        println!("Unknown MBC5 write address {address:x}");
     } else if (0xa000..0xc000).contains(&address) {
         if !cart.ram_enabled {
             return;
@@ -168,13 +241,13 @@ fn write_mbc5(
         cart.ram[banked_address as usize..banked_address as usize + size]
             .copy_from_slice(&pif_ram[data..data + size]);
     } else {
-        panic!("Unsupported write address {:x}", address);
+        panic!("Unsupported write address {address:x}");
     }
 }
 
 fn read_mbc5(
     pif_ram: &mut [u8],
-    cart: &mut device::controller::gbcart::GbCart,
+    cart: &device::controller::gbcart::GbCart,
     address: u16,
     data: usize,
     size: usize,
@@ -199,13 +272,13 @@ fn read_mbc5(
         pif_ram[data..data + size]
             .copy_from_slice(&cart.ram[banked_address as usize..banked_address as usize + size]);
     } else {
-        panic!("Unsupported read address {:x}", address);
+        panic!("Unsupported read address {address:x}");
     }
 }
 
 pub fn read(
     pif_ram: &mut [u8],
-    cart: &mut device::controller::gbcart::GbCart,
+    cart: &device::controller::gbcart::GbCart,
     address: u16,
     data: usize,
     size: usize,
@@ -217,6 +290,7 @@ pub fn read(
         return;
     }
     match cart.cart_type {
+        CartType::MBC1RamBatt => read_mbc1(pif_ram, cart, address, data, size),
         CartType::MBC3RamBatt => read_mbc3(pif_ram, cart, address, data, size),
         CartType::MBC3RamBattRtc => read_mbc3(pif_ram, cart, address, data, size),
         CartType::MBC5RamBatt => read_mbc5(pif_ram, cart, address, data, size),
@@ -225,7 +299,7 @@ pub fn read(
 }
 
 pub fn write(
-    pif_ram: &mut [u8],
+    pif_ram: &[u8],
     cart: &mut device::controller::gbcart::GbCart,
     address: u16,
     data: usize,
@@ -235,6 +309,7 @@ pub fn write(
         return;
     }
     match cart.cart_type {
+        CartType::MBC1RamBatt => write_mbc1(pif_ram, cart, address, data, size),
         CartType::MBC3RamBatt => write_mbc3(pif_ram, cart, address, data, size),
         CartType::MBC3RamBattRtc => write_mbc3(pif_ram, cart, address, data, size),
         CartType::MBC5RamBatt => write_mbc5(pif_ram, cart, address, data, size),
@@ -244,9 +319,10 @@ pub fn write(
 
 pub fn get_cart_type(data: u8) -> CartType {
     match data {
+        0x03 => CartType::MBC1RamBatt,
         0x10 => CartType::MBC3RamBattRtc,
         0x13 => CartType::MBC3RamBatt,
         0x1b => CartType::MBC5RamBatt,
-        _ => panic!("Unsupported cart type {:x}", data),
+        _ => panic!("Unsupported cart type {data:x}"),
     }
 }

src/device/controller/mempak.rs

@@ -1,11 +1,18 @@
 use crate::device;
+use crate::ui;
 
 pub const MEMPAK_SIZE: usize = 0x8000;
 const MPK_PAGE_SIZE: usize = 256;
 
 fn format_mempak(device: &mut device::Device) {
-    if device.ui.saves.mempak.data.len() < MEMPAK_SIZE * 4 {
-        device.ui.saves.mempak.data.resize(MEMPAK_SIZE * 4, 0);
+    if device.ui.storage.saves.mempak.data.len() < MEMPAK_SIZE * 4 {
+        device
+            .ui
+            .storage
+            .saves
+            .mempak
+            .data
+            .resize(MEMPAK_SIZE * 4, 0);
 
         let page_0: [u8; MPK_PAGE_SIZE] = [
             /* Label area */
@@ -38,28 +45,31 @@ fn format_mempak(device: &mut device::Device) {
             let offset = i * MEMPAK_SIZE;
 
             /* Fill Page 0 with pre-initialized content */
-            device.ui.saves.mempak.data[offset..offset + MPK_PAGE_SIZE].copy_from_slice(&page_0);
+            device.ui.storage.saves.mempak.data[offset..offset + MPK_PAGE_SIZE]
+                .copy_from_slice(&page_0);
 
             /* Fill INODE page 1 and update it's checkum */
             let start_page = 5;
             for i in MPK_PAGE_SIZE..2 * start_page {
-                device.ui.saves.mempak.data[offset + i] = 0;
+                device.ui.storage.saves.mempak.data[offset + i] = 0;
             }
             for i in (MPK_PAGE_SIZE + 2 * start_page..2 * MPK_PAGE_SIZE).step_by(2) {
-                device.ui.saves.mempak.data[offset + i] = 0x00;
-                device.ui.saves.mempak.data[offset + i + 1] = 0x03;
+                device.ui.storage.saves.mempak.data[offset + i] = 0x00;
+                device.ui.storage.saves.mempak.data[offset + i + 1] = 0x03;
             }
-            device.ui.saves.mempak.data[offset + (MPK_PAGE_SIZE + 1)] = 0x71;
+            device.ui.storage.saves.mempak.data[offset + (MPK_PAGE_SIZE + 1)] = 0x71;
 
             /* Page 2 is identical to page 1 */
             let page1 = offset + MPK_PAGE_SIZE;
             let page2 = offset + 2 * MPK_PAGE_SIZE;
-            let page1data = device.ui.saves.mempak.data[page1..page1 + MPK_PAGE_SIZE].to_vec();
-            device.ui.saves.mempak.data[page2..page2 + MPK_PAGE_SIZE].copy_from_slice(&page1data);
+            let page1data =
+                device.ui.storage.saves.mempak.data[page1..page1 + MPK_PAGE_SIZE].to_vec();
+            device.ui.storage.saves.mempak.data[page2..page2 + MPK_PAGE_SIZE]
+                .copy_from_slice(&page1data);
 
             /* Remaining pages DIR+DATA (3...) are initialized with 0x00 */
             for i in 3 * MPK_PAGE_SIZE..MEMPAK_SIZE - 3 * MPK_PAGE_SIZE {
-                device.ui.saves.mempak.data[offset + i] = 0;
+                device.ui.storage.saves.mempak.data[offset + i] = 0;
             }
         }
     }
@@ -71,7 +81,7 @@ pub fn read(device: &mut device::Device, channel: usize, address: u16, data: usi
 
         let offset = (channel * MEMPAK_SIZE) + address as usize;
         device.pif.ram[data..data + size]
-            .copy_from_slice(&device.ui.saves.mempak.data[offset..offset + size])
+            .copy_from_slice(&device.ui.storage.saves.mempak.data[offset..offset + size])
     } else {
         for i in 0..size {
             device.pif.ram[data + i] = 0;
@@ -84,9 +94,9 @@ pub fn write(device: &mut device::Device, channel: usize, address: u16, data: us
         format_mempak(device);
 
         let offset = (channel * MEMPAK_SIZE) + address as usize;
-        device.ui.saves.mempak.data[offset..offset + size]
+        device.ui.storage.saves.mempak.data[offset..offset + size]
             .copy_from_slice(&device.pif.ram[data..data + size]);
 
-        device.ui.saves.mempak.written = true
+        ui::storage::schedule_save(device, ui::storage::SaveTypes::Mempak);
     }
 }

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() {
-            device::ui::input::set_rumble(&mut device.ui, channel, rumble);
-        } else if device.netplay.as_ref().unwrap().player_number as usize == channel {
-            device::ui::input::set_rumble(&mut device.ui, 0, rumble);
+
+        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);
         }
     }
 }

src/device/controller/transferpak.rs

@@ -54,14 +54,14 @@ pub fn read(device: &mut device::Device, channel: usize, address: u16, data: usi
         0xC..=0xF => {
             device::controller::gbcart::read(
                 &mut device.pif.ram,
-                &mut pak.cart,
+                &pak.cart,
                 0x4000 * pak.bank + (address & 0x7fff) - 0x4000,
                 data,
                 size,
             );
         }
         _ => {
-            panic!("unknown transfer pak read {:x}", address >> 12);
+            println!("unknown transfer pak read {:x}", address >> 12);
         }
     }
 }
@@ -84,7 +84,7 @@ pub fn write(device: &mut device::Device, channel: usize, address: u16, data: us
                     }
                     pak.enabled = true;
                 }
-                _ => panic!("unknown transfer pak value"),
+                _ => println!("unknown transfer pak value"),
             }
             return;
         }
@@ -119,7 +119,7 @@ pub fn write(device: &mut device::Device, channel: usize, address: u16, data: us
         }
         0xC..=0xF => {
             device::controller::gbcart::write(
-                &mut device.pif.ram,
+                &device.pif.ram,
                 &mut pak.cart,
                 0x4000 * pak.bank + (address & 0x7fff) - 0x4000,
                 data,
@@ -127,7 +127,7 @@ pub fn write(device: &mut device::Device, channel: usize, address: u16, data: us
             );
         }
         _ => {
-            panic!("unknown transfer pak write {:x}", address >> 12);
+            println!("unknown transfer pak write {:x}", address >> 12);
         }
     }
 }

src/device/controller/vru.rs

@@ -1,5 +1,4 @@
 use crate::{device, ui};
-use eframe::egui;
 use std::collections::HashMap;
 
 const JCMD_VRU_READ: u8 = 0x09;
@@ -30,16 +29,6 @@ pub struct Vru {
     pub word_mappings: HashMap<String, String>,
 }
 
-#[derive(serde::Serialize, serde::Deserialize)]
-pub struct VruWindow {
-    #[serde(skip)]
-    pub window_notifier: Option<tokio::sync::mpsc::Sender<Vec<String>>>,
-    #[serde(skip)]
-    pub word_receiver: Option<tokio::sync::mpsc::Receiver<String>>,
-    #[serde(skip)]
-    pub gui_ctx: Option<egui::Context>,
-}
-
 pub fn init(device: &mut device::Device) {
     reset_vru(device);
     create_word_mappings(device);
@@ -129,7 +118,7 @@ pub fn process(device: &mut device::Device, channel: usize) {
 
                         let (res, _enc, errors) = encoding_rs::SHIFT_JIS.decode(&data);
                         if errors {
-                            panic!("Failed to decode Japanese word {:X?}", data);
+                            panic!("Failed to decode Japanese word {data:X?}");
                         } else {
                             device.vru.words.push(res.to_string());
                         }
@@ -147,7 +136,7 @@ pub fn process(device: &mut device::Device, channel: usize) {
                         if let Some(result) = word {
                             device.vru.words.push(result.clone());
                         } else {
-                            panic!("Unknown VRU word {}", data);
+                            panic!("Unknown VRU word {data}");
                         }
                     }
                 } else {
@@ -190,13 +179,8 @@ 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() {
-                ui::vru::prompt_for_match(
-                    &device.vru.words,
-                    device.vru_window.window_notifier.as_ref().unwrap(),
-                    device.vru_window.word_receiver.as_mut().unwrap(),
-                    device.vru_window.gui_ctx.as_ref().unwrap(),
-                )
+            let index = if let Some(weak) = &device.ui.weak {
+                ui::vru::prompt_for_match(&device.vru.words, weak, device.vi.frame_time)
             } else {
                 0x7FFF
             };
@@ -253,7 +237,7 @@ pub fn process(device: &mut device::Device, channel: usize) {
             }
             device.vru.status = 0; /* status is always set to 0 after a write */
         }
-        _ => panic!("unknown VRU command {}", cmd),
+        _ => panic!("unknown VRU command {cmd}"),
     }
 }
 
@@ -2730,5 +2714,17 @@ fn create_word_mappings(device: &mut device::Device) {
             String::from("82B582E382C182CF82C282AF82A282A982A2"),
             String::from("restricted-depart"),
         ),
+        (
+            String::from("009903720366006903C903FF0045033C"),
+            String::from("objection"),
+        ),
+        (
+            String::from("041100CF02EE0381004503B7"),
+            String::from("hold-it"),
+        ),
+        (
+            String::from("03BA019203C9036C0087000303C6"),
+            String::from("take-that"),
+        ),
     ]);
 }

src/device/cop0.rs

@@ -179,6 +179,8 @@ pub fn reserved(device: &mut device::Device, _opcode: u32) {
     device::exceptions::reserved_exception(device, 0);
 }
 
+pub fn emux_xdetect(_device: &mut device::Device, _opcode: u32) {}
+
 fn get_control_registers(device: &device::Device, index: u32) -> u64 {
     match index {
         COP0_COUNT_REG => device.cpu.cop0.regs[index as usize] >> 1,
@@ -261,38 +263,38 @@ pub fn add_cycles(device: &mut device::Device, cycles: u64) {
 
 pub fn map_instructions(device: &mut device::Device) {
     device.cpu.cop0.instrs = [
-        device::cop0::mfc0,        // 0
-        device::cop0::dmfc0,       // 1
-        device::cop0::reserved,    // 2
-        device::cop0::reserved,    // 3
-        device::cop0::mtc0,        // 4
-        device::cop0::dmtc0,       // 5
-        device::cop0::reserved,    // 6
-        device::cop0::reserved,    // 7
-        device::cop0::reserved,    // 8
-        device::cop0::reserved,    // 9
-        device::cop0::reserved,    // 10
-        device::cop0::reserved,    // 11
-        device::cop0::reserved,    // 12
-        device::cop0::reserved,    // 13
-        device::cop0::reserved,    // 14
-        device::cop0::reserved,    // 15
-        device::cop0::execute_cp0, // 16
-        device::cop0::reserved,    // 17
-        device::cop0::reserved,    // 18
-        device::cop0::reserved,    // 19
-        device::cop0::reserved,    // 20
-        device::cop0::reserved,    // 21
-        device::cop0::reserved,    // 22
-        device::cop0::reserved,    // 23
-        device::cop0::reserved,    // 24
-        device::cop0::reserved,    // 25
-        device::cop0::reserved,    // 26
-        device::cop0::reserved,    // 27
-        device::cop0::reserved,    // 28
-        device::cop0::reserved,    // 29
-        device::cop0::reserved,    // 30
-        device::cop0::reserved,    // 31
+        device::cop0::mfc0,         // 0
+        device::cop0::dmfc0,        // 1
+        device::cop0::reserved,     // 2
+        device::cop0::reserved,     // 3
+        device::cop0::mtc0,         // 4
+        device::cop0::dmtc0,        // 5
+        device::cop0::reserved,     // 6
+        device::cop0::reserved,     // 7
+        device::cop0::reserved,     // 8
+        device::cop0::reserved,     // 9
+        device::cop0::reserved,     // 10
+        device::cop0::reserved,     // 11
+        device::cop0::reserved,     // 12
+        device::cop0::reserved,     // 13
+        device::cop0::reserved,     // 14
+        device::cop0::reserved,     // 15
+        device::cop0::execute_cp0,  // 16
+        device::cop0::reserved,     // 17
+        device::cop0::reserved,     // 18
+        device::cop0::reserved,     // 19
+        device::cop0::emux_xdetect, // 20
+        device::cop0::reserved,     // 21
+        device::cop0::reserved,     // 22
+        device::cop0::reserved,     // 23
+        device::cop0::reserved,     // 24
+        device::cop0::reserved,     // 25
+        device::cop0::reserved,     // 26
+        device::cop0::reserved,     // 27
+        device::cop0::reserved,     // 28
+        device::cop0::reserved,     // 29
+        device::cop0::reserved,     // 30
+        device::cop0::reserved,     // 31
     ];
 
     device.cpu.cop0.instrs2 = [

src/device/cpu.rs

@@ -1,4 +1,4 @@
-use crate::{device, savestates};
+use crate::{device, savestates, ui};
 
 #[derive(PartialEq, serde::Serialize, serde::Deserialize)]
 pub enum State {
@@ -227,6 +227,10 @@ pub fn init(device: &mut device::Device) {
     device.cpu.clock_rate = if !device.cpu.overclock {
         93750000
     } else {
+        ui::video::onscreen_message(
+            &device.ui,
+            "Overclocking enabled, setting clock rate to 125 MHz",
+        );
         125000000
     };
 

src/device/events.rs

@@ -1,4 +1,5 @@
 use crate::device;
+use crate::ui;
 
 pub const EVENT_TYPE_NONE: usize = 0;
 pub const EVENT_TYPE_AI: usize = 1;
@@ -12,7 +13,8 @@ pub const EVENT_TYPE_SPDMA: usize = 8;
 pub const EVENT_TYPE_COMPARE: usize = 9;
 pub const EVENT_TYPE_VRU: usize = 10;
 pub const EVENT_TYPE_PAK: usize = 11;
-pub const EVENT_TYPE_COUNT: usize = 12;
+pub const EVENT_TYPE_SAVE: usize = 12;
+pub const EVENT_TYPE_COUNT: usize = 13;
 
 #[derive(PartialEq, Copy, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Event {
@@ -36,9 +38,9 @@ pub fn create_event_at(device: &mut device::Device, name: usize, when: u64) {
     set_next_event(device);
 }
 
-pub fn get_event(device: &mut device::Device, name: usize) -> Option<&mut Event> {
+pub fn get_event(device: &device::Device, name: usize) -> Option<&Event> {
     if device.cpu.events[name].enabled {
-        return Some(&mut device.cpu.events[name]);
+        return Some(&device.cpu.events[name]);
     }
     None
 }
@@ -60,6 +62,7 @@ fn get_event_handler(name: usize) -> fn(&mut device::Device) {
         EVENT_TYPE_COMPARE => device::cop0::compare_event,
         EVENT_TYPE_VRU => device::controller::vru::vru_talking_event,
         EVENT_TYPE_PAK => device::controller::pak_switch_event,
+        EVENT_TYPE_SAVE => ui::storage::save_event,
         _ => dummy_event,
     }
 }

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

@@ -40,8 +40,8 @@ pub enum AccessSize {
 
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct Memory {
-    #[serde(skip, default = "savestates::default_memory_read")]
-    pub fast_read: [fn(&mut device::Device, u64, AccessSize) -> u32; 0x2000], // fast_read is used for lookups that try to detect idle loops
+    #[serde(skip, default = "savestates::default_memory_read_fast")]
+    pub fast_read: [fn(&device::Device, u64, AccessSize) -> u32; 0x2000], // fast_read is used for lookups that try to detect idle loops
     #[serde(skip, default = "savestates::default_memory_read")]
     pub memory_map_read: [fn(&mut device::Device, u64, AccessSize) -> u32; 0x2000],
     #[serde(skip, default = "savestates::default_memory_write")]
@@ -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,5 +1,6 @@
-use crate::{device, ui};
-use rand_chacha::rand_core::RngCore;
+use crate::device;
+use crate::ui;
+use rand::Rng;
 
 const PI_DRAM_ADDR_REG: u32 = 0;
 const PI_CART_ADDR_REG: u32 = 1;
@@ -83,7 +84,6 @@ fn dma_write(device: &mut device::Device) {
     let cart_addr = device.pi.regs[PI_CART_ADDR_REG as usize] & !1;
     let dram_addr = device.pi.regs[PI_DRAM_ADDR_REG as usize] & 0xFFFFFE;
     let mut length = (device.pi.regs[PI_WR_LEN_REG as usize] & 0xFFFFFF) + 1;
-    ui::video::check_framebuffers(dram_addr);
 
     /* PI seems to treat the first 128 bytes differently, see https://n64brew.dev/wiki/Peripheral_Interface#Unaligned_DMA_transfer */
     if length >= 0x7f && (length & 1) != 0 {
@@ -93,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);
@@ -166,7 +169,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
     }
 }
 
-fn randomize_interrupt_time(rng: &mut rand_chacha::ChaCha8Rng) -> u64 {
+fn randomize_interrupt_time(rng: &mut rand::rngs::Xoshiro256PlusPlus) -> u64 {
     rng.next_u64() % 0x10
 }
 
@@ -222,7 +225,11 @@ fn unknown_dma_write(
     dram_addr &= device::rdram::RDRAM_MASK as u32;
 
     for i in 0..length {
-        device.rdram.mem[(dram_addr + i) as usize ^ device.byte_swap] = 0;
+        *device
+            .rdram
+            .mem
+            .get_mut((dram_addr + i) as usize ^ device.byte_swap)
+            .unwrap_or(&mut 0) = 0;
     }
     device::pi::calculate_cycles(device, 1, length)
 }

src/device/pif.rs

@@ -218,20 +218,37 @@ 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);
         }
     }
-    if device.ui.config.input.emulate_vru {
+    if device.ui.config.input.emulate_vru && device.netplay.is_none() {
         device.pif.channels[3].process = Some(device::controller::vru::process);
     }
     device.pif.channels[4].process = Some(device::cart::process)
 }
 
+fn get_default_handler(device: &device::Device) -> device::controller::PakHandler {
+    if device.ui.game_id == "NCT" {
+        // Chameleon Twist does not support the mempak
+        device::controller::PakHandler {
+            read: device::controller::rumble::read,
+            write: device::controller::rumble::write,
+            pak_type: device::controller::PakType::RumblePak,
+        }
+    } else {
+        device::controller::PakHandler {
+            read: device::controller::mempak::read,
+            write: device::controller::mempak::write,
+            pak_type: device::controller::PakType::MemPak,
+        }
+    }
+}
+
 pub fn init(device: &mut device::Device) {
     if device.cart.pal {
         device.pif.rom = rom::PAL_PIF_ROM;
@@ -241,11 +258,7 @@ pub fn init(device: &mut device::Device) {
     device.pif.ram[0x26] = device.cart.cic_seed;
     device.pif.ram[0x27] = device.cart.cic_seed;
 
-    let mempak_handler = device::controller::PakHandler {
-        read: device::controller::mempak::read,
-        write: device::controller::mempak::write,
-        pak_type: device::controller::PakType::MemPak,
-    };
+    let default_handler = get_default_handler(device);
     let tpak_handler = device::controller::PakHandler {
         read: device::controller::transferpak::read,
         write: device::controller::transferpak::write,
@@ -255,19 +268,19 @@ 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(mempak_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(mempak_handler);
         }
     }
-    if device.ui.config.input.emulate_vru {
+    if device.ui.config.input.emulate_vru && device.netplay.is_none() {
         device.pif.channels[3].pak_handler = None;
     }
 }

src/device/rdram.rs

@@ -24,15 +24,19 @@ pub struct Rdram {
 }
 
 pub fn read_mem_fast(
-    device: &mut device::Device,
+    device: &device::Device,
     address: u64,
     _access_size: device::memory::AccessSize,
 ) -> u32 {
     let masked_address = address as usize & RDRAM_MASK;
     u32::from_ne_bytes(
-        device.rdram.mem[masked_address..masked_address + 4]
+        device
+            .rdram
+            .mem
+            .get(masked_address..masked_address + 4)
+            .unwrap_or(&[0; 4])
             .try_into()
-            .unwrap(),
+            .unwrap_or_default(),
     )
 }
 
@@ -46,29 +50,71 @@ pub fn read_mem(
         rdram_calculate_cycles(access_size as u64) / (access_size as u64 / 4),
     );
     let masked_address = address as usize & RDRAM_MASK;
-    if address < device.rdram.size as u64 {
-        ui::video::check_framebuffers(masked_address as u32);
-        u32::from_ne_bytes(
-            device.rdram.mem[masked_address..masked_address + 4]
-                .try_into()
-                .unwrap(),
-        )
-    } else {
-        0
-    }
+
+    ui::video::check_framebuffers(masked_address as u32, 4);
+
+    u32::from_ne_bytes(
+        device
+            .rdram
+            .mem
+            .get(masked_address..masked_address + 4)
+            .unwrap_or(&[0; 4])
+            .try_into()
+            .unwrap_or_default(),
+    )
 }
 
 pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u32) {
-    if address < device.rdram.size as u64 {
-        ui::video::check_framebuffers(address as u32);
-        let mut data = u32::from_ne_bytes(
-            device.rdram.mem[address as usize..(address + 4) as usize]
-                .try_into()
-                .unwrap(),
+    ui::video::check_framebuffers(address as u32, 4);
+
+    let mut data = u32::from_ne_bytes(
+        device
+            .rdram
+            .mem
+            .get(address as usize..(address + 4) as usize)
+            .unwrap_or(&[0; 4])
+            .try_into()
+            .unwrap_or_default(),
+    );
+    device::memory::masked_write_32(&mut data, value, mask);
+    device
+        .rdram
+        .mem
+        .get_mut(address as usize..(address + 4) as usize)
+        .unwrap_or(&mut [0; 4])
+        .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
         );
-        device::memory::masked_write_32(&mut data, value, mask);
-        device.rdram.mem[address as usize..(address + 4) as usize]
-            .copy_from_slice(&data.to_ne_bytes());
+    }
+
+    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;
     }
 }
 
@@ -106,9 +152,19 @@ pub fn init(device: &mut device::Device) {
         unsafe { Vec::from_raw_parts(ptr, device.rdram.size as usize, device.rdram.size as usize) };
 
     // hack, skip RDRAM initialization
-    device.rdram.mem[0x318..0x318 + 4].copy_from_slice(&device.rdram.size.to_ne_bytes());
+    device
+        .rdram
+        .mem
+        .get_mut(0x318..0x318 + 4)
+        .unwrap_or(&mut [0; 4])
+        .copy_from_slice(&device.rdram.size.to_ne_bytes());
     // hack, skip RDRAM initialization
-    device.rdram.mem[0x3f0..0x3f0 + 4].copy_from_slice(&device.rdram.size.to_ne_bytes());
+    device
+        .rdram
+        .mem
+        .get_mut(0x3f0..0x3f0 + 4)
+        .unwrap_or(&mut [0; 4])
+        .copy_from_slice(&device.rdram.size.to_ne_bytes());
 
     device.ri.regs[device::ri::RI_MODE_REG as usize] = 0x0e;
     device.ri.regs[device::ri::RI_CONFIG_REG as usize] = 0x40;

src/device/rsp_interface.rs

@@ -89,7 +89,7 @@ pub struct Rsp {
 }
 
 pub fn read_mem_fast(
-    device: &mut device::Device,
+    device: &device::Device,
     address: u64,
     _access_size: device::memory::AccessSize,
 ) -> u32 {
@@ -147,7 +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);
+    ui::video::check_framebuffers(dram_addr, count * (length + skip) - skip);
     if dma.dir == DmaDir::Read {
         let mut j = 0;
         while j < count {
@@ -159,7 +159,11 @@ fn do_dma(device: &mut device::Device, dma: RspDma) {
                         .try_into()
                         .unwrap(),
                 );
-                device.rdram.mem[dram_addr as usize..dram_addr as usize + 4]
+                device
+                    .rdram
+                    .mem
+                    .get_mut(dram_addr as usize..dram_addr as usize + 4)
+                    .unwrap_or(&mut [0; 4])
                     .copy_from_slice(&data.to_ne_bytes());
                 mem_addr += 4;
                 dram_addr += 4;
@@ -173,14 +177,16 @@ fn do_dma(device: &mut device::Device, dma: RspDma) {
         while j < count {
             let mut i = 0;
             while i < length {
-                let mut data = 0;
-                if dram_addr < device.rdram.size {
-                    data = u32::from_ne_bytes(
-                        device.rdram.mem[dram_addr as usize..dram_addr as usize + 4]
-                            .try_into()
-                            .unwrap(),
-                    );
-                }
+                let data = u32::from_ne_bytes(
+                    device
+                        .rdram
+                        .mem
+                        .get(dram_addr as usize..dram_addr as usize + 4)
+                        .unwrap_or(&[0; 4])
+                        .try_into()
+                        .unwrap_or_default(),
+                );
+
                 if offset != 0 {
                     // imem being updated
                     device.rsp.cpu.instructions[((mem_addr & 0xFFF) / 4) as usize].func =
@@ -215,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 {
@@ -272,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]
         }
@@ -460,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,26 +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];
-    w[0] = device.rsp.mem[address as usize & 0xFFF];
-    w[1] = device.rsp.mem[(address as usize + 1) & 0xFFF];
-    w[2] = device.rsp.mem[(address as usize + 2) & 0xFFF];
-    w[3] = device.rsp.mem[(address as usize + 3) & 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) {
@@ -337,25 +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];
-    w[0] = device.rsp.mem[address as usize & 0xFFF];
-    w[1] = device.rsp.mem[(address as usize + 1) & 0xFFF];
-    w[2] = device.rsp.mem[(address as usize + 2) & 0xFFF];
-    w[3] = device.rsp.mem[(address as usize + 3) & 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) {
@@ -369,23 +406,31 @@ 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);
 
-    device.rsp.mem[address as usize & 0xFFF] =
-        (device.rsp.cpu.gpr[rt(opcode) as usize] >> 24) as u8;
-    device.rsp.mem[(address as usize + 1) & 0xFFF] =
-        (device.rsp.cpu.gpr[rt(opcode) as usize] >> 16) as u8;
-    device.rsp.mem[(address as usize + 2) & 0xFFF] =
-        (device.rsp.cpu.gpr[rt(opcode) as usize] >> 8) as u8;
-    device.rsp.mem[(address as usize + 3) & 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];
+    // 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;
+        }
+    }
 }
 
 pub fn sll(device: &mut device::Device, opcode: u32) {
@@ -606,19 +651,19 @@ pub fn mfc2(device: &mut device::Device, opcode: u32) {
 pub fn cfc2(device: &mut device::Device, opcode: u32) {
     let hi;
     let lo;
-    let mut zero = unsafe { _mm_setzero_si128() };
+    let zero = unsafe { _mm_setzero_si128() };
     match rd(opcode) & 3 {
         0x00 => {
-            hi = &mut device.rsp.cpu.vcoh;
-            lo = &mut device.rsp.cpu.vcol;
+            hi = &device.rsp.cpu.vcoh;
+            lo = &device.rsp.cpu.vcol;
         }
         0x01 => {
-            hi = &mut device.rsp.cpu.vcch;
-            lo = &mut device.rsp.cpu.vccl;
+            hi = &device.rsp.cpu.vcch;
+            lo = &device.rsp.cpu.vccl;
         }
         0x02 | 0x03 => {
-            hi = &mut zero;
-            lo = &mut device.rsp.cpu.vce;
+            hi = &zero;
+            lo = &device.rsp.cpu.vce;
         }
         _ => {
             panic!("unknown cfc2")
@@ -715,7 +760,7 @@ pub fn lsv(device: &mut device::Device, opcode: u32) {
 
     let mut element = velement(opcode);
 
-    if element % 2 == 0 {
+    if element.is_multiple_of(2) {
         modify_vpr16(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
             element / 2,
@@ -742,11 +787,22 @@ pub fn llv(device: &mut device::Device, opcode: u32) {
 
     let mut element = velement(opcode);
 
-    if element % 4 == 0 {
-        let mut value = 0;
-        for i in 0..4 {
-            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u32) << (8 * (3 - i));
-        }
+    if element.is_multiple_of(4) {
+        // 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,
@@ -772,11 +828,22 @@ pub fn ldv(device: &mut device::Device, opcode: u32) {
 
     let mut element = velement(opcode);
 
-    if element % 8 == 0 {
-        let mut value = 0;
-        for i in 0..8 {
-            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u64) << (8 * (7 - i));
-        }
+    if element.is_multiple_of(8) {
+        // 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,
@@ -802,11 +869,22 @@ pub fn lqv(device: &mut device::Device, opcode: u32) {
 
     let mut element = velement(opcode);
 
-    if element == 0 && address % 16 == 0 {
-        let mut value = 0;
-        for i in 0..16 {
-            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u128) << (8 * (15 - i));
-        }
+    if element == 0 && address.is_multiple_of(16) {
+        // 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);
@@ -829,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 {
@@ -981,7 +1070,7 @@ pub fn ssv(device: &mut device::Device, opcode: u32) {
 
     let mut element = velement(opcode);
 
-    if element % 2 == 0 {
+    if element.is_multiple_of(2) {
         let start = (address & 0xFFF) as usize;
         device.rsp.mem[start..start + 2].copy_from_slice(
             &get_vpr16(device.rsp.cpu.vpr[rt(opcode) as usize], element / 2).to_be_bytes(),
@@ -1003,7 +1092,7 @@ pub fn slv(device: &mut device::Device, opcode: u32) {
 
     let mut element = velement(opcode);
 
-    if element % 4 == 0 {
+    if element.is_multiple_of(4) {
         let start = (address & 0xFFF) as usize;
         device.rsp.mem[start..start + 4].copy_from_slice(
             &get_vpr32(device.rsp.cpu.vpr[rt(opcode) as usize], element / 4).to_be_bytes(),
@@ -1025,7 +1114,7 @@ pub fn sdv(device: &mut device::Device, opcode: u32) {
 
     let mut element = velement(opcode);
 
-    if element % 8 == 0 {
+    if element.is_multiple_of(8) {
         let start = (address & 0xFFF) as usize;
         device.rsp.mem[start..start + 8].copy_from_slice(
             &get_vpr64(device.rsp.cpu.vpr[rt(opcode) as usize], element / 8).to_be_bytes(),
@@ -1047,7 +1136,7 @@ pub fn sqv(device: &mut device::Device, opcode: u32) {
 
     let mut element = velement(opcode);
 
-    if element == 0 && address % 16 == 0 {
+    if element == 0 && address.is_multiple_of(16) {
         let start = (address & 0xFFF) as usize;
         device.rsp.mem[start..start + 16]
             .copy_from_slice(&get_vpr128(device.rsp.cpu.vpr[rt(opcode) as usize]).to_be_bytes());

src/device/si.rs

@@ -1,6 +1,6 @@
-use rand_chacha::rand_core::RngCore;
-
 use crate::device;
+use crate::ui;
+use rand::Rng;
 
 const SI_DRAM_ADDR_REG: u32 = 0;
 const SI_PIF_ADDR_RD64B_REG: u32 = 1;
@@ -38,7 +38,7 @@ pub fn read_regs(
     device.si.regs[((address & 0xFFFF) >> 2) as usize]
 }
 
-fn randomize_interrupt_time(rng: &mut rand_chacha::ChaCha8Rng) -> u64 {
+fn randomize_interrupt_time(rng: &mut rand::rngs::Xoshiro256PlusPlus) -> u64 {
     rng.next_u64() % 0x100
 }
 
@@ -86,18 +86,29 @@ fn copy_pif_rdram(device: &mut device::Device) {
         let mut i = 0;
         while i < device::pif::PIF_RAM_SIZE {
             let data = u32::from_ne_bytes(
-                device.rdram.mem[dram_addr + i..dram_addr + i + 4]
+                device
+                    .rdram
+                    .mem
+                    .get(dram_addr + i..dram_addr + i + 4)
+                    .unwrap_or(&[0; 4])
                     .try_into()
-                    .unwrap(),
+                    .unwrap_or_default(),
             );
             device.pif.ram[i..i + 4].copy_from_slice(&data.to_be_bytes());
             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());
-            device.rdram.mem[dram_addr + i..dram_addr + i + 4].copy_from_slice(&data.to_ne_bytes());
+            device
+                .rdram
+                .mem
+                .get_mut(dram_addr + i..dram_addr + i + 4)
+                .unwrap_or(&mut [0; 4])
+                .copy_from_slice(&data.to_ne_bytes());
             i += 4;
         }
     } else {

src/device/tlb.rs

@@ -146,7 +146,7 @@ pub fn probe(device: &mut device::Device) {
 }
 
 fn tlb_unmap(device: &mut device::Device, index: u64) {
-    let e = &mut device.cpu.cop0.tlb_entries[index as usize];
+    let e = &device.cpu.cop0.tlb_entries[index as usize];
 
     if e.v_even != 0 {
         let mut i = e.start_even;
@@ -184,7 +184,7 @@ fn tlb_unmap(device: &mut device::Device, index: u64) {
 }
 
 fn tlb_map(device: &mut device::Device, index: u64) {
-    let e = &mut device.cpu.cop0.tlb_entries[index as usize];
+    let e = &device.cpu.cop0.tlb_entries[index as usize];
 
     if e.v_even != 0
         && e.start_even < e.end_even

src/device/unmapped.rs

@@ -1,7 +1,7 @@
 use crate::device;
 
-pub fn read_mem(
-    _device: &mut device::Device,
+pub fn read_mem_fast(
+    _device: &device::Device,
     address: u64,
     _access_size: device::memory::AccessSize,
 ) -> u32 {
@@ -9,4 +9,12 @@ pub fn read_mem(
     value | (value << 16)
 }
 
+pub fn read_mem(
+    device: &mut device::Device,
+    address: u64,
+    access_size: device::memory::AccessSize,
+) -> u32 {
+    read_mem_fast(device, address, access_size)
+}
+
 pub fn write_mem(_device: &mut device::Device, _address: u64, _value: u32, _mask: u32) {}

src/device/vi.rs

@@ -1,4 +1,4 @@
-use crate::{device, netplay, ui};
+use crate::{cheats, device, netplay, ui};
 use governor::clock::Clock;
 
 const VI_STATUS_REG: u32 = 0;
@@ -70,12 +70,10 @@ fn set_vertical_interrupt(device: &mut device::Device) {
 }
 
 fn set_current_line(device: &mut device::Device) {
-    let delay = device.vi.delay;
     let next_vi = device::events::get_event(device, device::events::EVENT_TYPE_VI);
-    if next_vi.is_some() {
-        device.vi.regs[VI_CURRENT_REG as usize] = ((delay
-            - (next_vi.unwrap().count
-                - device.cpu.cop0.regs[device::cop0::COP0_COUNT_REG as usize]))
+    if let Some(next_vi) = next_vi {
+        device.vi.regs[VI_CURRENT_REG as usize] = ((device.vi.delay
+            - (next_vi.count - device.cpu.cop0.regs[device::cop0::COP0_COUNT_REG as usize]))
             / device.vi.count_per_scanline)
             as u32;
 
@@ -86,7 +84,8 @@ fn set_current_line(device: &mut device::Device) {
     }
     /* update current field */
     device.vi.regs[VI_CURRENT_REG as usize] =
-        (device.vi.regs[VI_CURRENT_REG as usize] & !1) | device.vi.field
+        (device.vi.regs[VI_CURRENT_REG as usize] & !1) | device.vi.field;
+    ui::video::set_register(VI_CURRENT_REG, device.vi.regs[VI_CURRENT_REG as usize])
 }
 
 pub fn read_regs(
@@ -134,18 +133,34 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
 }
 
 pub fn vertical_interrupt_event(device: &mut device::Device) {
-    ui::video::check_callback(device);
-
-    if device.netplay.is_some() {
-        netplay::send_sync_check(device);
-        device.vi.enable_speed_limiter = !device.netplay.as_ref().unwrap().fast_forward;
+    if device.cheats.enabled {
+        cheats::execute_cheats(device, device.cheats.cheats.clone());
     }
 
-    device.vi.vi_counter += 1;
-    if device.vi.vi_counter % device.vi.limit_freq == 0 && device.vi.enable_speed_limiter {
-        speed_limiter(device);
+    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 = !netplay.fast_forward;
+        }
     }
+
+    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 };
@@ -175,10 +190,8 @@ pub fn init(device: &mut device::Device) {
     }
 }
 
-fn speed_limiter(device: &mut device::Device) {
-    let result = device.vi.limiter.as_ref().unwrap().check();
-    if result.is_err() {
-        let outcome = result.unwrap_err();
+fn speed_limiter(device: &mut device::Device, speed_limiter_toggled: bool) {
+    if let Err(outcome) = device.vi.limiter.as_ref().unwrap().check() {
         let dur = outcome.wait_time_from(governor::clock::DefaultClock::default().now());
         spin_sleep::sleep(dur);
         if dur < device.vi.min_wait_time {
@@ -195,14 +208,17 @@ fn speed_limiter(device: &mut device::Device) {
         .as_secs_f64()
         > 1.0
     {
-        if device.vi.min_wait_time.as_secs_f64() == 0.0 && device.vi.limit_freq < MAX_LIMIT_FREQ {
-            device.vi.limit_freq += 1;
-            create_limiter(device);
-        } else if device.vi.min_wait_time.as_secs_f64() > device.vi.frame_time
-            && device.vi.limit_freq > 1
-        {
-            device.vi.limit_freq -= 1;
-            create_limiter(device);
+        if !speed_limiter_toggled {
+            if device.vi.min_wait_time.as_secs_f64() == 0.0 && device.vi.limit_freq < MAX_LIMIT_FREQ
+            {
+                device.vi.limit_freq += 1;
+                create_limiter(device);
+            } else if device.vi.min_wait_time.as_secs_f64() > device.vi.frame_time
+                && device.vi.limit_freq > 1
+            {
+                device.vi.limit_freq -= 1;
+                create_limiter(device);
+            }
         }
 
         //println!("limit freq: {}", device.vi.limit_freq);

src/main.rs

@@ -3,11 +3,13 @@
 #[global_allocator]
 static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
+mod cheats;
 mod device;
 mod netplay;
 mod savestates;
 mod ui;
 use clap::Parser;
+use std::io::Error;
 use ui::gui;
 
 /// N64 emulator
@@ -21,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,
@@ -65,149 +74,97 @@ struct Args {
     clear_input_bindings: bool,
 }
 
-#[tokio::main]
-async fn main() {
+fn main() -> std::io::Result<()> {
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .worker_threads(4)
+        .thread_name("n64")
+        .thread_stack_size(env!("N64_STACK_SIZE").parse().unwrap())
+        .build()
+        .unwrap();
+
     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.cache_dir.clone());
-    if result.is_err() {
-        panic!("could not create cache 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())
-    }
-    let running_file = dirs.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())
-        }
-    }
-
+    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 = runtime.spawn(async 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,
+                },
+            );
+        });
+        runtime.block_on(handle).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 = gui::get_controller_names(&ui);
+            let controllers = ui::input::get_controller_names(&ui);
             for (i, controller) in controllers.iter().enumerate() {
-                println!("Controller {}: {}", i, controller);
+                println!("Controller {i}: {controller}");
             }
-            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(),
-            );
-            return;
-        }
-        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(),
-            );
-            return;
-        }
-        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(());
         }
-    } else if args.game.is_some() {
-        let file_path = std::path::Path::new(args.game.as_ref().unwrap());
-        let rom_contents = device::get_rom_contents(file_path);
-        if rom_contents.is_empty() {
-            println!("Could not read rom file");
-            return;
+        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 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);
         }
-        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;
-                device::run_game(&mut device, rom_contents, args.fullscreen, overclock);
-            })
-            .unwrap();
-
-        handle.join().unwrap();
     } else {
-        let options = eframe::NativeOptions {
-            wgpu_options: eframe::egui_wgpu::WgpuConfiguration {
-                wgpu_setup: eframe::egui_wgpu::WgpuSetup::CreateNew(
-                    eframe::egui_wgpu::WgpuSetupCreateNew {
-                        instance_descriptor: eframe::egui_wgpu::wgpu::InstanceDescriptor {
-                            backends: eframe::wgpu::Backends::GL,
-                            ..Default::default()
-                        },
-                        ..Default::default()
-                    },
-                ),
-                ..Default::default()
-            },
-            viewport: eframe::egui::ViewportBuilder::default()
-                .with_inner_size([854.0, 480.0])
-                .with_icon(
-                    eframe::icon_data::from_png_bytes(include_bytes!("../data/gopher64.png"))
-                        .unwrap(),
-                ),
-            ..Default::default()
-        };
-
-        let controllers_paths;
-        let controller_names;
-        {
-            let game_ui = ui::Ui::new();
-            controllers_paths = gui::get_controller_paths(&game_ui);
-            controller_names = gui::get_controller_names(&game_ui);
-        }
-        eframe::run_native(
-            "gopher64",
-            options,
-            Box::new(|cc| {
-                Ok(Box::new(ui::gui::GopherEguiApp::new(
-                    cc,
-                    controllers_paths,
-                    controller_names,
-                )))
-            }),
-        )
-        .unwrap();
+        runtime.block_on(async {
+            gui::app_window();
+        });
     }
+    runtime.shutdown_timeout(std::time::Duration::from_secs(1));
+    Ok(())
 }

src/netplay.rs

@@ -46,14 +46,6 @@ struct InputEvent {
     plugin: u8,
 }
 
-pub const NETPLAY_ERROR_DESYNC: u32 = 0;
-pub const NETPLAY_ERROR_LOST_CONNECTION: u32 = 1;
-pub const NETPLAY_ERROR_PLAYER_DISCONNECTED: u32 = 2;
-pub const NETPLAY_ERROR_PLAYER_1_DISCONNECTED: u32 = 3;
-pub const NETPLAY_ERROR_PLAYER_2_DISCONNECTED: u32 = 4;
-pub const NETPLAY_ERROR_PLAYER_3_DISCONNECTED: u32 = 5;
-pub const NETPLAY_ERROR_PLAYER_4_DISCONNECTED: u32 = 6;
-
 pub fn send_rtc(netplay: &mut Netplay, rtc: i64) {
     let mut request: Vec<u8> = [TCP_SEND_RTC].to_vec();
     let size: u32 = 8;
@@ -111,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();
-    if netplay.vi_counter % 600 == 0 {
+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();
@@ -144,7 +135,7 @@ pub fn get_input(device: &mut device::Device, channel: usize) -> ui::input::Inpu
     let timeout = std::time::Instant::now() + std::time::Duration::from_secs(10);
     let mut request_timer = std::time::Instant::now() - std::time::Duration::from_millis(5);
     while input.is_none() {
-        process_incoming(netplay, &mut device.ui); // we execute process_incoming before request_input so that we send an accurate buffer count
+        process_incoming(netplay, &device.ui); // we execute process_incoming before request_input so that we send an accurate buffer count
         if std::time::Instant::now() > request_timer {
             // sends a request packet every 5ms
             request_input(netplay, channel);
@@ -155,7 +146,7 @@ pub fn get_input(device: &mut device::Device, channel: usize) -> ui::input::Inpu
             .remove(&netplay.player_data[channel].count);
 
         if std::time::Instant::now() > timeout {
-            ui::audio::play_netplay_audio(&mut device.ui, NETPLAY_ERROR_LOST_CONNECTION);
+            ui::video::onscreen_message(&device.ui, "Lost connection to netplay server");
             input = Some(InputEvent {
                 input: 0,
                 plugin: 0,
@@ -186,7 +177,7 @@ fn request_input(netplay: &Netplay, channel: usize) {
     netplay.udp_socket.send(&request).unwrap();
 }
 
-fn process_incoming(netplay: &mut Netplay, ui: &mut ui::Ui) {
+fn process_incoming(netplay: &mut Netplay, ui: &ui::Ui) {
     let mut buf: [u8; 1024] = [0; 1024];
     while let Ok(_incoming) = netplay.udp_socket.recv(&mut buf) {
         match buf[0] {
@@ -200,15 +191,13 @@ fn process_incoming(netplay: &mut Netplay, ui: &mut ui::Ui) {
                 }
                 if current_status != netplay.status {
                     if ((current_status & 0x1) ^ (netplay.status & 0x1)) != 0 {
-                        ui::audio::play_netplay_audio(ui, NETPLAY_ERROR_DESYNC);
+                        ui::video::onscreen_message(ui, "Netplay desync detected");
+                        ui::video::onscreen_message(ui, "Netplay desync detected"); // queue this message twice to ensure they see it
                     }
                     for dis in 1..5 {
                         if ((current_status & (0x1 << dis)) ^ (netplay.status & (0x1 << dis))) != 0
                         {
-                            ui::audio::play_netplay_audio(
-                                ui,
-                                NETPLAY_ERROR_PLAYER_DISCONNECTED + dis,
-                            );
+                            ui::video::onscreen_message(ui, &format!("Player {dis} disconnected"));
                         }
                     }
                     netplay.status = current_status;
@@ -246,18 +235,13 @@ fn process_incoming(netplay: &mut Netplay, ui: &mut ui::Ui) {
     }
 }
 
-pub fn init(
-    mut peer_addr: std::net::SocketAddr,
-    session: ui::gui::gui_netplay::NetplayRoom,
-    player_number: u8,
-) -> Netplay {
-    peer_addr.set_port(session.port.unwrap() as u16);
+pub fn init(peer_addr: std::net::SocketAddr, player_number: u8) -> Netplay {
     let udp_socket;
     if peer_addr.is_ipv4() {
         udp_socket = std::net::UdpSocket::bind((std::net::Ipv4Addr::UNSPECIFIED, 0))
             .expect("couldn't bind to address");
         socket2::SockRef::from(&udp_socket)
-            .set_tos(CS4 << 2)
+            .set_tos_v4(CS4 << 2)
             .unwrap();
     } else {
         udp_socket = std::net::UdpSocket::bind((std::net::Ipv6Addr::UNSPECIFIED, 0))

src/savestates.rs

@@ -1,4 +1,4 @@
-use crate::{device, ui};
+use crate::{cheats, device, ui};
 #[cfg(target_arch = "aarch64")]
 use device::__m128i;
 use serde::de::{Deserialize, Deserializer, SeqAccess, Visitor};
@@ -12,7 +12,7 @@ impl<'de, const N: usize> Visitor<'de> for M128iArrayVisitor<N> {
     type Value = [__m128i; N];
 
     fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        formatter.write_str(&format!("an array of {} 128-bit integers", N))
+        formatter.write_str(&format!("an array of {N} 128-bit integers"))
     }
 
     fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
@@ -70,127 +70,155 @@ where
 }
 
 pub fn create_savestate(device: &device::Device) {
-    ui::video::full_sync();
+    let mut rdp_state: Vec<u8> = vec![0; ui::video::state_size()];
+    ui::video::save_state(rdp_state.as_mut_ptr());
 
     let data: &[(&[u8], &str)] = &[
         (&postcard::to_stdvec(device).unwrap(), "device"),
-        (&postcard::to_stdvec(&device.ui.saves).unwrap(), "saves"),
+        (
+            &postcard::to_stdvec(&device.ui.storage.saves).unwrap(),
+            "saves",
+        ),
+        (&rdp_state, "rdp_state"),
     ];
     let compressed_file = ui::storage::compress_file(data);
-    std::fs::write(device.ui.paths.savestate_file_path.clone(), compressed_file).unwrap();
+    std::fs::write(
+        device.ui.storage.paths.savestate_file_path.clone(),
+        compressed_file,
+    )
+    .unwrap();
+    ui::video::onscreen_message(
+        &device.ui,
+        &format!(
+            "Savestate created in slot {}",
+            device.ui.storage.save_state_slot
+        ),
+    );
 }
 
 pub fn load_savestate(device: &mut device::Device) {
-    let savestate = std::fs::read(&mut device.ui.paths.savestate_file_path);
-    if savestate.is_ok() {
-        let device_bytes = ui::storage::decompress_file(savestate.as_ref().unwrap(), "device");
-        let save_bytes = ui::storage::decompress_file(savestate.as_ref().unwrap(), "saves");
-        let state: device::Device = postcard::from_bytes(&device_bytes).unwrap();
+    let savestate = std::fs::read(&device.ui.storage.paths.savestate_file_path);
+    if let Ok(savestate) = &savestate {
+        let device_bytes = ui::storage::decompress_file(savestate, "device");
+        let save_bytes = ui::storage::decompress_file(savestate, "saves");
+        let rdp_state = ui::storage::decompress_file(savestate, "rdp_state");
+        if let Ok(state) = postcard::from_bytes::<device::Device>(&device_bytes) {
+            device.ui.storage.saves = postcard::from_bytes(&save_bytes).unwrap();
 
-        device.ui.saves = postcard::from_bytes(&save_bytes).unwrap();
+            device.cpu = state.cpu;
+            device.pif = state.pif;
 
-        device.cpu = state.cpu;
-        device.pif = state.pif;
+            let rom = device.cart.rom.clone();
+            device.cart = state.cart;
+            device.cart.rom = rom;
 
-        let rom = device.cart.rom.clone();
-        device.cart = state.cart;
-        device.cart.rom = rom;
+            device.memory = state.memory;
+            device.rsp = state.rsp;
+            device.rdp = state.rdp;
+            device.rdram = state.rdram;
+            device.mi = state.mi;
+            device.pi = state.pi;
+            device.vi = state.vi;
+            device.ai = state.ai;
+            device.si = state.si;
+            device.ri = state.ri;
+            device.vru = state.vru;
+            device.cheats = state.cheats;
 
-        device.memory = state.memory;
-        device.rsp = state.rsp;
-        device.rdp = state.rdp;
-        device.rdram = state.rdram;
-        device.mi = state.mi;
-        device.pi = state.pi;
-        device.vi = state.vi;
-        device.ai = state.ai;
-        device.si = state.si;
-        device.ri = state.ri;
-        device.vru = state.vru;
+            let mut tpak_rom = [vec![], vec![], vec![], vec![]];
+            for (i, item) in tpak_rom.iter_mut().enumerate() {
+                *item = device.transferpaks[i].cart.rom.clone();
+            }
+            device.transferpaks = state.transferpaks;
+            for (i, item) in tpak_rom.iter().enumerate() {
+                device.transferpaks[i].cart.rom = item.clone();
+            }
 
-        let mut tpak_rom = [vec![], vec![], vec![], vec![]];
-        for (i, item) in tpak_rom.iter_mut().enumerate() {
-            *item = device.transferpaks[i].cart.rom.clone();
-        }
-        device.transferpaks = state.transferpaks;
-        for (i, item) in tpak_rom.iter().enumerate() {
-            device.transferpaks[i].cart.rom = item.clone();
-        }
+            device::memory::init(device);
+            device::vi::set_expected_refresh_rate(device);
+            device::cpu::map_instructions(device);
+            device::cop0::map_instructions(device);
+            device::cop1::map_instructions(device);
+            device::cop2::map_instructions(device);
+            device::rsp_cpu::map_instructions(device);
 
-        device::memory::init(device);
-        device::vi::set_expected_refresh_rate(device);
-        device::cpu::map_instructions(device);
-        device::cop0::map_instructions(device);
-        device::cop1::map_instructions(device);
-        device::cop2::map_instructions(device);
-        device::rsp_cpu::map_instructions(device);
+            let mut mem_addr = 0x1000;
+            while mem_addr < 0x2000 {
+                let data =
+                    u32::from_be_bytes(device.rsp.mem[mem_addr..mem_addr + 4].try_into().unwrap());
+                device.rsp.cpu.instructions[(mem_addr & 0xFFF) / 4].func =
+                    device::rsp_cpu::decode_opcode(device, data);
+                device.rsp.cpu.instructions[(mem_addr & 0xFFF) / 4].opcode = data;
+                mem_addr += 4;
+            }
 
-        let mut mem_addr = 0x1000;
-        while mem_addr < 0x2000 {
-            let data =
-                u32::from_be_bytes(device.rsp.mem[mem_addr..mem_addr + 4].try_into().unwrap());
-            device.rsp.cpu.instructions[(mem_addr & 0xFFF) / 4].func =
-                device::rsp_cpu::decode_opcode(device, data);
-            device.rsp.cpu.instructions[(mem_addr & 0xFFF) / 4].opcode = data;
-            mem_addr += 4;
-        }
-
-        for line_index in 0..512 {
-            device.memory.icache[line_index].instruction[0] =
-                device::cpu::decode_opcode(device, device.memory.icache[line_index].words[0]);
-            device.memory.icache[line_index].instruction[1] =
-                device::cpu::decode_opcode(device, device.memory.icache[line_index].words[1]);
-            device.memory.icache[line_index].instruction[2] =
-                device::cpu::decode_opcode(device, device.memory.icache[line_index].words[2]);
-            device.memory.icache[line_index].instruction[3] =
-                device::cpu::decode_opcode(device, device.memory.icache[line_index].words[3]);
-            device.memory.icache[line_index].instruction[4] =
-                device::cpu::decode_opcode(device, device.memory.icache[line_index].words[4]);
-            device.memory.icache[line_index].instruction[5] =
-                device::cpu::decode_opcode(device, device.memory.icache[line_index].words[5]);
-            device.memory.icache[line_index].instruction[6] =
-                device::cpu::decode_opcode(device, device.memory.icache[line_index].words[6]);
-            device.memory.icache[line_index].instruction[7] =
-                device::cpu::decode_opcode(device, device.memory.icache[line_index].words[7]);
-        }
-
-        device::pif::connect_pif_channels(device);
-        for i in 0..4 {
-            if device.pif.channels[i].pak_handler.is_some() {
-                if device.pif.channels[i].pak_handler.unwrap().pak_type
-                    == device::controller::PakType::RumblePak
-                {
-                    let rumblepak_handler = device::controller::PakHandler {
-                        read: device::controller::rumble::read,
-                        write: device::controller::rumble::write,
-                        pak_type: device::controller::PakType::RumblePak,
-                    };
-                    device.pif.channels[i].pak_handler = Some(rumblepak_handler);
-                } else if device.pif.channels[i].pak_handler.unwrap().pak_type
-                    == device::controller::PakType::MemPak
-                {
-                    let mempak_handler = device::controller::PakHandler {
-                        read: device::controller::mempak::read,
-                        write: device::controller::mempak::write,
-                        pak_type: device::controller::PakType::MemPak,
-                    };
-                    device.pif.channels[i].pak_handler = Some(mempak_handler);
-                } else if device.pif.channels[i].pak_handler.unwrap().pak_type
-                    == device::controller::PakType::TransferPak
-                {
-                    let tpak_handler = device::controller::PakHandler {
-                        read: device::controller::transferpak::read,
-                        write: device::controller::transferpak::write,
-                        pak_type: device::controller::PakType::TransferPak,
-                    };
-                    device.pif.channels[i].pak_handler = Some(tpak_handler);
+            for line_index in 0..512 {
+                for i in 0..8 {
+                    device.memory.icache[line_index].instruction[i] = device::cpu::decode_opcode(
+                        device,
+                        device.memory.icache[line_index].words[i],
+                    );
                 }
             }
-        }
 
-        ui::audio::close(&mut device.ui);
-        ui::audio::init(&mut device.ui, device.ai.freq);
-        ui::video::load_state(device);
+            device::pif::connect_pif_channels(device);
+            for i in 0..4 {
+                if device.pif.channels[i].pak_handler.is_some() {
+                    if device.pif.channels[i].pak_handler.unwrap().pak_type
+                        == device::controller::PakType::RumblePak
+                    {
+                        let rumblepak_handler = device::controller::PakHandler {
+                            read: device::controller::rumble::read,
+                            write: device::controller::rumble::write,
+                            pak_type: device::controller::PakType::RumblePak,
+                        };
+                        device.pif.channels[i].pak_handler = Some(rumblepak_handler);
+                    } else if device.pif.channels[i].pak_handler.unwrap().pak_type
+                        == device::controller::PakType::MemPak
+                    {
+                        let mempak_handler = device::controller::PakHandler {
+                            read: device::controller::mempak::read,
+                            write: device::controller::mempak::write,
+                            pak_type: device::controller::PakType::MemPak,
+                        };
+                        device.pif.channels[i].pak_handler = Some(mempak_handler);
+                    } else if device.pif.channels[i].pak_handler.unwrap().pak_type
+                        == device::controller::PakType::TransferPak
+                    {
+                        let tpak_handler = device::controller::PakHandler {
+                            read: device::controller::transferpak::read,
+                            write: device::controller::transferpak::write,
+                            pak_type: device::controller::PakType::TransferPak,
+                        };
+                        device.pif.channels[i].pak_handler = Some(tpak_handler);
+                    }
+                }
+            }
+
+            ui::audio::close_game_audio(&mut device.ui);
+            ui::audio::init_game_audio(&mut device.ui, device.ai.freq);
+            ui::video::load_state(device, rdp_state.as_ptr());
+
+            if device.cheats.enabled {
+                cheats::execute_cheats(device, device.cheats.cheats.clone());
+            }
+
+            ui::video::onscreen_message(
+                &device.ui,
+                &format!(
+                    "Savestate loaded from slot {}",
+                    device.ui.storage.save_state_slot
+                ),
+            );
+        } else {
+            ui::video::onscreen_message(
+                &device.ui,
+                &format!(
+                    "Failed to load savestate from slot {}",
+                    device.ui.storage.save_state_slot
+                ),
+            );
+        }
     }
 }
 
@@ -209,11 +237,16 @@ where
     [device::cop0::reserved; N]
 }
 
+pub fn default_memory_read_fast()
+-> [fn(&device::Device, u64, device::memory::AccessSize) -> u32; 0x2000] {
+    [device::unmapped::read_mem_fast; 0x2000]
+}
+
 pub fn default_memory_read()
 -> [fn(&mut device::Device, u64, device::memory::AccessSize) -> u32; 0x2000] {
-    [device::rdram::read_mem; 0x2000]
+    [device::unmapped::read_mem; 0x2000]
 }
 
 pub fn default_memory_write() -> [fn(&mut device::Device, u64, u32, u32); 0x2000] {
-    [device::rdram::write_mem; 0x2000]
+    [device::unmapped::write_mem; 0x2000]
 }

src/ui.rs

@@ -1,43 +1,66 @@
 pub mod audio;
+pub mod cheats;
 pub mod config;
 pub mod gui;
 pub mod input;
+pub mod netplay;
 pub mod storage;
+pub mod usb;
 pub mod video;
 pub mod vru;
 
 pub struct Dirs {
     pub config_dir: std::path::PathBuf,
-    pub cache_dir: std::path::PathBuf,
     pub data_dir: std::path::PathBuf,
 }
 
+pub struct Audio {
+    pub audio_stream: *mut sdl3_sys::audio::SDL_AudioStream,
+    pub gain: f32,
+}
+
+pub struct Input {
+    pub joysticks: Vec<sdl3_sys::joystick::SDL_JoystickID>,
+    pub keyboard_state: *const bool,
+    pub controllers: [input::Controllers; 4],
+}
+
+pub struct Storage {
+    pub save_type: Vec<storage::SaveTypes>,
+    pub paths: storage::Paths,
+    pub saves: storage::Saves,
+    pub save_state_slot: u32,
+}
+
+pub struct Video {
+    pub window: *mut sdl3_sys::video::SDL_Window,
+    pub fullscreen: bool,
+}
+
+pub struct Usb {
+    pub usb_tx: Option<tokio::sync::broadcast::Sender<usb::UsbData>>,
+    pub cart_rx: Option<tokio::sync::broadcast::Receiver<usb::UsbData>>,
+}
+
 pub struct Ui {
     pub dirs: Dirs,
-    pub keyboard_state: *const bool,
-    pub controllers: [input::Controllers; 4],
     pub config: config::Config,
-    pub save_type: Vec<storage::SaveTypes>,
     pub game_id: String,
     pub game_hash: String,
-    pub paths: storage::Paths,
-    pub saves: storage::Saves,
-    pub event_audio: audio::EventAudio,
-    pub window: *mut sdl3_sys::video::SDL_Window,
-    pub audio_stream: *mut sdl3_sys::audio::SDL_AudioStream,
-    pub event_audio_stream: *mut sdl3_sys::audio::SDL_AudioStream,
-    pub audio_device: u32,
-    pub num_joysticks: i32,
-    pub fullscreen: bool,
-    pub joysticks: *mut sdl3_sys::joystick::SDL_JoystickID,
     pub with_sdl: bool,
+    pub audio: Audio,
+    pub input: Input,
+    pub storage: Storage,
+    pub video: Video,
+    pub usb: Usb,
+    pub weak: Option<slint::Weak<gui::AppWindow>>,
 }
 
 impl Drop for Ui {
     fn drop(&mut self) {
         if self.with_sdl {
             unsafe {
-                sdl3_sys::stdinc::SDL_free(self.joysticks as *mut std::ffi::c_void);
+                sdl3_ttf_sys::ttf::TTF_Quit();
                 sdl3_sys::init::SDL_Quit();
             }
         }
@@ -46,12 +69,23 @@ impl Drop for Ui {
 
 pub fn sdl_init(flag: sdl3_sys::init::SDL_InitFlags) {
     unsafe {
-        let init = sdl3_sys::init::SDL_WasInit(0);
-        if init & flag == 0 && !sdl3_sys::init::SDL_InitSubSystem(flag) {
+        if sdl3_sys::init::SDL_WasInit(flag) == 0 && !sdl3_sys::init::SDL_InitSubSystem(flag) {
             let err = std::ffi::CStr::from_ptr(sdl3_sys::error::SDL_GetError())
                 .to_str()
                 .unwrap();
-            panic!("Could not initialize SDL subsystem: {}, {}", flag, err);
+            panic!(
+                "Could not initialize SDL subsystem: {}, {}",
+                u32::from(flag),
+                err
+            );
+        }
+    }
+}
+
+pub fn ttf_init() {
+    unsafe {
+        if !sdl3_ttf_sys::ttf::TTF_Init() {
+            panic!("Could not initialize TTF");
         }
     }
 }
@@ -61,121 +95,115 @@ pub fn get_dirs() -> Dirs {
     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");
     };
 
     Dirs {
         config_dir,
-        cache_dir,
         data_dir,
     }
 }
 
 impl Ui {
-    fn construct_ui(num_joysticks: i32, joysticks: *mut u32, with_sdl: bool) -> Ui {
+    fn construct_ui(joysticks: Vec<sdl3_sys::everything::SDL_JoystickID>, with_sdl: bool) -> Ui {
         let dirs = get_dirs();
 
         Ui {
-            controllers: [
-                input::Controllers {
-                    game_controller: std::ptr::null_mut(),
-                    joystick: std::ptr::null_mut(),
-                    rumble: false,
+            input: Input {
+                controllers: [
+                    input::Controllers {
+                        game_controller: std::ptr::null_mut(),
+                        joystick: std::ptr::null_mut(),
+                        rumble: false,
+                    },
+                    input::Controllers {
+                        game_controller: std::ptr::null_mut(),
+                        joystick: std::ptr::null_mut(),
+                        rumble: false,
+                    },
+                    input::Controllers {
+                        game_controller: std::ptr::null_mut(),
+                        joystick: std::ptr::null_mut(),
+                        rumble: false,
+                    },
+                    input::Controllers {
+                        game_controller: std::ptr::null_mut(),
+                        joystick: std::ptr::null_mut(),
+                        rumble: false,
+                    },
+                ],
+                keyboard_state: std::ptr::null_mut(),
+                joysticks,
+            },
+            storage: Storage {
+                save_state_slot: 0,
+                save_type: vec![],
+                paths: storage::Paths {
+                    eep_file_path: std::path::PathBuf::new(),
+                    fla_file_path: std::path::PathBuf::new(),
+                    sra_file_path: std::path::PathBuf::new(),
+                    pak_file_path: std::path::PathBuf::new(),
+                    sdcard_file_path: std::path::PathBuf::new(),
+                    romsave_file_path: std::path::PathBuf::new(),
+                    savestate_file_path: std::path::PathBuf::new(),
                 },
-                input::Controllers {
-                    game_controller: std::ptr::null_mut(),
-                    joystick: std::ptr::null_mut(),
-                    rumble: false,
+                saves: storage::Saves {
+                    write_to_disk: true,
+                    eeprom: storage::Save {
+                        data: Vec::new(),
+                        write_pending: false,
+                    },
+                    sram: storage::Save {
+                        data: Vec::new(),
+                        write_pending: false,
+                    },
+                    flash: storage::Save {
+                        data: Vec::new(),
+                        write_pending: false,
+                    },
+                    mempak: storage::Save {
+                        data: Vec::new(),
+                        write_pending: false,
+                    },
+                    sdcard: storage::Save {
+                        data: Vec::new(),
+                        write_pending: false,
+                    },
+                    romsave: storage::RomSave {
+                        data: std::collections::HashMap::new(),
+                        write_pending: false,
+                    },
                 },
-                input::Controllers {
-                    game_controller: std::ptr::null_mut(),
-                    joystick: std::ptr::null_mut(),
-                    rumble: false,
-                },
-                input::Controllers {
-                    game_controller: std::ptr::null_mut(),
-                    joystick: std::ptr::null_mut(),
-                    rumble: false,
-                },
-            ],
-            keyboard_state: std::ptr::null_mut(),
+            },
             config: config::Config::new(),
-            save_type: vec![],
             game_id: String::new(),
             game_hash: String::new(),
-            paths: storage::Paths {
-                eep_file_path: std::path::PathBuf::new(),
-                fla_file_path: std::path::PathBuf::new(),
-                sra_file_path: std::path::PathBuf::new(),
-                pak_file_path: std::path::PathBuf::new(),
-                sdcard_file_path: std::path::PathBuf::new(),
-                romsave_file_path: std::path::PathBuf::new(),
-                savestate_file_path: std::path::PathBuf::new(),
+            audio: Audio {
+                audio_stream: std::ptr::null_mut(),
+                gain: 1.0,
             },
-            saves: storage::Saves {
-                write_to_disk: true,
-                eeprom: storage::Save {
-                    data: Vec::new(),
-                    written: false,
-                },
-                sram: storage::Save {
-                    data: Vec::new(),
-                    written: false,
-                },
-                flash: storage::Save {
-                    data: Vec::new(),
-                    written: false,
-                },
-                mempak: storage::Save {
-                    data: Vec::new(),
-                    written: false,
-                },
-                sdcard: storage::Save {
-                    data: Vec::new(),
-                    written: false,
-                },
-                romsave: storage::RomSave {
-                    data: std::collections::HashMap::new(),
-                    written: false,
-                },
+            video: Video {
+                window: std::ptr::null_mut(),
+                fullscreen: false,
             },
-            event_audio: audio::EventAudio {
-                mempak: include_bytes!("../data/mempak.wav").to_vec(),
-                rumblepak: include_bytes!("../data/rumblepak.wav").to_vec(),
-                transferpak: include_bytes!("../data/transferpak.wav").to_vec(),
-                netplay_desync: include_bytes!("../data/netplay_desync.wav").to_vec(),
-                netplay_lost_connection: include_bytes!("../data/netplay_lost_connection.wav")
-                    .to_vec(),
-                netplay_disconnected: [
-                    include_bytes!("../data/netplay_p1_disconnected.wav").to_vec(),
-                    include_bytes!("../data/netplay_p2_disconnected.wav").to_vec(),
-                    include_bytes!("../data/netplay_p3_disconnected.wav").to_vec(),
-                    include_bytes!("../data/netplay_p4_disconnected.wav").to_vec(),
-                ],
+            usb: Usb {
+                usb_tx: None,
+                cart_rx: None,
             },
-            window: std::ptr::null_mut(),
-            audio_stream: std::ptr::null_mut(),
-            event_audio_stream: std::ptr::null_mut(),
-            audio_device: 0,
-            fullscreen: false,
-            num_joysticks,
-            joysticks,
+            weak: None,
             dirs,
             with_sdl,
         }
     }
 
     pub fn default() -> Ui {
-        Self::construct_ui(0, std::ptr::null_mut(), false)
+        Self::construct_ui(vec![], false)
     }
 
     pub fn new() -> Ui {
@@ -185,6 +213,11 @@ impl Ui {
         if joysticks.is_null() {
             panic!("Could not get joystick list");
         }
-        Self::construct_ui(num_joysticks, joysticks, true)
+        let mut joystick_vec = vec![];
+        for i in 0..num_joysticks {
+            joystick_vec.push(unsafe { *joysticks.add(i as usize) });
+        }
+        unsafe { sdl3_sys::stdinc::SDL_free(joysticks as *mut std::ffi::c_void) }
+        Self::construct_ui(joystick_vec, true)
     }
 }

src/ui/audio.rs

@@ -1,130 +1,95 @@
 use crate::device;
-use crate::netplay;
 use crate::ui;
 
-pub struct EventAudio {
-    pub mempak: Vec<u8>,
-    pub rumblepak: Vec<u8>,
-    pub transferpak: Vec<u8>,
-    pub netplay_desync: Vec<u8>,
-    pub netplay_lost_connection: Vec<u8>,
-    pub netplay_disconnected: [Vec<u8>; 4],
-}
-
 pub fn init(ui: &mut ui::Ui, frequency: u64) {
     ui::sdl_init(sdl3_sys::init::SDL_INIT_AUDIO);
+    init_game_audio(ui, frequency);
+}
 
+pub fn init_game_audio(ui: &mut ui::Ui, frequency: u64) {
     let game_audio_spec = sdl3_sys::audio::SDL_AudioSpec {
         format: sdl3_sys::audio::SDL_AUDIO_S16LE,
         freq: frequency as i32,
         channels: 2,
     };
-    let device_audio_spec = sdl3_sys::audio::SDL_AudioSpec {
-        format: sdl3_sys::audio::SDL_AUDIO_S16LE,
-        freq: 48000,
-        channels: 2,
-    };
-    ui.audio_device = unsafe {
-        sdl3_sys::audio::SDL_OpenAudioDevice(
+
+    ui.audio.audio_stream = unsafe {
+        sdl3_sys::audio::SDL_OpenAudioDeviceStream(
             sdl3_sys::audio::SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK,
-            &device_audio_spec,
+            &game_audio_spec,
+            None,
+            std::ptr::null_mut(),
         )
     };
-    if ui.audio_device == 0 {
-        panic!("Could not open audio device");
+    if ui.audio.audio_stream.is_null() {
+        panic!("Could not create audio stream");
     }
-
-    let mut dst = Default::default();
     if !unsafe {
-        sdl3_sys::audio::SDL_GetAudioDeviceFormat(ui.audio_device, &mut dst, std::ptr::null_mut())
+        sdl3_sys::audio::SDL_SetAudioStreamGain(ui.audio.audio_stream, ui.audio.gain)
+            && sdl3_sys::audio::SDL_ResumeAudioStreamDevice(ui.audio.audio_stream)
     } {
-        panic!("Could not get audio device format");
-    }
-
-    ui.audio_stream = unsafe { sdl3_sys::audio::SDL_CreateAudioStream(&game_audio_spec, &dst) };
-    if ui.audio_stream.is_null() {
-        return;
-    }
-    if !unsafe { sdl3_sys::audio::SDL_BindAudioStream(ui.audio_device, ui.audio_stream) } {
-        panic!("Could not bind audio stream");
-    }
-
-    let wav_audio_spec = sdl3_sys::audio::SDL_AudioSpec {
-        format: sdl3_sys::audio::SDL_AUDIO_S16LE,
-        freq: 24000,
-        channels: 1,
-    };
-
-    ui.event_audio_stream =
-        unsafe { sdl3_sys::audio::SDL_CreateAudioStream(&wav_audio_spec, &dst) };
-    if !unsafe { sdl3_sys::audio::SDL_BindAudioStream(ui.audio_device, ui.event_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);
+}
+
+pub fn close_game_audio(ui: &mut ui::Ui) {
     unsafe {
-        if !ui.audio_stream.is_null() {
-            sdl3_sys::audio::SDL_DestroyAudioStream(ui.audio_stream);
-            ui.audio_stream = std::ptr::null_mut();
+        if !ui.audio.audio_stream.is_null() {
+            sdl3_sys::audio::SDL_DestroyAudioStream(ui.audio.audio_stream);
+            ui.audio.audio_stream = std::ptr::null_mut();
         }
-        if !ui.event_audio_stream.is_null() {
-            sdl3_sys::audio::SDL_DestroyAudioStream(ui.event_audio_stream);
-            ui.event_audio_stream = std::ptr::null_mut();
-        }
-        sdl3_sys::audio::SDL_CloseAudioDevice(ui.audio_device);
-        ui.audio_device = 0;
     }
 }
 
-pub fn play_netplay_audio(ui: &mut ui::Ui, error: u32) {
-    if ui.event_audio_stream.is_null() {
-        return;
-    }
-    let sound = match error {
-        netplay::NETPLAY_ERROR_DESYNC => &ui.event_audio.netplay_desync,
-        netplay::NETPLAY_ERROR_LOST_CONNECTION => &ui.event_audio.netplay_lost_connection,
-        netplay::NETPLAY_ERROR_PLAYER_1_DISCONNECTED => &ui.event_audio.netplay_disconnected[0],
-        netplay::NETPLAY_ERROR_PLAYER_2_DISCONNECTED => &ui.event_audio.netplay_disconnected[1],
-        netplay::NETPLAY_ERROR_PLAYER_3_DISCONNECTED => &ui.event_audio.netplay_disconnected[2],
-        netplay::NETPLAY_ERROR_PLAYER_4_DISCONNECTED => &ui.event_audio.netplay_disconnected[3],
-        _ => panic!("Invalid netplay error"),
-    };
-    if !unsafe {
-        sdl3_sys::audio::SDL_PutAudioStreamData(
-            ui.event_audio_stream,
-            sound.as_ptr() as *const std::ffi::c_void,
-            sound.len() as i32,
-        )
-    } {
-        panic!("Could not play audio");
+pub fn lower_audio_volume(ui: &mut ui::Ui) {
+    unsafe {
+        ui.audio.gain = sdl3_sys::audio::SDL_GetAudioStreamGain(ui.audio.audio_stream) - 0.05;
+        if ui.audio.gain < 0.0 {
+            ui.audio.gain = 0.0;
+        }
+        sdl3_sys::audio::SDL_SetAudioStreamGain(ui.audio.audio_stream, ui.audio.gain);
     }
+    ui::video::onscreen_message(ui, &format!("Audio volume: {:.0}%", ui.audio.gain * 100.0));
 }
 
-pub fn play_pak_switch(ui: &mut ui::Ui, pak: device::controller::PakType) {
-    if ui.event_audio_stream.is_null() {
+pub fn raise_audio_volume(ui: &mut ui::Ui) {
+    unsafe {
+        ui.audio.gain = sdl3_sys::audio::SDL_GetAudioStreamGain(ui.audio.audio_stream) + 0.05;
+        if ui.audio.gain > 2.0 {
+            ui.audio.gain = 2.0;
+        }
+        sdl3_sys::audio::SDL_SetAudioStreamGain(ui.audio.audio_stream, ui.audio.gain);
+    }
+    ui::video::onscreen_message(ui, &format!("Audio volume: {:.0}%", ui.audio.gain * 100.0));
+}
+
+fn adjust_audio_frequency(device: &device::Device, frequency: f32) {
+    if !device.vi.enable_speed_limiter {
         return;
     }
 
-    let sound = match pak {
-        device::controller::PakType::RumblePak => &ui.event_audio.rumblepak,
-        device::controller::PakType::MemPak => &ui.event_audio.mempak,
-        device::controller::PakType::TransferPak => &ui.event_audio.transferpak,
-        _ => panic!("Invalid pak type"),
-    };
-    if !unsafe {
-        sdl3_sys::audio::SDL_PutAudioStreamData(
-            ui.event_audio_stream,
-            sound.as_ptr() as *const std::ffi::c_void,
-            sound.len() as i32,
-        )
-    } {
-        panic!("Could not play audio");
+    unsafe {
+        let current_ratio =
+            sdl3_sys::everything::SDL_GetAudioStreamFrequencyRatio(device.ui.audio.audio_stream);
+        sdl3_sys::everything::SDL_SetAudioStreamFrequencyRatio(
+            device.ui.audio.audio_stream,
+            (current_ratio + frequency).clamp(0.995, 1.005),
+        );
+        /*
+        println!(
+            "Adjusted audio frequency ratio to {}",
+            sdl3_sys::everything::SDL_GetAudioStreamFrequencyRatio(device.ui.audio.audio_stream)
+        );
+        */
     }
 }
 
-pub fn play_audio(device: &mut device::Device, dram_addr: usize, length: u64) {
-    if device.ui.audio_stream.is_null() {
+pub fn play_audio(device: &device::Device, dram_addr: usize, length: u64) {
+    if device.ui.audio.audio_stream.is_null() {
         return;
     }
 
@@ -132,42 +97,57 @@ pub fn play_audio(device: &mut device::Device, dram_addr: usize, length: u64) {
     let mut i = 0;
     while i < length as usize / 2 {
         // Left channel
-        primary_buffer[i] = device.rdram.mem[dram_addr + (i * 2) + 2] as i16
-            | ((device.rdram.mem[dram_addr + (i * 2) + 3] as i16) << 8);
+        primary_buffer[i] = *device.rdram.mem.get(dram_addr + (i * 2) + 2).unwrap_or(&0) as i16
+            | ((*device.rdram.mem.get(dram_addr + (i * 2) + 3).unwrap_or(&0) as i16) << 8);
 
         // Right channel
-        primary_buffer[i + 1] = device.rdram.mem[dram_addr + (i * 2)] as i16
-            | ((device.rdram.mem[dram_addr + (i * 2) + 1] as i16) << 8);
+        primary_buffer[i + 1] = *device.rdram.mem.get(dram_addr + (i * 2)).unwrap_or(&0) as i16
+            | ((*device.rdram.mem.get(dram_addr + (i * 2) + 1).unwrap_or(&0) as i16) << 8);
         i += 2;
     }
 
     let audio_queued =
-        unsafe { sdl3_sys::audio::SDL_GetAudioStreamQueued(device.ui.audio_stream) } as f64;
-    let acceptable_latency = (device.ai.freq as f64 * 0.2) * 4.0;
-    let min_latency = (device.ai.freq as f64 * 0.02) * 4.0;
+        unsafe { sdl3_sys::audio::SDL_GetAudioStreamQueued(device.ui.audio.audio_stream) } as f64;
+    let samples_per_frame = device.ai.freq as f64 * device.vi.frame_time * 4.0;
+    let max_latency = samples_per_frame * 8.0;
 
-    if audio_queued < min_latency {
-        let silence_buffer: Vec<u8> = vec![0; min_latency as usize & !3];
+    if audio_queued < samples_per_frame {
+        let silence_buffer: Vec<u8> = vec![0; samples_per_frame as usize & !3];
         if !unsafe {
             sdl3_sys::audio::SDL_PutAudioStreamData(
-                device.ui.audio_stream,
+                device.ui.audio.audio_stream,
                 silence_buffer.as_ptr() as *const std::ffi::c_void,
                 silence_buffer.len() as i32,
             )
         } {
             panic!("Could not play audio");
         }
+        /*
+        println!(
+            "Audio underrun: queued {} samples, expected at least {} samples",
+            audio_queued, samples_per_frame
+        );
+        */
+        adjust_audio_frequency(device, -0.0005);
     }
 
-    if audio_queued < acceptable_latency
-        && !unsafe {
+    if audio_queued < max_latency {
+        if !unsafe {
             sdl3_sys::audio::SDL_PutAudioStreamData(
-                device.ui.audio_stream,
+                device.ui.audio.audio_stream,
                 primary_buffer.as_ptr() as *const std::ffi::c_void,
                 primary_buffer.len() as i32 * 2,
             )
+        } {
+            panic!("Could not play audio");
         }
-    {
-        panic!("Could not play audio");
+    } else {
+        /*
+        println!(
+            "Audio overrun: queued {} samples, expected at most {} samples",
+            audio_queued, max_latency
+        );
+        */
+        adjust_audio_frequency(device, 0.0005);
     }
 }

src/ui/cheats.rs

@@ -0,0 +1,156 @@
+use crate::device;
+use crate::ui;
+use crate::ui::gui::AppWindow;
+use crate::ui::gui::ErrorDialog;
+use slint::ComponentHandle;
+
+#[derive(serde::Serialize, serde::Deserialize, Clone)]
+pub struct CheatData {
+    note: String,
+    pub data: Vec<String>,
+    pub options: Option<std::collections::BTreeMap<String, String>>,
+}
+
+pub type Cheats = std::collections::BTreeMap<String, std::collections::BTreeMap<String, CheatData>>;
+
+pub fn cheats_window(app: &AppWindow) {
+    let weak = app.as_weak();
+    app.on_cheats_select_rom_clicked(move |rom_dir| {
+        let select_rom = if !rom_dir.is_empty()
+            && let Ok(exists) = std::fs::exists(&rom_dir)
+            && exists
+        {
+            rfd::AsyncFileDialog::new().set_directory(rom_dir)
+        } else {
+            rfd::AsyncFileDialog::new()
+        }
+        .set_title("Select ROM")
+        .add_filter("ROM files", &ui::gui::N64_EXTENSIONS)
+        .pick_file();
+        let weak = weak.clone();
+        tokio::spawn(async move {
+            if let Some(file) = select_rom.await
+                && let Some(rom_contents) = device::get_rom_contents(file.path())
+            {
+                let game_crc = ui::storage::get_game_crc(&rom_contents);
+                let game_name = ui::storage::get_game_name(&rom_contents);
+                weak.upgrade_in_event_loop(move |handle| {
+                    handle.set_cheat_game_name(game_name.into());
+                })
+                .unwrap();
+                let cheats: Cheats =
+                    serde_json::from_slice(include_bytes!("../../data/cheats.json")).unwrap();
+                if let Some(cheat) = cheats.get(&game_crc) {
+                    let cheat = cheat.clone();
+                    weak.upgrade_in_event_loop(move |handle| {
+                        let cheat_settings = ui::config::Cheats::new();
+                        let game_cheats = cheat_settings.cheats.get(&game_crc).cloned();
+                        handle.set_cheat_game_crc(game_crc.into());
+                        let cheats_vec = slint::VecModel::default();
+                        for item in cheat.iter() {
+                            let mut cheat_enabled = false;
+                            if let Some(game_cheat) = game_cheats.as_ref()
+                                && game_cheat.contains_key(item.0)
+                            {
+                                cheat_enabled = true;
+                            }
+                            let options_vec = slint::VecModel::default();
+                            if let Some(options) = item.1.options.as_ref() {
+                                for option in options.iter() {
+                                    let mut option_enabled = false;
+                                    if let Some(game_cheat) = game_cheats.as_ref()
+                                        && game_cheat.contains_key(item.0)
+                                        && let Some(opt) = game_cheat.get(item.0)
+                                        && let Some(opt) = opt
+                                        && opt == option.0
+                                    {
+                                        option_enabled = true;
+                                    }
+                                    options_vec.push((option_enabled, option.0.into()));
+                                }
+                            }
+                            let options = slint::ModelRc::from(std::rc::Rc::new(options_vec));
+                            cheats_vec.push((
+                                item.0.clone().into(),
+                                cheat_enabled,
+                                item.1.clone().note.into(),
+                                options,
+                            ));
+                        }
+                        #[allow(clippy::type_complexity)]
+                        let cheats_model: std::rc::Rc<
+                            slint::VecModel<(
+                                slint::SharedString,
+                                bool,
+                                slint::SharedString,
+                                slint::ModelRc<(bool, slint::SharedString)>,
+                            )>,
+                        > = std::rc::Rc::new(cheats_vec);
+                        handle.set_cheats(slint::ModelRc::from(cheats_model));
+                    })
+                    .unwrap();
+                } else {
+                    clear_cheats(&weak, false);
+                }
+            } else {
+                clear_cheats(&weak, true);
+                weak.upgrade_in_event_loop(move |_handle| {
+                    let message_dialog = ErrorDialog::new().unwrap();
+                    let weak_dialog = message_dialog.as_weak();
+                    message_dialog.on_close_clicked(move || {
+                        weak_dialog.unwrap().window().hide().unwrap();
+                    });
+                    message_dialog.set_text("Could not read ROM".into());
+                    message_dialog.show().unwrap();
+                })
+                .unwrap();
+            }
+        });
+    });
+
+    let weak = app.as_weak();
+    app.on_cheats_clear_clicked(move || {
+        let mut cheats = ui::config::Cheats::new();
+        cheats.cheats.clear();
+        clear_cheats(&weak, true);
+    });
+
+    app.on_cheat_toggled(move |game_crc, cheat_name, option, enabled| {
+        let mut cheats = ui::config::Cheats::new();
+        let mut game_cheats = cheats
+            .cheats
+            .remove(&game_crc.to_string())
+            .unwrap_or_default();
+        if enabled {
+            let cheat_option = if option.is_empty() {
+                None
+            } else {
+                Some(option.into())
+            };
+            game_cheats.insert(cheat_name.into(), cheat_option);
+        } else {
+            game_cheats.remove(&cheat_name.to_string());
+        }
+        cheats.cheats.insert(game_crc.into(), game_cheats);
+    });
+}
+
+fn clear_cheats(weak: &slint::Weak<AppWindow>, clear_name: bool) {
+    weak.upgrade_in_event_loop(move |handle| {
+        let cheats_vec = slint::VecModel::default();
+        #[allow(clippy::type_complexity)]
+        let cheats_model: std::rc::Rc<
+            slint::VecModel<(
+                slint::SharedString,
+                bool,
+                slint::SharedString,
+                slint::ModelRc<(bool, slint::SharedString)>,
+            )>,
+        > = std::rc::Rc::new(cheats_vec);
+        handle.set_cheats(slint::ModelRc::from(cheats_model));
+        if clear_name {
+            handle.set_cheat_game_name("".into());
+        }
+    })
+    .unwrap();
+}

src/ui/config.rs

@@ -29,11 +29,12 @@ 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)]
 pub struct Input {
-    pub input_profiles: std::collections::HashMap<String, InputProfile>,
+    pub input_profiles: std::collections::BTreeMap<String, InputProfile>,
     pub input_profile_binding: [String; 4],
     pub controller_assignment: [Option<String>; 4],
     pub controller_enabled: [bool; 4],
@@ -47,11 +48,20 @@ pub struct Video {
     pub integer_scaling: bool,
     pub fullscreen: bool,
     pub widescreen: bool,
+    pub crt: bool,
 }
 
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct Emulation {
     pub overclock: bool,
+    pub disable_expansion_pak: bool,
+    pub usb: bool,
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct Cheats {
+    pub cheats:
+        std::collections::HashMap<String, std::collections::HashMap<String, Option<String>>>,
 }
 
 #[derive(serde::Serialize, serde::Deserialize)]
@@ -59,6 +69,37 @@ pub struct Config {
     pub input: Input,
     pub video: Video,
     pub emulation: Emulation,
+    pub rom_dir: std::path::PathBuf,
+}
+
+impl Drop for Cheats {
+    fn drop(&mut self) {
+        write_cheats(self);
+    }
+}
+
+fn write_cheats(cheats: &Cheats) {
+    let dirs = ui::get_dirs();
+    let file_path = dirs.config_dir.join("cheats.json");
+    let f = std::fs::File::create(file_path).unwrap();
+    serde_json::to_writer_pretty(f, &cheats).unwrap();
+}
+
+impl Cheats {
+    pub fn new() -> Cheats {
+        let dirs = ui::get_dirs();
+        let file_path = dirs.config_dir.join("cheats.json");
+        let cheats_file = std::fs::read(file_path);
+        if let Ok(cheats_file) = cheats_file {
+            let result = serde_json::from_slice(cheats_file.as_ref());
+            if let Ok(result) = result {
+                return result;
+            }
+        }
+        Cheats {
+            cheats: std::collections::HashMap::new(),
+        }
+    }
 }
 
 impl Drop for Config {
@@ -79,13 +120,13 @@ impl Config {
         let dirs = ui::get_dirs();
         let file_path = dirs.config_dir.join("config.json");
         let config_file = std::fs::read(file_path);
-        if config_file.is_ok() {
-            let result = serde_json::from_slice(config_file.unwrap().as_ref());
+        if let Ok(config_file) = config_file {
+            let result = serde_json::from_slice(config_file.as_ref());
             if let Ok(result) = result {
                 return result;
             }
         }
-        let mut input_profiles = std::collections::HashMap::new();
+        let mut input_profiles = std::collections::BTreeMap::new();
         input_profiles.insert("default".to_string(), ui::input::get_default_profile());
         Config {
             input: Input {
@@ -106,8 +147,14 @@ impl Config {
                 integer_scaling: false,
                 fullscreen: false,
                 widescreen: false,
+                crt: false,
             },
-            emulation: Emulation { overclock: false },
+            emulation: Emulation {
+                overclock: false,
+                disable_expansion_pak: false,
+                usb: false,
+            },
+            rom_dir: std::path::PathBuf::new(),
         }
     }
 }

src/ui/gui/about_page.slint

@@ -0,0 +1,98 @@
+// Copyright © SixtyFPS GmbH <info@slint.dev>
+// SPDX-License-Identifier: MIT
+
+import { Button, HorizontalBox, VerticalBox } from "std-widgets.slint";
+import { Page } from "page.slint";
+
+export global AboutData {
+    in property <string> version;
+    in property <bool> has_update;
+}
+
+export component NewVersionButton {
+    callback newversion_button_clicked;
+    HorizontalBox {
+        alignment: center;
+        Button {
+            text: @tr("New version available! Click here to download");
+            primary: true;
+            clicked => {
+                newversion_button_clicked();
+            }
+        }
+    }
+}
+
+export component About inherits Page {
+    callback wiki_button_clicked;
+    callback discord_button_clicked;
+    callback newversion_button_clicked;
+    callback patreon_button_clicked;
+    callback github_sponsors_button_clicked;
+    callback source_code_button_clicked;
+    title: @tr("About");
+
+    VerticalBox {
+        alignment: start;
+        HorizontalBox {
+            alignment: center;
+            Button {
+                text: @tr("Wiki");
+                clicked => {
+                    wiki_button_clicked();
+                }
+            }
+        }
+
+        HorizontalBox {
+            alignment: center;
+            Button {
+                text: @tr("Discord Server");
+                clicked => {
+                    discord_button_clicked();
+                }
+            }
+        }
+
+        HorizontalBox {
+            alignment: center;
+            Button {
+                text: @tr("Source Code");
+                clicked => {
+                    source_code_button_clicked();
+                }
+            }
+        }
+
+        HorizontalBox {
+            alignment: center;
+            Button {
+                text: @tr("Donate (via Patreon)");
+                clicked => {
+                    patreon_button_clicked();
+                }
+            }
+
+            Button {
+                text: @tr("Donate (via GitHub)");
+                clicked => {
+                    github_sponsors_button_clicked();
+                }
+            }
+        }
+
+        HorizontalBox {
+            alignment: center;
+            Text {
+                text: AboutData.version;
+            }
+        }
+
+        if AboutData.has_update:NewVersionButton {
+            newversion_button_clicked => {
+                newversion_button_clicked();
+            }
+        }
+        Rectangle { }
+    }
+}

src/ui/gui/appwindow.slint

@@ -0,0 +1,154 @@
+// Copyright © SixtyFPS GmbH <info@slint.dev>
+// SPDX-License-Identifier: MIT
+
+import { StandardButton } from "std-widgets.slint";
+import { LocalGame, ControllerConfig, Netplay, Cheats, Settings, About } from "pages.slint";
+import { SideBar } from "side_bar.slint";
+import { SettingsData } from "settings_page.slint";
+import { AboutData } from "about_page.slint";
+import { ControllerData } from "controller_page.slint";
+import { State } from "localgame_page.slint";
+import { CheatsData } from "cheat_page.slint";
+export { InputProfileDialog } from "input_profile.slint";
+export { VruDialog } from "vru_dialog.slint";
+export { NetplayCreate } from "netplay_create.slint";
+export { NetplayJoin } from "netplay_join.slint";
+export { NetplayWait } from "netplay_wait.slint";
+export { CustomNetplayServer } from "netplay_page.slint";
+export { DispatcherDialog } from "netplay_create.slint";
+
+export component AppWindow inherits Window {
+    callback wiki_button_clicked;
+    callback discord_button_clicked;
+    callback newversion_button_clicked;
+    callback patreon_button_clicked;
+    callback github_sponsors_button_clicked;
+    callback source_code_button_clicked;
+    callback open_rom_button_clicked;
+    callback saves_folder_button_clicked;
+    callback input_profile_button_clicked;
+    callback create_session_button_clicked;
+    callback join_session_button_clicked;
+    callback netplay_discord_button_clicked;
+    callback netplay_feedback_button_clicked;
+    callback cheats_select_rom_clicked(string);
+    callback cheats_clear_clicked;
+    callback cheat_toggled(string, string, string, bool);
+    in property version <=> AboutData.version;
+    in property has_update <=> AboutData.has_update;
+    in-out property integer_scaling <=> SettingsData.integer_scaling;
+    in-out property fullscreen <=> SettingsData.fullscreen;
+    in-out property widescreen <=> SettingsData.widescreen;
+    in-out property apply_crt_shader <=> SettingsData.apply_crt_shader;
+    in-out property overclock_n64_cpu <=> SettingsData.overclock_n64_cpu;
+    in-out property disable_expansion_pak <=> SettingsData.disable_expansion_pak;
+    in-out property resolution <=> SettingsData.resolution;
+    in-out property emulate_usb <=> SettingsData.emulate_usb;
+    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;
+    in-out property controller_names <=> ControllerData.controller_names;
+    in-out property selected_controller <=> ControllerData.selected_controller;
+    in-out property game_running <=> State.game_running;
+    in-out property blank_profiles <=> ControllerData.blank_profiles;
+    in-out property cheat_game_name <=> CheatsData.cheat_game_name;
+    in-out property cheat_game_crc <=> CheatsData.cheat_game_crc;
+    in-out property cheats <=> CheatsData.cheats;
+    preferred-width: 700px;
+    preferred-height: 500px;
+    title: @tr("Gopher64");
+    icon: @image-url("../../../data/icon/gopher64.png");
+
+    HorizontalLayout {
+        side-bar := SideBar {
+            title: @tr("Gopher64");
+            model: [
+                @tr("Menu" => "Local Game"),
+                @tr("Menu" => "Controller Config"),
+                @tr("Menu" => "Netplay"),
+                @tr("Menu" => "Cheats"),
+                @tr("Menu" => "Settings"),
+                @tr("Menu" => "About")
+            ];
+        }
+
+        if(side-bar.current-item == 0): LocalGame {
+            open_rom_button_clicked => {
+                open_rom_button_clicked();
+            }
+            saves_folder_button_clicked => {
+                saves_folder_button_clicked();
+            }
+            newversion_button_clicked => {
+                newversion_button_clicked();
+            }
+        }
+        if(side-bar.current-item == 1): ControllerConfig {
+            input_profile_button_clicked => {
+                input_profile_button_clicked();
+            }
+        }
+        if(side-bar.current-item == 2): Netplay {
+            create_session_button_clicked => {
+                create_session_button_clicked();
+            }
+            join_session_button_clicked => {
+                join_session_button_clicked();
+            }
+            netplay_discord_button_clicked => {
+                netplay_discord_button_clicked();
+            }
+            netplay_feedback_button_clicked => {
+                netplay_feedback_button_clicked();
+            }
+        }
+        if(side-bar.current-item == 3): Cheats {
+            cheats_select_rom_clicked(rom_dir) => {
+                cheats_select_rom_clicked(rom_dir);
+            }
+            cheats_clear_clicked => {
+                cheats_clear_clicked();
+            }
+            cheat_toggled(game_crc, cheat_name, option, enabled) => {
+                cheat_toggled(game_crc,cheat_name,option,enabled);
+            }
+        }
+        if(side-bar.current-item == 4): Settings { }
+        if(side-bar.current-item == 5): About {
+            wiki_button_clicked => {
+                wiki_button_clicked();
+            }
+            discord_button_clicked => {
+                discord_button_clicked();
+            }
+            newversion_button_clicked => {
+                newversion_button_clicked();
+            }
+            patreon_button_clicked => {
+                patreon_button_clicked();
+            }
+            github_sponsors_button_clicked => {
+                github_sponsors_button_clicked();
+            }
+            source_code_button_clicked => {
+                source_code_button_clicked();
+            }
+        }
+    }
+}
+
+export component ErrorDialog inherits Dialog {
+    in-out property <string> text;
+    title: @tr("Error");
+    Text {
+        text: text;
+    }
+
+    StandardButton {
+        kind: close;
+    }
+}

src/ui/gui/cheat_page.slint

@@ -0,0 +1,90 @@
+// Copyright © SixtyFPS GmbH <info@slint.dev>
+// SPDX-License-Identifier: MIT
+
+import { ListView, HorizontalBox, VerticalBox, Button, GroupBox, CheckBox } from "std-widgets.slint";
+import { Page } from "page.slint";
+import { SettingsData } from "settings_page.slint";
+
+export global CheatsData {
+    in-out property <string> cheat_game_name;
+    in-out property <string> cheat_game_crc;
+    in-out property <[{cheat_name:string, notes:string, enabled:bool, options:[{option:string, enabled:bool}]}]> cheats;
+}
+
+export component Cheats inherits Page {
+    title: @tr("Cheats");
+    callback cheats_select_rom_clicked(string);
+    callback cheats_clear_clicked;
+    callback cheat_toggled(string, string, string, bool);
+
+    VerticalBox {
+        alignment: start;
+        HorizontalBox {
+            alignment: start;
+            if CheatsData.cheat_game_name == "": Button {
+                text: @tr("Select ROM");
+                clicked => {
+                    cheats_select_rom_clicked(SettingsData.rom_dir);
+                }
+            }
+            if CheatsData.cheat_game_name != "": Button {
+                text: CheatsData.cheat_game_name;
+                clicked => {
+                    cheats_select_rom_clicked(SettingsData.rom_dir);
+                }
+            }
+            Rectangle {
+                width: 20px;
+            }
+
+            Button {
+                text: @tr("Clear Cheats For All ROMs");
+                clicked => {
+                    cheats_clear_clicked();
+                }
+            }
+        }
+
+        Rectangle { }
+
+        if CheatsData.cheats.length > 0:ListView {
+            preferred-height: 500px;
+            preferred-width: 520px;
+            for data in CheatsData.cheats: VerticalBox {
+                Text {
+                    text: data.cheat_name;
+                    font-size: 16px;
+                    wrap: word-wrap;
+                }
+
+                if data.notes != "":Text {
+                    text: data.notes;
+                    wrap: word-wrap;
+                }
+
+                if data.options.length == 0: CheckBox {
+                    text: @tr("Enabled");
+                    checked: data.enabled;
+                    toggled => {
+                        data.enabled = self.checked;
+                        cheat_toggled(CheatsData.cheat_game_crc,data.cheat_name,"",self.checked);
+                    }
+                }
+                for item[index] in data.options: CheckBox {
+                    text: item.option;
+                    enabled: !data.enabled || (data.enabled && item.enabled);
+                    checked: item.enabled;
+                    toggled => {
+                        item.enabled = self.checked;
+                        data.enabled = self.checked;
+                        cheat_toggled(CheatsData.cheat_game_crc,data.cheat_name,item.option,self.checked);
+                    }
+                }
+                Rectangle { }
+            }
+        }
+        if CheatsData.cheats.length == 0 && CheatsData.cheat_game_name != "": Text {
+            text: @tr("No Cheats Available");
+        }
+    }
+}

src/ui/gui/controller_page.slint

@@ -0,0 +1,125 @@
+// Copyright © SixtyFPS GmbH <info@slint.dev>
+// SPDX-License-Identifier: MIT
+
+import { CheckBox, ComboBox, Button, HorizontalBox, VerticalBox, GroupBox } from "std-widgets.slint";
+import { Page } from "page.slint";
+import { State } from "localgame_page.slint";
+
+export global ControllerData {
+    in-out property <bool> emulate_vru;
+    in-out property <[bool]> controller_enabled;
+    in-out property <[bool]> transferpak;
+    in-out property <[int]> selected_profile_binding: [-1, -1, -1, -1];
+    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;
+}
+
+export component ControllerConfig inherits Page {
+    callback input_profile_button_clicked;
+    title: @tr("Controller Configuration");
+
+    VerticalBox {
+        alignment: start;
+        HorizontalBox {
+            alignment: start;
+            Button {
+                text: @tr("Configure Input Profile");
+                enabled: !State.game_running;
+                clicked => {
+                    input_profile_button_clicked();
+                }
+            }
+        }
+
+        Rectangle { }
+
+        HorizontalBox {
+            GroupBox {
+                title: @tr("Port");
+                VerticalLayout {
+                    alignment: space-between;
+                    for player in [0, 1, 2, 3]: Text {
+                        text: player + 1;
+                        vertical-alignment: center;
+                    }
+                }
+            }
+
+            GroupBox {
+                title: @tr("Enabled");
+                VerticalLayout {
+                    alignment: space-between;
+                    for player in [0, 1, 2, 3]: CheckBox {
+                        checked: ControllerData.controller_enabled[player];
+                        toggled => {
+                            ControllerData.controller_enabled[player] = self.checked;
+                        }
+                    }
+                }
+            }
+
+            GroupBox {
+                title: @tr("Emulate VRU");
+                VerticalLayout {
+                    alignment: space-between;
+                    for valid in [false, false, false, true]: CheckBox {
+                        enabled: valid;
+                        checked: valid && ControllerData.emulate_vru;
+                        toggled => {
+                            ControllerData.emulate_vru = self.checked;
+                        }
+                    }
+                }
+            }
+
+            GroupBox {
+                title: @tr("Transfer Pak");
+                VerticalLayout {
+                    alignment: space-between;
+                    for player in [0, 1, 2, 3]: CheckBox {
+                        checked: ControllerData.transferpak[player];
+                        toggled => {
+                            ControllerData.transferpak[player] = self.checked;
+                        }
+                    }
+                }
+            }
+
+            if !ControllerData.blank_profiles: GroupBox {
+                title: @tr("Profile");
+                horizontal-stretch: 0.25;
+                VerticalLayout {
+                    alignment: space-between;
+                    for player in [0, 1, 2, 3]: ComboBox {
+                        model: ControllerData.input_profiles;
+                        min-width: self.preferred-width > 150px ? self.preferred-width : 150px;
+                        current-index: ControllerData.selected_profile_binding[player];
+                        selected => {
+                            ControllerData.selected_profile_binding[player] = self.current-index;
+                        }
+                    }
+                }
+            }
+
+            GroupBox {
+                title: @tr("Controller");
+                horizontal-stretch: 0.75;
+                VerticalLayout {
+                    alignment: space-between;
+                    for player in [0, 1, 2, 3]: ComboBox {
+                        model: ControllerData.controller_names;
+                        min-width: self.preferred-width > 300px ? self.preferred-width : 300px;
+                        current-index: ControllerData.selected_controller[player];
+                        selected => {
+                            ControllerData.selected_controller[player] = self.current-index;
+                            ControllerData.controller_changed[player] = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

src/ui/gui/gui_netplay.rs

@@ -1,942 +0,0 @@
-use crate::device;
-use crate::ui::gui::GopherEguiApp;
-use crate::ui::{self, gui};
-use eframe::egui;
-use sha2::{Digest, Sha256};
-
-const NETPLAY_VERSION: i32 = 17;
-const EMU_NAME: &str = "gopher64";
-
-#[derive(Default)]
-pub struct GameInfo {
-    pub md5: String,
-    pub game_name: String,
-    pub rom_label: String,
-    pub rom_contents: Vec<u8>,
-}
-
-#[derive(PartialEq, Default)]
-pub struct NetplayServer {
-    pub name: String,
-    pub ip: String,
-}
-
-#[derive(Default)]
-pub struct GuiNetplay {
-    pub create: bool,
-    pub join: bool,
-    pub wait: bool,
-    pub session_name: String,
-    pub password: String,
-    pub player_name: String,
-    pub error: String,
-    pub create_rom_label: String,
-    pub join_rom_label: String,
-    pub send_chat: bool,
-    pub have_sessions: Option<NetplayServer>,
-    pub begin_game: bool,
-    pub chat_log: String,
-    pub chat_message: String,
-    pub selected_session: Option<NetplayRoom>,
-    pub pending_begin: bool,
-    pub peer_addr: Option<std::net::SocketAddr>,
-    pub motd: String,
-    pub sessions: Vec<NetplayRoom>,
-    pub rom_contents: Vec<u8>,
-    pub player_number: u8,
-    pub player_names: [String; 4],
-    pub server: NetplayServer,
-    pub socket_waiting: bool,
-    pub game_info: GameInfo,
-    pub servers: Vec<NetplayServer>,
-    pub waiting_session: Option<NetplayRoom>,
-    pub socket:
-        Option<tungstenite::WebSocket<tungstenite::stream::MaybeTlsStream<std::net::TcpStream>>>,
-    pub server_receiver:
-        Option<tokio::sync::mpsc::Receiver<std::collections::HashMap<String, String>>>,
-    pub game_info_receiver: Option<tokio::sync::mpsc::Receiver<GameInfo>>,
-    pub broadcast_socket: Option<std::net::UdpSocket>,
-    pub broadcast_timer: Option<std::time::Instant>,
-}
-
-#[derive(serde::Serialize, serde::Deserialize, PartialEq, Default, Clone)]
-pub struct NetplayRoom {
-    room_name: Option<String>,
-    password: Option<String>,
-    protected: Option<bool>,
-    #[serde(rename = "MD5")]
-    md5: Option<String>,
-    game_name: Option<String>,
-    pub port: Option<i32>,
-    features: Option<std::collections::HashMap<String, String>>,
-    buffer_target: Option<i32>,
-}
-
-#[derive(serde::Serialize, serde::Deserialize)]
-pub struct NetplayMessage {
-    #[serde(rename = "type")]
-    message_type: String,
-    player_name: Option<String>,
-    client_sha: Option<String>,
-    netplay_version: Option<i32>,
-    emulator: Option<String>,
-    room: Option<NetplayRoom>,
-    accept: Option<i32>,
-    message: Option<String>,
-    auth: Option<String>,
-    player_names: Option<[String; 4]>,
-    #[serde(rename = "authTime")]
-    auth_time: Option<String>,
-    rooms: Option<Vec<NetplayRoom>>,
-}
-
-fn get_servers(app: &mut GopherEguiApp, ctx: &egui::Context) {
-    if app.netplay.servers.is_empty() {
-        if app.netplay.broadcast_socket.is_none() {
-            app.netplay.broadcast_socket = Some(
-                std::net::UdpSocket::bind((std::net::Ipv4Addr::UNSPECIFIED, 0))
-                    .expect("couldn't bind to address"),
-            );
-            let socket = app.netplay.broadcast_socket.as_ref().unwrap();
-            socket
-                .set_broadcast(true)
-                .expect("set_broadcast call failed");
-            socket
-                .set_nonblocking(true)
-                .expect("could not set up socket");
-            let data: [u8; 1] = [1];
-            socket
-                .send_to(&data, (std::net::Ipv4Addr::BROADCAST, 45000))
-                .expect("couldn't send data");
-            app.netplay.broadcast_timer =
-                Some(std::time::Instant::now() + std::time::Duration::from_secs(5));
-            ctx.request_repaint();
-        }
-        if app.netplay.server_receiver.is_none() {
-            let (tx, rx) = tokio::sync::mpsc::channel(1);
-            app.netplay.server_receiver = Some(rx);
-            let gui_ctx = ctx.clone();
-            let task = reqwest::get("https://m64p.s3.amazonaws.com/servers.json");
-            tokio::spawn(async move {
-                let response = task.await;
-                if let Ok(response) = response {
-                    tx.send(response.json().await.unwrap()).await.unwrap();
-                    gui_ctx.request_repaint();
-                }
-            });
-        }
-    }
-    if app.netplay.broadcast_timer.is_some()
-        && std::time::Instant::now() > app.netplay.broadcast_timer.unwrap()
-    {
-        app.netplay.broadcast_timer = None;
-    }
-    if app.netplay.broadcast_socket.is_some() && app.netplay.broadcast_timer.is_some() {
-        let mut buffer = [0; 1024];
-        let result = app
-            .netplay
-            .broadcast_socket
-            .as_ref()
-            .unwrap()
-            .recv_from(&mut buffer);
-        if result.is_ok() {
-            let (amt, _src) = result.unwrap();
-            let data: std::collections::HashMap<String, String> =
-                serde_json::from_slice(&buffer[..amt]).unwrap();
-            for server in data.iter() {
-                let (server_name, server_ip) = server;
-                app.netplay.servers.push(NetplayServer {
-                    name: server_name.to_string(),
-                    ip: server_ip.to_string(),
-                });
-                app.netplay.server = NetplayServer {
-                    name: server.0.clone(),
-                    ip: server.1.clone(),
-                };
-            }
-            app.netplay.broadcast_socket = None;
-        }
-        ctx.request_repaint();
-    }
-    if app.netplay.server_receiver.is_some() {
-        let result = app.netplay.server_receiver.as_mut().unwrap().try_recv();
-        if result.is_ok() {
-            for server in result.unwrap().iter() {
-                app.netplay.servers.push(NetplayServer {
-                    name: server.0.clone(),
-                    ip: server.1.clone(),
-                });
-            }
-            app.netplay.server_receiver = None;
-            if app.netplay.server.name.is_empty() {
-                let first_server = app.netplay.servers.first().unwrap();
-                app.netplay.server = NetplayServer {
-                    name: first_server.name.clone(),
-                    ip: first_server.ip.clone(),
-                };
-            }
-        }
-        ctx.request_repaint();
-    }
-}
-
-pub fn netplay_create(app: &mut GopherEguiApp, ctx: &egui::Context) {
-    egui::Window::new("Create Netplay Session").show(ctx, |ui| {
-        egui::Grid::new("netplay_create_grid").show(ui, |ui| {
-            let profile_name_label = ui.label("Session Name:");
-            let mut size = ui.spacing().interact_size;
-            size.x = 200.0;
-            ui.add_sized(size, |ui: &mut egui::Ui| {
-                ui.text_edit_singleline(&mut app.netplay.session_name)
-                    .labelled_by(profile_name_label.id)
-            });
-
-            ui.end_row();
-
-            let password_label = ui.label("Password (Optional):");
-
-            ui.text_edit_singleline(&mut app.netplay.password)
-                .labelled_by(password_label.id);
-
-            ui.end_row();
-
-            ui.label("ROM");
-            if app.netplay.create_rom_label.is_empty() {
-                app.netplay.create_rom_label = "Open ROM".to_string();
-            }
-            if ui.button(&app.netplay.create_rom_label).clicked() {
-                let (tx, rx) = tokio::sync::mpsc::channel(1);
-                app.netplay.game_info_receiver = Some(rx);
-                let gui_ctx = ctx.clone();
-                app.netplay.create_rom_label = "Inspecting ROM".to_string();
-                let task = rfd::AsyncFileDialog::new()
-                    .set_title("Select ROM")
-                    .pick_file();
-                tokio::spawn(async move {
-                    let file = task.await;
-
-                    if let Some(file) = file {
-                        parse_rom_file(file, tx).await;
-                    } else {
-                        tx.send(GameInfo {
-                            md5: "".to_string(),
-                            game_name: "".to_string(),
-                            rom_label: "Open ROM".to_string(),
-                            rom_contents: vec![],
-                        })
-                        .await
-                        .unwrap();
-                    }
-                    gui_ctx.request_repaint();
-                });
-            }
-
-            ui.end_row();
-
-            let player_name_label = ui.label("Player Name:");
-
-            ui.text_edit_singleline(&mut app.netplay.player_name)
-                .labelled_by(player_name_label.id);
-
-            ui.end_row();
-
-            ui.label("Server:");
-
-            get_servers(app, ctx);
-
-            if app.netplay.game_info_receiver.is_some() {
-                let result = app.netplay.game_info_receiver.as_mut().unwrap().try_recv();
-                if result.is_ok() {
-                    app.netplay.game_info_receiver = None;
-                    let data = result.unwrap();
-                    if !data.md5.is_empty() {
-                        app.netplay.game_info = data;
-                        app.netplay.rom_contents = app.netplay.game_info.rom_contents.clone();
-                        app.netplay.create_rom_label = app.netplay.game_info.rom_label.clone();
-                    } else {
-                        app.netplay.create_rom_label = data.rom_label;
-                    }
-                }
-                ctx.request_repaint();
-            }
-
-            egui::ComboBox::from_id_salt("server-combobox")
-                .selected_text(app.netplay.server.name.to_string())
-                .show_ui(ui, |ui| {
-                    for server in app.netplay.servers.iter() {
-                        ui.selectable_value(
-                            &mut app.netplay.server,
-                            NetplayServer {
-                                name: server.name.clone(),
-                                ip: server.ip.clone(),
-                            },
-                            server.name.clone(),
-                        );
-                    }
-                });
-
-            ui.end_row();
-
-            if app.netplay.socket_waiting {
-                let data = app.netplay.socket.as_mut().unwrap().read();
-                if data.is_ok() {
-                    let message: NetplayMessage =
-                        serde_json::from_slice(&data.unwrap().into_data()).unwrap();
-                    if message.accept.unwrap() == 0 {
-                        if message.message_type == "reply_create_room" {
-                            app.netplay.create = false;
-                            app.netplay.wait = true;
-                            app.netplay.waiting_session = Some(message.room.unwrap());
-                        }
-                    } else {
-                        app.netplay.error = message.message.unwrap();
-                    }
-                    app.netplay.socket_waiting = false;
-                }
-                ctx.request_repaint();
-            }
-        });
-        ui.horizontal(|ui| {
-            if ui.button("Create Session").clicked() {
-                if app.netplay.player_name.is_empty() {
-                    app.netplay.error = "Player Name cannot be empty".to_string();
-                } else if app.netplay.session_name.is_empty() {
-                    app.netplay.error = "Session Name cannot be empty".to_string();
-                } else if app.netplay.game_info.md5.is_empty() {
-                    app.netplay.error = "ROM not loaded".to_string();
-                } else {
-                    let now_utc = chrono::Utc::now().timestamp_millis().to_string();
-                    let hasher = Sha256::new().chain_update(&now_utc).chain_update(EMU_NAME);
-                    let mut game_name = app.netplay.game_info.game_name.to_string();
-                    if game_name.is_empty() {
-                        // If the ROM doesn't report a name, use the filename
-                        game_name = app.netplay.create_rom_label.clone();
-                    }
-                    let mut features = std::collections::HashMap::new();
-                    features.insert("overclock".to_string(), app.overclock.to_string());
-                    let netplay_message = NetplayMessage {
-                        message_type: "request_create_room".to_string(),
-                        player_name: Some(app.netplay.player_name.clone()),
-                        client_sha: Some(env!("GIT_HASH").to_string()),
-                        netplay_version: Some(NETPLAY_VERSION),
-                        emulator: Some(EMU_NAME.to_string()),
-                        accept: None,
-                        message: None,
-                        rooms: None,
-                        auth_time: Some(now_utc),
-                        player_names: None,
-                        auth: Some(format!("{:x}", hasher.finalize())),
-                        room: Some(NetplayRoom {
-                            room_name: Some(app.netplay.session_name.clone()),
-                            password: Some(app.netplay.password.clone()),
-                            game_name: Some(game_name),
-                            md5: Some(app.netplay.game_info.md5.clone()),
-                            protected: None,
-                            port: None,
-                            features: Some(features),
-                            buffer_target: Some(2),
-                        }),
-                    };
-                    let (mut socket, _response) =
-                        tungstenite::connect(&app.netplay.server.ip).expect("Can't connect");
-                    socket
-                        .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
-                            serde_json::to_vec(&netplay_message).unwrap(),
-                        )))
-                        .unwrap();
-                    match socket.get_mut() {
-                        tungstenite::stream::MaybeTlsStream::Plain(stream) => {
-                            app.netplay.peer_addr = Some(stream.peer_addr().unwrap());
-                            stream.set_nonblocking(true)
-                        }
-                        _ => unimplemented!(),
-                    }
-                    .expect("could not set socket to non-blocking");
-                    app.netplay.socket_waiting = true;
-                    app.netplay.socket = Some(socket);
-                }
-            }
-
-            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                if ui.button("Close").clicked() {
-                    if let Some(socket) = app.netplay.socket.as_mut() {
-                        socket.close(None).unwrap();
-                        loop {
-                            match socket.read() {
-                                Err(tungstenite::Error::ConnectionClosed) => break,
-                                _ => continue,
-                            };
-                        }
-                    }
-                    app.netplay = Default::default();
-                };
-            })
-        });
-    });
-}
-
-fn get_sessions(app: &mut GopherEguiApp, ctx: &egui::Context) {
-    if app.netplay.have_sessions.is_some()
-        && app.netplay.server != *app.netplay.have_sessions.as_ref().unwrap()
-    {
-        // User has changed the server
-        app.netplay.have_sessions = None;
-        app.netplay.socket = None;
-    }
-    if app.netplay.socket.is_none() {
-        let (mut sock, _response) =
-            tungstenite::connect(&app.netplay.server.ip).expect("Can't connect");
-        match sock.get_mut() {
-            tungstenite::stream::MaybeTlsStream::Plain(stream) => {
-                app.netplay.peer_addr = Some(stream.peer_addr().unwrap());
-                stream.set_nonblocking(true)
-            }
-            _ => unimplemented!(),
-        }
-        .expect("could not set socket to non-blocking");
-        app.netplay.socket = Some(sock);
-    }
-    let socket = app.netplay.socket.as_mut().unwrap();
-    if app.netplay.have_sessions.is_none() {
-        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,
-        };
-
-        socket
-            .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
-                serde_json::to_vec(&request_rooms).unwrap(),
-            )))
-            .unwrap();
-        app.netplay.have_sessions = Some(NetplayServer {
-            name: app.netplay.server.name.clone(),
-            ip: app.netplay.server.ip.clone(),
-        });
-        app.netplay.socket_waiting = true;
-        ctx.request_repaint();
-    }
-}
-
-async fn parse_rom_file(file: rfd::FileHandle, tx: tokio::sync::mpsc::Sender<GameInfo>) {
-    let rom_contents = device::get_rom_contents(file.path());
-    if !rom_contents.is_empty() {
-        let hash = device::cart::rom::calculate_hash(&rom_contents);
-        let game_name = ui::storage::get_game_name(&rom_contents);
-
-        tx.send(GameInfo {
-            md5: hash,
-            game_name,
-            rom_label: file.file_name(),
-            rom_contents,
-        })
-        .await
-        .unwrap();
-    } else {
-        tx.send(GameInfo {
-            md5: "".to_string(),
-            game_name: "".to_string(),
-            rom_label: "Invalid ROM".to_string(),
-            rom_contents: vec![],
-        })
-        .await
-        .unwrap();
-    }
-}
-
-pub fn netplay_join(app: &mut GopherEguiApp, ctx: &egui::Context) {
-    if app.netplay.socket_waiting {
-        let socket = app.netplay.socket.as_mut().unwrap();
-        let data = socket.read();
-        if data.is_ok() {
-            let message: NetplayMessage =
-                serde_json::from_slice(&data.unwrap().into_data()).unwrap();
-            if message.accept.unwrap() == 0 {
-                if message.message_type == "reply_get_rooms" {
-                    if message.rooms.is_some() {
-                        app.netplay.sessions = message.rooms.unwrap();
-                    }
-                } else if message.message_type == "reply_join_room" {
-                    app.netplay.join = false;
-                    app.netplay.wait = true;
-                    app.netplay.waiting_session = Some(message.room.unwrap());
-                }
-                app.netplay.socket_waiting = false;
-            } else {
-                app.netplay.error = message.message.unwrap();
-                app.netplay.join_rom_label = "Join Session (Open ROM)".to_string();
-            }
-        }
-        ctx.request_repaint();
-    }
-    if app.netplay.game_info_receiver.is_some() {
-        let result = app.netplay.game_info_receiver.as_mut().unwrap().try_recv();
-        if result.is_ok() {
-            app.netplay.game_info_receiver = None;
-            let data = result.unwrap();
-            if !data.md5.is_empty() {
-                app.netplay.game_info = data;
-                app.netplay.rom_contents = app.netplay.game_info.rom_contents.clone();
-
-                let netplay_message = NetplayMessage {
-                    message_type: "request_join_room".to_string(),
-                    player_name: Some(app.netplay.player_name.clone()),
-                    client_sha: Some(env!("GIT_HASH").to_string()),
-                    netplay_version: None,
-                    emulator: None,
-                    accept: None,
-                    message: None,
-                    rooms: None,
-                    auth_time: None,
-                    player_names: None,
-                    auth: None,
-                    room: Some(NetplayRoom {
-                        room_name: None,
-                        password: Some(app.netplay.password.clone()),
-                        game_name: None,
-                        md5: Some(app.netplay.game_info.md5.clone()),
-                        protected: None,
-                        port: app.netplay.selected_session.as_ref().unwrap().port,
-                        features: None,
-                        buffer_target: None,
-                    }),
-                };
-                let socket = app.netplay.socket.as_mut().unwrap();
-                socket
-                    .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
-                        serde_json::to_vec(&netplay_message).unwrap(),
-                    )))
-                    .unwrap();
-
-                app.netplay.socket_waiting = true;
-            } else {
-                app.netplay.error = data.rom_label;
-                app.netplay.join_rom_label = "Join Session (Open ROM)".to_string();
-            }
-        }
-        ctx.request_repaint();
-    }
-    egui::Window::new("Join Netplay Session").show(ctx, |ui| {
-        ui.horizontal(|ui| {
-            let mut size = ui.spacing().interact_size;
-            size.x = 100.0;
-            ui.add_sized(
-                size,
-                egui::TextEdit::singleline(&mut app.netplay.player_name).hint_text("Player name"),
-            );
-
-            get_servers(app, ctx);
-
-            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                if ui.button("Refresh").clicked() {
-                    app.netplay.socket = None;
-                    app.netplay.have_sessions = None;
-                    app.netplay.selected_session = None;
-                    ctx.request_repaint();
-                }
-                egui::ComboBox::from_id_salt("server-combobox")
-                    .selected_text(app.netplay.server.name.to_string())
-                    .show_ui(ui, |ui| {
-                        for server in app.netplay.servers.iter() {
-                            ui.selectable_value(
-                                &mut app.netplay.server,
-                                NetplayServer {
-                                    name: server.name.clone(),
-                                    ip: server.ip.clone(),
-                                },
-                                server.name.clone(),
-                            );
-                        }
-                    });
-            });
-        });
-        if !app.netplay.server.name.is_empty() {
-            get_sessions(app, ctx);
-        }
-        ui.add_space(16.0);
-        if app.netplay.sessions.is_empty() {
-            ui.label("No sessions available");
-        } else {
-            egui::Grid::new("netplay_join_grid").show(ui, |ui| {
-                ui.label(egui::RichText::new("Session Name (click to select)").underline());
-                ui.label(egui::RichText::new("Game Name").underline());
-                ui.label(egui::RichText::new("Password Protected").underline());
-                ui.end_row();
-
-                for room in app.netplay.sessions.iter() {
-                    ui.selectable_value(
-                        &mut app.netplay.selected_session,
-                        Some(room.clone()),
-                        room.room_name.as_ref().unwrap(),
-                    );
-                    ui.label(room.game_name.as_ref().unwrap());
-                    ui.label(room.protected.unwrap_or(false).to_string());
-                    ui.end_row();
-                }
-            });
-        }
-        ui.add_space(16.0);
-        ui.horizontal(|ui| {
-            let mut size = ui.spacing().interact_size;
-            size.x = 130.0;
-            ui.add_sized(
-                size,
-                egui::TextEdit::singleline(&mut app.netplay.password)
-                    .hint_text("Password (if required)"),
-            );
-            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                if ui.button("Close").clicked() {
-                    if let Some(socket) = app.netplay.socket.as_mut() {
-                        socket.close(None).unwrap();
-                        loop {
-                            match socket.read() {
-                                Err(tungstenite::Error::ConnectionClosed) => break,
-                                _ => continue,
-                            };
-                        }
-                    }
-                    app.netplay = Default::default();
-                };
-                if app.netplay.join_rom_label.is_empty() {
-                    app.netplay.join_rom_label = "Join Session (Open ROM)".to_string();
-                }
-                if ui.button(&app.netplay.join_rom_label).clicked() {
-                    if app.netplay.player_name.is_empty() {
-                        app.netplay.error = "Player Name cannot be empty".to_string();
-                    } else if app.netplay.selected_session.is_none() {
-                        app.netplay.error = "No session selected".to_string();
-                    } else if app
-                        .netplay
-                        .selected_session
-                        .as_ref()
-                        .unwrap()
-                        .protected
-                        .unwrap()
-                        && app.netplay.password.is_empty()
-                    {
-                        app.netplay.error = "Session requires a password".to_string();
-                    } else {
-                        let (tx, rx) = tokio::sync::mpsc::channel(1);
-                        app.netplay.game_info_receiver = Some(rx);
-                        let gui_ctx = ctx.clone();
-                        app.netplay.join_rom_label = "Inspecting ROM".to_string();
-                        let task = rfd::AsyncFileDialog::new()
-                            .set_title("Select ROM")
-                            .pick_file();
-                        tokio::spawn(async move {
-                            let file = task.await;
-
-                            if let Some(file) = file {
-                                parse_rom_file(file, tx).await;
-                            } else {
-                                tx.send(GameInfo {
-                                    md5: "".to_string(),
-                                    game_name: "".to_string(),
-                                    rom_label: "No ROM selected".to_string(),
-                                    rom_contents: vec![],
-                                })
-                                .await
-                                .unwrap();
-                            }
-                            gui_ctx.request_repaint();
-                        });
-                    }
-                };
-            });
-        });
-    });
-}
-
-pub fn netplay_wait(app: &mut GopherEguiApp, ctx: &egui::Context) {
-    let overclock = app
-        .netplay
-        .waiting_session
-        .as_ref()
-        .unwrap()
-        .features
-        .as_ref()
-        .unwrap()
-        .get("overclock")
-        .unwrap();
-
-    let motd_message = NetplayMessage {
-        message_type: "request_motd".to_string(),
-        player_name: None,
-        client_sha: None,
-        netplay_version: None,
-        emulator: None,
-        accept: None,
-        rooms: None,
-        player_names: None,
-        message: None,
-        auth_time: None,
-        auth: None,
-        room: None,
-    };
-    let request_players = NetplayMessage {
-        message_type: "request_players".to_string(),
-        player_name: None,
-        client_sha: None,
-        netplay_version: None,
-        player_names: None,
-        emulator: None,
-        rooms: None,
-        accept: None,
-        message: None,
-        auth_time: None,
-        auth: None,
-        room: Some(NetplayRoom {
-            room_name: None,
-            password: None,
-            game_name: None,
-            md5: None,
-            protected: None,
-            port: app.netplay.waiting_session.as_ref().unwrap().port,
-            features: None,
-            buffer_target: None,
-        }),
-    };
-
-    if !app.netplay.socket_waiting {
-        let socket = app.netplay.socket.as_mut().unwrap();
-        socket
-            .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
-                serde_json::to_vec(&motd_message).unwrap(),
-            )))
-            .unwrap();
-        socket
-            .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
-                serde_json::to_vec(&request_players).unwrap(),
-            )))
-            .unwrap();
-        app.netplay.socket_waiting = true;
-    }
-
-    if app.netplay.begin_game {
-        let begin_game = NetplayMessage {
-            message_type: "request_begin_game".to_string(),
-            player_name: None,
-            client_sha: None,
-            netplay_version: None,
-            player_names: None,
-            rooms: None,
-            emulator: None,
-            accept: None,
-            message: None,
-            auth_time: None,
-            auth: None,
-            room: Some(NetplayRoom {
-                room_name: None,
-                password: None,
-                game_name: None,
-                md5: None,
-                protected: None,
-                port: app.netplay.waiting_session.as_ref().unwrap().port,
-                features: None,
-                buffer_target: None,
-            }),
-        };
-        let socket = app.netplay.socket.as_mut().unwrap();
-        socket
-            .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
-                serde_json::to_vec(&begin_game).unwrap(),
-            )))
-            .unwrap();
-        app.netplay.begin_game = false;
-    }
-
-    if app.netplay.send_chat {
-        let send_chat = NetplayMessage {
-            message_type: "request_chat_message".to_string(),
-            player_name: Some(app.netplay.player_name.clone()),
-            client_sha: None,
-            netplay_version: None,
-            player_names: None,
-            rooms: None,
-            emulator: None,
-            accept: None,
-            message: Some(app.netplay.chat_message.clone()),
-            auth_time: None,
-            auth: None,
-            room: Some(NetplayRoom {
-                room_name: None,
-                password: None,
-                game_name: None,
-                md5: None,
-                protected: None,
-                port: app.netplay.waiting_session.as_ref().unwrap().port,
-                features: None,
-                buffer_target: None,
-            }),
-        };
-        app.netplay.chat_message.clear();
-        let socket = app.netplay.socket.as_mut().unwrap();
-        socket
-            .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
-                serde_json::to_vec(&send_chat).unwrap(),
-            )))
-            .unwrap();
-        app.netplay.send_chat = false;
-    }
-
-    if app.netplay.socket_waiting {
-        let socket = app.netplay.socket.as_mut().unwrap();
-        let data = socket.read();
-        if data.is_ok() {
-            let message: NetplayMessage =
-                serde_json::from_slice(&data.unwrap().into_data()).unwrap();
-            if message.accept.unwrap() == 0 {
-                if message.message_type == "reply_motd" {
-                    let re = regex::Regex::new(r"<[^>]*>").unwrap();
-                    app.netplay.motd = re
-                        .replace_all(message.message.unwrap().as_str(), "")
-                        .into_owned();
-                } else if message.message_type == "reply_players" {
-                    app.netplay.player_names = message.player_names.unwrap();
-                } else if message.message_type == "reply_chat_message" {
-                    app.netplay.chat_log.push_str(&message.message.unwrap());
-                    app.netplay.chat_log.push('\n');
-                } else if message.message_type == "reply_begin_game" {
-                    let mut player = 0;
-                    for (i, name) in app.netplay.player_names.iter().enumerate() {
-                        if *name == app.netplay.player_name {
-                            player = i;
-                            break;
-                        }
-                    }
-                    app.netplay.player_number = player as u8;
-
-                    if message.accept.unwrap() == 0 {
-                        socket.close(None).unwrap();
-                        loop {
-                            match socket.read() {
-                                Err(tungstenite::Error::ConnectionClosed) => break,
-                                _ => continue,
-                            };
-                        }
-
-                        gui::open_rom(app, ctx, *overclock == "true");
-                        app.netplay = Default::default();
-                        return;
-                    } else {
-                        app.netplay.error = message.message.unwrap();
-                    }
-                }
-            } else {
-                app.netplay.error = message.message.unwrap();
-            }
-        }
-        ctx.request_repaint();
-    }
-
-    egui::Window::new("Pending Netplay Session").show(ctx, |ui| {
-        egui::Grid::new("netplay_wait_grid_1").show(ui, |ui| {
-            ui.label("Session Name:");
-            let room_name = app
-                .netplay
-                .waiting_session
-                .as_ref()
-                .unwrap()
-                .room_name
-                .as_ref()
-                .unwrap();
-            let game_name = app
-                .netplay
-                .waiting_session
-                .as_ref()
-                .unwrap()
-                .game_name
-                .as_ref()
-                .unwrap();
-            ui.label(room_name);
-            ui.end_row();
-            ui.label("Game Name:");
-            ui.label(game_name);
-            ui.end_row();
-            for i in 0..4 {
-                ui.label(format!("Player {}:", i + 1));
-                ui.label(app.netplay.player_names[i].clone());
-                ui.end_row();
-            }
-        });
-        egui::ScrollArea::vertical()
-            .max_height(100.0)
-            .stick_to_bottom(true)
-            .show(ui, |ui| {
-                ui.add(
-                    egui::TextEdit::multiline(&mut app.netplay.chat_log)
-                        .interactive(false)
-                        .desired_width(ui.available_width()),
-                );
-            });
-
-        ui.horizontal(|ui| {
-            let mut size = ui.spacing().interact_size;
-            size.x = 200.0;
-
-            ui.add_sized(
-                size,
-                egui::TextEdit::singleline(&mut app.netplay.chat_message)
-                    .hint_text("Enter chat message here"),
-            );
-
-            if ui
-                .add_enabled(!app.netplay.send_chat, egui::Button::new("Send Message"))
-                .clicked()
-                && !app.netplay.chat_message.is_empty()
-            {
-                app.netplay.send_chat = true;
-            }
-        });
-
-        ui.add_space(16.0);
-        ui.label(app.netplay.motd.clone());
-        ui.add_space(16.0);
-
-        ui.horizontal(|ui| {
-            let button_enabled = app.netplay.player_name == app.netplay.player_names[0]
-                && !app.netplay.pending_begin;
-            if ui
-                .add_enabled(button_enabled, egui::Button::new("Start Session"))
-                .clicked()
-            {
-                app.netplay.begin_game = true;
-                app.netplay.pending_begin = true;
-            }
-            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                if ui.button("Close").clicked() {
-                    if let Some(socket) = app.netplay.socket.as_mut() {
-                        socket.close(None).unwrap();
-                        loop {
-                            match socket.read() {
-                                Err(tungstenite::Error::ConnectionClosed) => break,
-                                _ => continue,
-                            };
-                        }
-                    }
-                    app.netplay = Default::default();
-                };
-            });
-        });
-    });
-}
-
-pub fn netplay_error(app: &mut GopherEguiApp, ctx: &egui::Context, error: String) {
-    egui::Window::new("Netplay Error").show(ctx, |ui| {
-        ui.label(error);
-        if ui.button("Close").clicked() {
-            app.netplay.error = "".to_string();
-        };
-    });
-}

src/ui/gui/input_profile.slint

@@ -0,0 +1,69 @@
+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 {
+    title: @tr("Create Input Profile");
+    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 {
+                placeholder-text: @tr("Enter profile name");
+                preferred-width: 300px;
+                edited(text) => {
+                    InputProfileData.profile_name = text;
+                }
+            }
+        }
+
+        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 {
+                text: @tr("Use DirectInput");
+                checked: InputProfileData.dinput;
+                toggled => {
+                    InputProfileData.dinput = self.checked;
+                }
+            }
+        }
+
+        HorizontalBox {
+            Button {
+                text: @tr("Start Profile Creation Wizard");
+                enabled: InputProfileData.profile_name != "" && InputProfileData.profile_name != "default";
+                clicked => {
+                    profile_creation_button_clicked();
+                }
+            }
+        }
+    }
+}

src/ui/gui/localgame_page.slint

@@ -0,0 +1,48 @@
+// Copyright © SixtyFPS GmbH <info@slint.dev>
+// SPDX-License-Identifier: MIT
+
+import { Button, HorizontalBox, VerticalBox } from "std-widgets.slint";
+import { Page } from "page.slint";
+import { AboutData, NewVersionButton } from "about_page.slint";
+
+export global State {
+    in-out property <bool> game_running;
+}
+
+export component LocalGame inherits Page {
+    callback open_rom_button_clicked;
+    callback saves_folder_button_clicked;
+    callback newversion_button_clicked;
+    title: @tr("Local Game");
+
+    VerticalBox {
+        alignment: start;
+        HorizontalBox {
+            alignment: center;
+            Button {
+                text: @tr("Open ROM");
+                enabled: !State.game_running;
+                clicked => {
+                    open_rom_button_clicked();
+                }
+            }
+        }
+
+        HorizontalBox {
+            alignment: center;
+            Button {
+                text: @tr("Open Saves Folder");
+                clicked => {
+                    saves_folder_button_clicked();
+                }
+            }
+        }
+
+        if AboutData.has_update:NewVersionButton {
+            newversion_button_clicked => {
+                newversion_button_clicked();
+            }
+        }
+        Rectangle { }
+    }
+}

src/ui/gui/netplay_create.slint

@@ -0,0 +1,130 @@
+import { LineEdit, HorizontalBox, VerticalBox, Button, ComboBox } from "std-widgets.slint";
+import { NetplayData } from "netplay_page.slint";
+
+export component NetplayCreate inherits Window {
+    title: @tr("Netplay: Create Session");
+    in-out property server_names <=> NetplayData.server_names;
+    in-out property server_urls <=> NetplayData.server_urls;
+    in-out property custom_server_url <=> NetplayData.custom_server_url;
+    in-out property game_name <=> NetplayData.game_name;
+    in-out property game_hash <=> NetplayData.game_hash;
+    in-out property game_cheats <=> NetplayData.game_cheats;
+    in-out property pending_session <=> NetplayData.pending_session;
+    in-out property rom_path <=> NetplayData.rom_path;
+    in-out property peer_addr <=> NetplayData.peer_addr;
+    in-out property rom_dir <=> NetplayData.rom_dir;
+    callback get_custom_url();
+    callback select_rom(string);
+    callback create_session(string, string, string, string, string, string, string);
+
+    VerticalBox {
+        HorizontalBox {
+            VerticalBox {
+                Text {
+                    text: @tr("Session Name:");
+                }
+
+                LineEdit {
+                    placeholder_text: @tr("Enter session name");
+                    edited(text) => {
+                        NetplayData.session_name = text;
+                    }
+                }
+            }
+
+            VerticalBox {
+                Text {
+                    text: @tr("Password (Optional):");
+                }
+
+                LineEdit {
+                    placeholder_text: @tr("Enter session password");
+                    edited(text) => {
+                        NetplayData.password = text;
+                    }
+                }
+            }
+        }
+
+        VerticalBox {
+            Text {
+                text: @tr("Player Name:");
+            }
+
+            LineEdit {
+                placeholder_text: @tr("Enter player name");
+                edited(text) => {
+                    NetplayData.player_name = text;
+                }
+            }
+        }
+
+        VerticalBox {
+            Text {
+                text: @tr("Server:");
+            }
+
+            HorizontalBox {
+                server := ComboBox {
+                    model: NetplayData.server_names;
+                    selected => {
+                        if (self.current-index >= 0) {
+                            if (self.current-value == "Custom") {
+                                get_custom_url();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if NetplayData.game_name == "": Button {
+            text: @tr("Select ROM");
+            clicked => {
+                select_rom(NetplayData.rom_dir);
+            }
+        }
+        if NetplayData.game_name != "": Button {
+            text: NetplayData.game_name;
+            clicked => {
+                select_rom(NetplayData.rom_dir);
+            }
+        }
+
+        Rectangle { }
+
+        if NetplayData.game_cheats != "":Text {
+            text: @tr("This game has cheats enabled. Cheats will be synchronized with other players.");
+        }
+        Rectangle { }
+
+        Button {
+            property <string> server_url;
+            text: @tr("Create Session");
+            enabled: NetplayData.session_name != "" && NetplayData.player_name != "" && NetplayData.game_name != "" && !NetplayData.pending_session;
+            clicked => {
+                NetplayData.pending_session = true;
+                if (server.current-value == "Custom") {
+                    server_url = "ws://" + NetplayData.custom_server_url;
+                } else {
+                    server_url = NetplayData.server_urls[server.current-index];
+                }
+                create_session(
+                    server_url,
+                    NetplayData.session_name,
+                    NetplayData.player_name,
+                    NetplayData.game_name,
+                    NetplayData.game_hash,
+                    NetplayData.game_cheats,
+                    NetplayData.password);
+            }
+        }
+    }
+}
+
+export component DispatcherDialog inherits Dialog {
+    title: @tr("Creating Server");
+    Text {
+        text: "Creating server, please wait...This may take about 30 seconds.";
+    }
+}

src/ui/gui/netplay_join.slint

@@ -0,0 +1,139 @@
+import { VerticalBox, LineEdit, StandardTableView, HorizontalBox, ComboBox, Button } from "std-widgets.slint";
+import { NetplayData } from "netplay_page.slint";
+
+export component NetplayJoin inherits Window {
+    title: @tr("Netplay: Join Session");
+    in-out property server_names <=> NetplayData.server_names;
+    in-out property server_urls <=> NetplayData.server_urls;
+    in-out property custom_server_url <=> NetplayData.custom_server_url;
+    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;
+    in-out property peer_addr <=> NetplayData.peer_addr;
+    in-out property pending_session <=> NetplayData.pending_session;
+    in-out property pending_refresh <=> NetplayData.pending_refresh;
+    in-out property rom_path <=> NetplayData.rom_path;
+    in-out property rom_dir <=> NetplayData.rom_dir;
+    callback refresh_session();
+    callback select_rom(string);
+    callback join_session(string, string, string, string, int);
+    preferred-width: 700px;
+
+    VerticalBox {
+        HorizontalBox {
+            VerticalBox {
+                Text {
+                    text: @tr("Player Name:");
+                }
+
+                LineEdit {
+                    placeholder_text: @tr("Enter player name");
+                    edited(text) => {
+                        NetplayData.player_name = text;
+                    }
+                }
+            }
+
+            VerticalBox {
+                Text {
+                    text: @tr("Custom Server URL (optional):");
+                }
+
+                LineEdit {
+                    placeholder-text: @tr("example.com:45000");
+                    text: NetplayData.custom_server_url;
+                    edited(text) => {
+                        NetplayData.custom_server_url = text;
+                    }
+                }
+            }
+        }
+
+        if NetplayData.pending_refresh: Text {
+            text: @tr("Refreshing session list, please wait...");
+            horizontal-alignment: center;
+            vertical-alignment: center;
+        }
+        if !NetplayData.pending_refresh && NetplayData.sessions.length > 0: Text {
+            text: @tr("Click on a session below to select it");
+            horizontal-alignment: center;
+            vertical-alignment: center;
+        }
+        if !NetplayData.pending_refresh && NetplayData.sessions.length == 0: Text {
+            text: @tr("No sessions available. Please refresh to check again.");
+            horizontal-alignment: center;
+            vertical-alignment: center;
+        }
+        StandardTableView {
+            columns: [
+                { title: "Server" },
+                { title: "Session Name" },
+                { title: "Game Name" },
+                { title: "Password" },
+                { title: "Cheats" }
+            ];
+            rows: NetplayData.sessions;
+            current-row: NetplayData.current_session;
+            current-row-changed(current-row) => {
+                NetplayData.current_session = current-row;
+            }
+        }
+
+        HorizontalBox {
+            Rectangle { }
+
+            Button {
+                enabled: !NetplayData.pending_refresh;
+                text: @tr("Refresh Session List");
+                clicked => {
+                    NetplayData.pending_refresh = true;
+                    NetplayData.current_session = -1;
+                    NetplayData.sessions = [];
+                    NetplayData.room_urls = [];
+                    NetplayData.room_ports = [];
+                    refresh_session();
+                }
+            }
+        }
+
+        HorizontalBox {
+            LineEdit {
+                placeholder-text: @tr("Password (if required)");
+                edited(text) => {
+                    NetplayData.password = text;
+                }
+            }
+
+            if NetplayData.game_name == "": Button {
+                text: @tr("Select ROM");
+                clicked => {
+                    select_rom(NetplayData.rom_dir);
+                }
+            }
+            if NetplayData.game_name != "": Button {
+                text: NetplayData.game_name;
+                clicked => {
+                    select_rom(NetplayData.rom_dir);
+                }
+            }
+
+            Button {
+                text: @tr("Join Session");
+                enabled: NetplayData.player_name != "" && NetplayData.current_session >= 0 && NetplayData.game_name != "" && !NetplayData.pending_session;
+                clicked => {
+                    NetplayData.pending_session = true;
+                    join_session(
+                    NetplayData.player_name,
+                    NetplayData.game_hash,
+                    NetplayData.password,
+                    NetplayData.room_urls[NetplayData.current_session],
+                    NetplayData.room_ports[NetplayData.current_session]);
+                }
+            }
+        }
+    }
+}

src/ui/gui/netplay_page.slint

@@ -0,0 +1,97 @@
+// Copyright © SixtyFPS GmbH <info@slint.dev>
+// SPDX-License-Identifier: MIT
+
+import { StandardButton, VerticalBox, HorizontalBox, Button, LineEdit } from "std-widgets.slint";
+import { Page } from "page.slint";
+
+export global NetplayData {
+    in-out property <[string]> server_names;
+    in-out property <[string]> server_urls;
+    in-out property <string> player_name;
+    in-out property <string> game_name;
+    in-out property <string> game_hash;
+    in-out property <string> game_cheats;
+    in-out property <string> rom_path;
+    in-out property <string> password;
+    in-out property <string> peer_addr;
+    in-out property <bool> pending_session;
+    in-out property <bool> pending_refresh;
+    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;
+}
+
+export component Netplay inherits Page {
+    callback create_session_button_clicked;
+    callback join_session_button_clicked;
+    callback netplay_discord_button_clicked;
+    callback netplay_feedback_button_clicked;
+    title: @tr("Netplay");
+
+    VerticalBox {
+        alignment: start;
+        HorizontalBox {
+            alignment: center;
+            Button {
+                text: @tr("Create Session");
+                clicked => {
+                    create_session_button_clicked();
+                }
+            }
+        }
+
+        HorizontalBox {
+            alignment: center;
+            Button {
+                text: @tr("Join Session");
+                clicked => {
+                    join_session_button_clicked();
+                }
+            }
+        }
+
+        Rectangle {
+            height: 20px;
+        }
+
+        HorizontalBox {
+            alignment: center;
+            Button {
+                text: @tr("Netplay Discord Channel");
+                clicked => {
+                    netplay_discord_button_clicked();
+                }
+            }
+
+            Button {
+                text: @tr("Provide Feedback");
+                clicked => {
+                    netplay_feedback_button_clicked();
+                }
+            }
+        }
+    }
+}
+
+export component CustomNetplayServer inherits Dialog {
+    in-out property custom_server_url <=> NetplayData.custom_server_url;
+    title: @tr("Custom Netplay Server");
+    preferred-width: 400px;
+    callback ok_clicked(string);
+    server_url := LineEdit {
+        text: NetplayData.custom_server_url;
+        placeholder-text: "example.com:45000";
+    }
+
+    StandardButton {
+        kind: ok;
+        clicked => {
+            NetplayData.custom_server_url = server_url.text;
+            ok_clicked(NetplayData.custom_server_url);
+        }
+    }
+}

src/ui/gui/netplay_wait.slint

@@ -0,0 +1,110 @@
+import { VerticalBox, HorizontalBox, TextEdit, ScrollView, LineEdit, Button, GridBox } from "std-widgets.slint";
+import { NetplayData } from "netplay_page.slint";
+
+export global NetplayWaitData {
+    in-out property <string> motd;
+    in-out property <[string]> players;
+    in-out property <int> port;
+    in-out property <bool> can_start;
+    in-out property <string> chat_text;
+    in-out property <string> ping;
+}
+
+export component NetplayWait inherits Window {
+    title: @tr("Netplay: Waiting Room");
+    preferred-width: 400px;
+    preferred-height: 400px;
+    in-out property players <=> NetplayWaitData.players;
+    in-out property session_name <=> NetplayData.session_name;
+    in-out property game_name <=> NetplayData.game_name;
+    in-out property rom_path <=> NetplayData.rom_path;
+    in-out property motd <=> NetplayWaitData.motd;
+    in-out property port <=> NetplayWaitData.port;
+    in-out property can_start <=> NetplayWaitData.can_start;
+    in-out property chat_text <=> NetplayWaitData.chat_text;
+    in-out property ping <=> NetplayWaitData.ping;
+    callback send_chat_message(string);
+    callback begin_game;
+
+    VerticalBox {
+        Text {
+            text: @tr("Session Name: ") + NetplayData.session_name;
+            font-size: 15px;
+            horizontal-alignment: center;
+        }
+
+        Text {
+            text: @tr("Game Name: ") + NetplayData.game_name;
+            font-size: 15px;
+            horizontal-alignment: center;
+        }
+
+        Text {
+            text: @tr("Ping: ") + NetplayWaitData.ping;
+            horizontal-alignment: center;
+        }
+
+        GridBox {
+            Row {
+                Text {
+                    text: "Player 1: " + players[0];
+                }
+
+                Text {
+                    text: "Player 2: " + players[1];
+                }
+            }
+
+            Row {
+                Text {
+                    text: "Player 3: " + players[2];
+                }
+
+                Text {
+                    text: "Player 4: " + players[3];
+                }
+            }
+        }
+
+        TextEdit {
+            read-only: true;
+            text: NetplayWaitData.chat_text;
+        }
+
+        HorizontalBox {
+            chat_message := LineEdit {
+                placeholder_text: @tr("Enter chat message");
+                key-released(event) => {
+                    if (event.text == Key.Return && chat_message.text != "") {
+                        send_chat_message(chat_message.text);
+                        chat_message.text = "";
+                    }
+                    accept
+                }
+            }
+
+            Button {
+                text: @tr("Send Message");
+                enabled: chat_message.text != "";
+                clicked => {
+                    send_chat_message(chat_message.text);
+                    chat_message.text = "";
+                }
+            }
+        }
+
+        Text {
+            text: NetplayWaitData.motd;
+            wrap: word-wrap;
+        }
+
+        Button {
+            text: @tr("Start Game");
+            enabled: NetplayWaitData.can_start;
+            clicked => {
+                NetplayWaitData.can_start = false;
+                begin_game();
+            }
+        }
+    }
+}

src/ui/gui/page.slint

@@ -0,0 +1,23 @@
+// Copyright © SixtyFPS GmbH <info@slint.dev>
+// SPDX-License-Identifier: MIT
+
+import { Switch, GridBox, ListView, ScrollView, HorizontalBox, VerticalBox, Palette } from "std-widgets.slint";
+
+export component Page inherits VerticalBox {
+    in property <string> title: "title";
+
+    accessible-role: tab-panel;
+    accessible-label: root.title;
+
+    HorizontalBox {
+        Text {
+            font-size: 20px;
+            text <=> root.title;
+        }
+
+        // Spacer
+        Rectangle { }
+    }
+
+    @children
+}

src/ui/gui/pages.slint

@@ -0,0 +1,6 @@
+export { LocalGame } from "localgame_page.slint";
+export { ControllerConfig } from "controller_page.slint";
+export { Netplay } from "netplay_page.slint";
+export { Cheats } from "cheat_page.slint";
+export { Settings } from "settings_page.slint";
+export { About } from "about_page.slint";