Update version milestone to Release Candidate 1.

* Implement Vibration & Background Input thumbnails

* Disable Resolution Scale and Subtitle Thumbnails

* Remove unused thumbnails & redirect original shadow resolution thumbnail to 1024x.

* Fix else if chain.

* Update resources submodule.

---------

Co-authored-by: RadiantDerg <9061202+RadiantDerg@users.noreply.github.com>
Co-authored-by: Skyth <19259897+blueskythlikesclouds@users.noreply.github.com>

.github/workflows/build-linux.yml

@@ -0,0 +1,73 @@
+name: Build Project (Linux)
+
+on:
+  workflow_dispatch:
+
+env:
+  LLVM_VERSION: 18
+  CMAKE_PRESET: linux-relwithdebinfo
+
+jobs:
+  build:
+    name: Build Linux
+    runs-on: ubuntu-24.04
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          token: ${{ secrets.ORG_TOKEN }}
+
+      - name: Checkout Private Repository
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ secrets.ASSET_REPO }}
+          token: ${{ secrets.ASSET_REPO_TOKEN }}
+          path: ./private
+
+      - name: Setup ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ccache-${{ runner.os }}
+  
+      - name: Cache vcpkg
+        uses: actions/cache@v4
+        with:
+          path: |
+            ./thirdparty/vcpkg/downloads
+            ./thirdparty/vcpkg/packages
+          key: vcpkg-${{ runner.os }}-${{ hashFiles('vcpkg.json') }}
+          restore-keys: |
+              vcpkg-${{ runner.os }}-
+
+      - name: Install Dependencies
+        run: |-
+          sudo apt update
+          sudo apt install -y ninja-build llvm-${{ env.LLVM_VERSION }}-dev libgtk-3-dev
+
+      - name: Cache ccache Directory
+        uses: actions/cache@v4
+        with:
+          path: /tmp/ccache
+          key: ccache-${{ runner.os }}
+
+      - name: Prepare Project
+        run: cp ./private/* ./UnleashedRecompLib/private
+  
+      - name: Configure Project
+        env:
+          CCACHE_DIR: /tmp/ccache
+        run: cmake . --preset ${{ env.CMAKE_PRESET }} -DSDL2MIXER_VORBIS=VORBISFILE -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DCMAKE_C_COMPILER_LAUNCHER=ccache
+
+      - name: Build Project
+        env:
+          CCACHE_DIR: /tmp/ccache
+        run: cmake --build ./out/build/${{ env.CMAKE_PRESET }} --target UnleashedRecomp
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: UnleashedRecomp-Linux
+          path: ./out/build/${{ env.CMAKE_PRESET }}/UnleashedRecomp/UnleashedRecomp
+      

.gitmodules

@@ -7,9 +7,6 @@
 [submodule "tools/XenosRecomp"]
 	path = tools/XenosRecomp
 	url = https://github.com/hedge-dev/XenosRecomp.git
-[submodule "thirdparty/libmspack"]
-	path = thirdparty/libmspack
-	url = https://github.com/kyz/libmspack
 [submodule "UnleashedRecompResources"]
 	path = UnleashedRecompResources
 	url = https://github.com/hedge-dev/UnleashedRecompResources.git
@@ -40,9 +37,6 @@
 [submodule "thirdparty/concurrentqueue"]
 	path = thirdparty/concurrentqueue
 	url = https://github.com/cameron314/concurrentqueue.git
-[submodule "thirdparty/tiny-AES-c"]
-	path = thirdparty/tiny-AES-c
-	url = https://github.com/kokke/tiny-AES-c.git
 [submodule "thirdparty/magic_enum"]
 	path = thirdparty/magic_enum
 	url = https://github.com/Neargye/magic_enum.git

README.md

@@ -4,7 +4,7 @@
 ```
 git clone --recurse-submodules https://github.com/hedge-dev/UnleashedRecomp.git
 ```
-2. Decompress and decrypt `default.xex`, apply the title update patch (`default.xexp`), and place the resulting file in `./UnleashedRecompLib/private/`.
+2. Place `default.xex` and `default.xexp` in `./UnleashedRecompLib/private/`.
 3. Decompress `shader.ar` and place the resulting file in `./UnleashedRecompLib/private/`.
 4. Open the repository directory in Visual Studio 2022 and wait for CMake generation to complete. If you don't plan to debug, switch to the `x64-Clang-Release` configuration.
 5. Under Solution Explorer, right-click and choose "Switch to CMake Targets View".

UnleashedRecomp/CMakeLists.txt

@@ -158,16 +158,15 @@ set(UNLEASHED_RECOMP_UI_CXX_SOURCES
     "ui/installer_wizard.cpp"
     "ui/message_window.cpp"
     "ui/options_menu.cpp"
-    "ui/options_menu_thumbnails.cpp"
+    "ui/options_menu_thumbnails.cpp"
+    "ui/tv_static.cpp"
 )
 
 set(UNLEASHED_RECOMP_INSTALL_CXX_SOURCES
     "install/installer.cpp"
     "install/iso_file_system.cpp"
-    "install/memory_mapped_file.cpp"
     "install/update_checker.cpp"
     "install/xcontent_file_system.cpp"
-    "install/xex_patcher.cpp"
     "install/hashes/apotos_shamar.cpp"
     "install/hashes/chunnan.cpp"
     "install/hashes/empire_city_adabat.cpp"
@@ -200,8 +199,6 @@ set(UNLEASHED_RECOMP_THIRDPARTY_SOURCES
     "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/implot/implot.cpp"
     "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/implot/implot_demo.cpp"
     "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/implot/implot_items.cpp"
-    "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/libmspack/libmspack/mspack/lzxd.c"
-    "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/tiny-AES-c/aes.c"
     "${UNLEASHED_RECOMP_TOOLS_ROOT}/XenosRecomp/thirdparty/smol-v/source/smolv.cpp"
 )
 
@@ -211,11 +208,8 @@ set(UNLEASHED_RECOMP_THIRDPARTY_INCLUDES
     "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/imgui"
     "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/implot"
     "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/json/include"
-    "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/libmspack/libmspack/mspack"
     "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/magic_enum/include"
     "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/stb"
-    "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/tiny-AES-c"
-    "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/TinySHA1"
     "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/unordered_dense/include"
     "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/volk"
     "${UNLEASHED_RECOMP_THIRDPARTY_ROOT}/Vulkan-Headers/include"
@@ -471,7 +465,8 @@ generate_aggregate_header(
 
 set(RESOURCES_SOURCE_PATH "${PROJECT_SOURCE_DIR}/../UnleashedRecompResources")
 set(RESOURCES_OUTPUT_PATH "${PROJECT_SOURCE_DIR}/res")
-
+
+## Miscellaneous ##
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/bc_diff/button_bc_diff.bin" DEST_FILE "${RESOURCES_OUTPUT_PATH}/bc_diff/button_bc_diff.bin" ARRAY_NAME "g_button_bc_diff" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/font/im_font_atlas.bin" DEST_FILE "${RESOURCES_OUTPUT_PATH}/font/im_font_atlas.bin" ARRAY_NAME "g_im_font_atlas" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/font/im_font_atlas.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/font/im_font_atlas.dds" ARRAY_NAME "g_im_font_atlas_texture" COMPRESSION_TYPE "zstd")
@@ -482,6 +477,8 @@ BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/co
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/common/kbm.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/common/kbm.dds" ARRAY_NAME "g_kbm" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/common/select.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/common/select.dds" ARRAY_NAME "g_select" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/common/light.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/common/light.dds" ARRAY_NAME "g_light" COMPRESSION_TYPE "zstd")
+
+## Installer ##
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/installer/arrow_circle.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/installer/arrow_circle.dds" ARRAY_NAME "g_arrow_circle" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/installer/install_001.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/installer/install_001.dds" ARRAY_NAME "g_install_001" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/installer/install_002.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/installer/install_002.dds" ARRAY_NAME "g_install_002" COMPRESSION_TYPE "zstd")
@@ -492,14 +489,23 @@ BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/in
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/installer/install_007.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/installer/install_007.dds" ARRAY_NAME "g_install_007" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/installer/install_008.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/installer/install_008.dds" ARRAY_NAME "g_install_008" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/installer/miles_electric_icon.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/installer/miles_electric_icon.dds" ARRAY_NAME "g_miles_electric_icon" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/installer/pulse_install.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/installer/pulse_install.dds" ARRAY_NAME "g_pulse_install" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/installer/pulse_install.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/installer/pulse_install.dds" ARRAY_NAME "g_pulse_install" COMPRESSION_TYPE "zstd")
+
+## Options Menu ##
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/achievement_notifications.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/achievement_notifications.dds" ARRAY_NAME "g_achievement_notifications" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/allow_background_input.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/allow_background_input.dds" ARRAY_NAME "g_allow_background_input" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/antialiasing.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/antialiasing.dds" ARRAY_NAME "g_antialiasing" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/allow_background_input_ps.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/allow_background_input_ps.dds" ARRAY_NAME "g_allow_background_input_ps" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/allow_background_input_xb.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/allow_background_input_xb.dds" ARRAY_NAME "g_allow_background_input_xb" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/antialiasing_none.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/antialiasing_none.dds" ARRAY_NAME "g_antialiasing_none" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/antialiasing_2x.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/antialiasing_2x.dds" ARRAY_NAME "g_antialiasing_2x" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/antialiasing_4x.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/antialiasing_4x.dds" ARRAY_NAME "g_antialiasing_4x" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/antialiasing_8x.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/antialiasing_8x.dds" ARRAY_NAME "g_antialiasing_8x" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/aspect_ratio.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/aspect_ratio.dds" ARRAY_NAME "g_aspect_ratio" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/battle_theme.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/battle_theme.dds" ARRAY_NAME "g_battle_theme" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/brightness.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/brightness.dds" ARRAY_NAME "g_brightness" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/control_tutorial.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/control_tutorial.dds" ARRAY_NAME "g_control_tutorial" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/brightness.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/brightness.dds" ARRAY_NAME "g_brightness" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/channel_stereo.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/channel_stereo.dds" ARRAY_NAME "g_channel_stereo" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/channel_surround.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/channel_surround.dds" ARRAY_NAME "g_channel_surround" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/control_tutorial_ps.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/control_tutorial_ps.dds" ARRAY_NAME "g_control_tutorial_ps" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/control_tutorial_xb.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/control_tutorial_xb.dds" ARRAY_NAME "g_control_tutorial_xb" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/controller_icons.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/controller_icons.dds" ARRAY_NAME "g_controller_icons" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/default.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/default.dds" ARRAY_NAME "g_default" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/effects_volume.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/effects_volume.dds" ARRAY_NAME "g_effects_volume" COMPRESSION_TYPE "zstd")
@@ -515,36 +521,42 @@ BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/op
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/motion_blur_off.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/motion_blur_off.dds" ARRAY_NAME "g_motion_blur_off" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/motion_blur_original.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/motion_blur_original.dds" ARRAY_NAME "g_motion_blur_original" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/motion_blur_enhanced.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/motion_blur_enhanced.dds" ARRAY_NAME "g_motion_blur_enhanced" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/movie_scale_mode.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/movie_scale_mode.dds" ARRAY_NAME "g_movie_scale_mode" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/movie_scale_fit.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/movie_scale_fit.dds" ARRAY_NAME "g_movie_scale_fit" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/movie_scale_fill.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/movie_scale_fill.dds" ARRAY_NAME "g_movie_scale_fill" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/music_attenuation.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/music_attenuation.dds" ARRAY_NAME "g_music_attenuation" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/music_volume.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/music_volume.dds" ARRAY_NAME "g_music_volume" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/resolution_scale.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/resolution_scale.dds" ARRAY_NAME "g_resolution_scale" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/shadow_resolution_original.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/shadow_resolution_original.dds" ARRAY_NAME "g_shadow_resolution_original" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/shadow_resolution_x512.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/shadow_resolution_x512.dds" ARRAY_NAME "g_shadow_resolution_x512" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/shadow_resolution_x1024.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/shadow_resolution_x1024.dds" ARRAY_NAME "g_shadow_resolution_x1024" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/shadow_resolution_x2048.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/shadow_resolution_x2048.dds" ARRAY_NAME "g_shadow_resolution_x2048" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/shadow_resolution_x4096.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/shadow_resolution_x4096.dds" ARRAY_NAME "g_shadow_resolution_x4096" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/shadow_resolution_x8192.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/shadow_resolution_x8192.dds" ARRAY_NAME "g_shadow_resolution_x8192" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/subtitles.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/subtitles.dds" ARRAY_NAME "g_subtitles" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/time_of_day_transition_xbox.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/time_of_day_transition_xbox.dds" ARRAY_NAME "g_time_of_day_transition_xbox" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/time_of_day_transition_playstation.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/time_of_day_transition_playstation.dds" ARRAY_NAME "g_time_of_day_transition_playstation" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/time_transition_ps.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/time_transition_ps.dds" ARRAY_NAME "g_time_of_day_transition_playstation" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/time_transition_xb.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/time_transition_xb.dds" ARRAY_NAME "g_time_of_day_transition_xbox" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/transparency_antialiasing_false.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/transparency_antialiasing_false.dds" ARRAY_NAME "g_transparency_antialiasing_false" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/transparency_antialiasing_true.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/transparency_antialiasing_true.dds" ARRAY_NAME "g_transparency_antialiasing_true" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/ui_alignment_mode.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/ui_alignment_mode.dds" ARRAY_NAME "g_ui_alignment_mode" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/ui_alignment_centre.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/ui_alignment_centre.dds" ARRAY_NAME "g_ui_alignment_centre" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/ui_alignment_edge.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/ui_alignment_edge.dds" ARRAY_NAME "g_ui_alignment_edge" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/vertical_camera.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/vertical_camera.dds" ARRAY_NAME "g_vertical_camera" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/voice_language.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/voice_language.dds" ARRAY_NAME "g_voice_language" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/vibration.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/vibration.dds" ARRAY_NAME "g_vibration" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/vsync.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/vsync.dds" ARRAY_NAME "g_vsync" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/vibration_ps.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/vibration_ps.dds" ARRAY_NAME "g_vibration_ps" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/vibration_xb.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/vibration_xb.dds" ARRAY_NAME "g_vibration_xb" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/vsync_on.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/vsync_on.dds" ARRAY_NAME "g_vsync_on" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/vsync_off.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/vsync_off.dds" ARRAY_NAME "g_vsync_off" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/window_size.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/window_size.dds" ARRAY_NAME "g_window_size" COMPRESSION_TYPE "zstd")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/thumbnails/xbox_color_correction.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/thumbnails/xbox_color_correction.dds" ARRAY_NAME "g_xbox_color_correction" COMPRESSION_TYPE "zstd")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/miles_electric.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/miles_electric.dds" ARRAY_NAME "g_miles_electric" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/miles_electric.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/miles_electric.dds" ARRAY_NAME "g_miles_electric" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/options_static.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/options_static.dds" ARRAY_NAME "g_options_static" COMPRESSION_TYPE "zstd")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/options_menu/options_static_flash.dds" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/options_menu/options_static_flash.dds" ARRAY_NAME "g_options_static_flash" COMPRESSION_TYPE "zstd")
+
+## Game Icon ##
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/game_icon.bmp" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/game_icon.bmp" ARRAY_NAME "g_game_icon")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/game_icon_night.bmp" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/game_icon_night.bmp" ARRAY_NAME "g_game_icon_night")
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/images/game_icon_night.bmp" DEST_FILE "${RESOURCES_OUTPUT_PATH}/images/game_icon_night.bmp" ARRAY_NAME "g_game_icon_night")
+
+## Audio ##
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/sounds/sys_worldmap_cursor.ogg" DEST_FILE "${RESOURCES_OUTPUT_PATH}/sounds/sys_worldmap_cursor.ogg" ARRAY_NAME "g_sys_worldmap_cursor")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/sounds/sys_worldmap_finaldecide.ogg" DEST_FILE "${RESOURCES_OUTPUT_PATH}/sounds/sys_worldmap_finaldecide.ogg" ARRAY_NAME "g_sys_worldmap_finaldecide")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/sounds/sys_actstg_pausecansel.ogg" DEST_FILE "${RESOURCES_OUTPUT_PATH}/sounds/sys_actstg_pausecansel.ogg" ARRAY_NAME "g_sys_actstg_pausecansel")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/sounds/sys_actstg_pausecursor.ogg" DEST_FILE "${RESOURCES_OUTPUT_PATH}/sounds/sys_actstg_pausecursor.ogg" ARRAY_NAME "g_sys_actstg_pausecursor")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/sounds/sys_actstg_pausedecide.ogg" DEST_FILE "${RESOURCES_OUTPUT_PATH}/sounds/sys_actstg_pausedecide.ogg" ARRAY_NAME "g_sys_actstg_pausedecide")
 BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/sounds/sys_actstg_pausewinclose.ogg" DEST_FILE "${RESOURCES_OUTPUT_PATH}/sounds/sys_actstg_pausewinclose.ogg" ARRAY_NAME "g_sys_actstg_pausewinclose")
-BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/sounds/sys_actstg_pausewinopen.ogg" DEST_FILE "${RESOURCES_OUTPUT_PATH}/sounds/sys_actstg_pausewinopen.ogg" ARRAY_NAME "g_sys_actstg_pausewinopen")
-
+BIN2C(TARGET_OBJ UnleashedRecomp SOURCE_FILE "${RESOURCES_SOURCE_PATH}/sounds/sys_actstg_pausewinopen.ogg" DEST_FILE "${RESOURCES_OUTPUT_PATH}/sounds/sys_actstg_pausewinopen.ogg" ARRAY_NAME "g_sys_actstg_pausewinopen")

UnleashedRecomp/api/Hedgehog/Math/Matrix.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <SWA.inl>
+
+namespace Hedgehog::Math
+{
+    class CMatrix
+    {
+    public:
+        be<float> m_M00;
+        be<float> m_M01;
+        be<float> m_M02;
+        be<float> m_M03;
+        be<float> m_M10;
+        be<float> m_M11;
+        be<float> m_M12;
+        be<float> m_M13;
+        be<float> m_M20;
+        be<float> m_M21;
+        be<float> m_M22;
+        be<float> m_M23;
+        be<float> m_M30;
+        be<float> m_M31;
+        be<float> m_M32;
+        be<float> m_M33;
+    };
+}

UnleashedRecomp/api/Hedgehog/Math/Quaternion.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <SWA.inl>
+
+namespace Hedgehog::Math
+{
+    class CQuaternion
+    {
+    public:
+        be<float> X;
+        be<float> Y;
+        be<float> Z;
+        be<float> W;
+    };
+}

UnleashedRecomp/api/Hedgehog/MirageCore/MatrixNode/hhMatrixNode.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <SWA.inl>
+
+namespace Hedgehog::Mirage
+{
+    class CMatrixNodeListener;
+
+    class CMatrixNode : public Base::CObject
+    {
+    public:
+        SWA_INSERT_PADDING(0x60);
+    };
+
+    SWA_ASSERT_SIZEOF(CMatrixNode, 0x60);
+}

UnleashedRecomp/api/Hedgehog/MirageCore/Misc/hhTransform.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <SWA.inl>
+
+namespace Hedgehog::Mirage
+{
+    class CTransform
+    {
+    public:
+        Math::CQuaternion m_Rotation;
+        Math::CVector m_Position;
+        Math::CMatrix m_Matrix;
+    };
+
+    SWA_ASSERT_OFFSETOF(CTransform, m_Rotation, 0x00);
+    SWA_ASSERT_OFFSETOF(CTransform, m_Position, 0x10);
+    SWA_ASSERT_OFFSETOF(CTransform, m_Matrix, 0x20);
+    SWA_ASSERT_SIZEOF(CTransform, 0x60);
+}

UnleashedRecomp/api/SWA.h

@@ -27,7 +27,11 @@
 #include "Hedgehog/Base/Type/hhSharedString.h"
 #include "Hedgehog/Base/hhObject.h"
 #include "Hedgehog/Database/System/hhDatabaseData.h"
+#include "Hedgehog/Math/Matrix.h"
+#include "Hedgehog/Math/Quaternion.h"
 #include "Hedgehog/Math/Vector.h"
+#include "Hedgehog/MirageCore/MatrixNode/hhMatrixNode.h"
+#include "Hedgehog/MirageCore/Misc/hhTransform.h"
 #include "Hedgehog/MirageCore/Misc/hhVertexDeclarationPtr.h"
 #include "Hedgehog/MirageCore/RenderData/hhMaterialData.h"
 #include "Hedgehog/MirageCore/RenderData/hhMeshData.h"
@@ -55,6 +59,7 @@
 #include "SWA/Achievement/AchievementID.h"
 #include "SWA/Achievement/AchievementManager.h"
 #include "SWA/Achievement/AchievementTest.h"
+#include "SWA/Boss/EggDragoon/Object/BossEggDragoonDrillMissile.h"
 #include "SWA/CSD/CsdDatabaseWrapper.h"
 #include "SWA/CSD/CsdProject.h"
 #include "SWA/CSD/CsdTexListMirage.h"
@@ -85,6 +90,7 @@
 #include "SWA/Movie/MovieDisplayer.h"
 #include "SWA/Movie/MovieManager.h"
 #include "SWA/Object/Common/DashPanel/ObjDashPanel.h"
+#include "SWA/Object/SonicStage/EU/RollingBarrel/ObjRollingBarrel.h"
 #include "SWA/Player/Character/EvilSonic/EvilSonic.h"
 #include "SWA/Player/Character/EvilSonic/EvilSonicContext.h"
 #include "SWA/Player/Character/EvilSonic/Hud/EvilHudGuide.h"
@@ -115,6 +121,7 @@
 #include "SWA/System/GameParameter.h"
 #include "SWA/System/GammaController.h"
 #include "SWA/System/InputState.h"
+#include "SWA/System/MatrixNodeTransform.h"
 #include "SWA/System/PadState.h"
 #include "SWA/System/World.h"
 #include "boost/smart_ptr/make_shared_object.h"

UnleashedRecomp/api/SWA/Boss/EggDragoon/Object/BossEggDragoonDrillMissile.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <SWA.inl>
+#include "SWA/System/MatrixNodeTransform.h"
+
+namespace SWA::Boss::EggDragoon::DrillMissile
+{
+    class CMissile
+    {
+    public:
+        SWA_INSERT_PADDING(0xC4);
+        xpointer<CMatrixNodeTransform> m_pMatrixNodeTransform;
+        SWA_INSERT_PADDING(0x68);
+        be<float> m_Speed;
+    };
+}

UnleashedRecomp/api/SWA/Globals.h

@@ -9,6 +9,9 @@ namespace SWA
         // ms_DrawLightFieldSamplingPoint: サンプリング点をデバッグ表示
         static inline bool* ms_DrawLightFieldSamplingPoint;
 
+        // N/A
+        static inline bool* ms_IsAutoSaveWarningShown;
+
         // ms_IgnoreLightFieldData: データを無視する
         static inline bool* ms_IgnoreLightFieldData;
 
@@ -39,6 +42,9 @@ namespace SWA
         // ms_IsRenderHudPause: ポーズメニュー 描画
         static inline bool* ms_IsRenderHudPause;
 
+        // N/A
+        static inline bool* ms_IsTitleStateMenu;
+
         // IsTriggerRender
         static inline bool* ms_IsTriggerRender;
 
@@ -52,6 +58,7 @@ namespace SWA
         {
             ms_DrawLightFieldSamplingPoint = (bool*)MmGetHostAddress(0x83367BCE);
             ms_IgnoreLightFieldData = (bool*)MmGetHostAddress(0x83367BCF);
+            ms_IsAutoSaveWarningShown = (bool*)MmGetHostAddress(0x83367BC1);
             ms_IsCollisionRender = (bool*)MmGetHostAddress(0x833678A6);
             ms_IsLoading = (bool*)MmGetHostAddress(0x83367A4C);
             ms_IsObjectCollisionRender = (bool*)MmGetHostAddress(0x83367905);
@@ -61,6 +68,7 @@ namespace SWA
             ms_IsRenderGameMainHud = (bool*)MmGetHostAddress(0x8328BB27);
             ms_IsRenderHud = (bool*)MmGetHostAddress(0x8328BB26);
             ms_IsRenderHudPause = (bool*)MmGetHostAddress(0x8328BB28);
+            ms_IsTitleStateMenu = (bool*)MmGetHostAddress(0x83367BC0);
             ms_IsTriggerRender = (bool*)MmGetHostAddress(0x83367904);
             ms_LightFieldDebug = (bool*)MmGetHostAddress(0x83367BCD);
             ms_VisualizeLoadedLevel = (bool*)MmGetHostAddress(0x833678C1);

UnleashedRecomp/api/SWA/Object/SonicStage/EU/RollingBarrel/ObjRollingBarrel.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <SWA.inl>
+
+namespace SWA
+{
+    class CObjRollingBarrel
+    {
+    public:
+        class CElement
+        {
+        public:
+            SWA_INSERT_PADDING(0xEC);
+            xpointer<void> m_FieldEC;
+            SWA_INSERT_PADDING(0x20);
+            be<float> m_Roll;
+        };
+
+        SWA_INSERT_PADDING(0xE8);
+        be<float> m_GenerationTime;
+        SWA_INSERT_PADDING(0x09);
+        bool m_FieldF5;
+        SWA_INSERT_PADDING(0x0A);
+        be<float> m_RandomRange;
+        be<float> m_Field104;
+    };
+
+    SWA_ASSERT_OFFSETOF(CObjRollingBarrel::CElement, m_FieldEC, 0xEC);
+    SWA_ASSERT_OFFSETOF(CObjRollingBarrel::CElement, m_Roll, 0x110);
+
+    SWA_ASSERT_OFFSETOF(CObjRollingBarrel, m_GenerationTime, 0xE8);
+    SWA_ASSERT_OFFSETOF(CObjRollingBarrel, m_FieldF5, 0xF5);
+    SWA_ASSERT_OFFSETOF(CObjRollingBarrel, m_RandomRange, 0x100);
+    SWA_ASSERT_OFFSETOF(CObjRollingBarrel, m_Field104, 0x104);
+}

UnleashedRecomp/api/SWA/System/ApplicationDocument.h

@@ -71,7 +71,8 @@ namespace SWA
             boost::shared_ptr<Hedgehog::Mirage::CMatrixNode> m_spMatrixNodeRoot;
             SWA_INSERT_PADDING(0x14);
             CGammaController m_GammaController;
-            SWA_INSERT_PADDING(0x1C);
+            boost::shared_ptr<CLoading> m_spLoading;
+            SWA_INSERT_PADDING(0x14);
             boost::shared_ptr<Achievement::CManager> m_spAchievementManager;
             boost::shared_ptr<CDatabaseTree> m_spDatabaseTree;
             Hedgehog::Base::CSharedString m_Field10C;
@@ -104,6 +105,7 @@ namespace SWA
     SWA_ASSERT_OFFSETOF(CApplicationDocument::CMember, m_Field74, 0x74);
     SWA_ASSERT_OFFSETOF(CApplicationDocument::CMember, m_spMatrixNodeRoot, 0x84);
     SWA_ASSERT_OFFSETOF(CApplicationDocument::CMember, m_GammaController, 0xA0);
+    SWA_ASSERT_OFFSETOF(CApplicationDocument::CMember, m_spLoading, 0xE0);
     SWA_ASSERT_OFFSETOF(CApplicationDocument::CMember, m_spAchievementManager, 0xFC);
     SWA_ASSERT_OFFSETOF(CApplicationDocument::CMember, m_spDatabaseTree, 0x104);
     SWA_ASSERT_OFFSETOF(CApplicationDocument::CMember, m_Field10C, 0x10C);

UnleashedRecomp/api/SWA/System/GameMode/Title/TitleStateBase.h

@@ -4,14 +4,5 @@
 
 namespace SWA
 {
-    class CTitleStateBase : public Hedgehog::Universe::CStateMachineBase::CStateBase
-    {
-    public:
-        class CTitleStateContext
-        {
-        public:
-            SWA_INSERT_PADDING(0x1E8);
-            xpointer<CTitleMenu> m_pTitleMenu;
-        };
-    };
+    class CTitleStateBase : public Hedgehog::Universe::CStateMachineBase::CStateBase {};
 }

UnleashedRecomp/api/SWA/System/GameMode/Title/TitleStateMenu.h

@@ -4,5 +4,14 @@
 
 namespace SWA
 {
-    class CTitleStateMenu : public CTitleStateBase {};
+    class CTitleStateMenu : public CTitleStateBase
+    {
+    public:
+        class CTitleStateMenuContext
+        {
+        public:
+            SWA_INSERT_PADDING(0x1E8);
+            xpointer<CTitleMenu> m_pTitleMenu;
+        };
+    };
 }

UnleashedRecomp/api/SWA/System/MatrixNodeTransform.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <SWA.inl>
+
+namespace SWA
+{
+    class CMatrixNodeTransform : public Hedgehog::Mirage::CMatrixNode
+    {
+    public:
+        Hedgehog::Mirage::CTransform m_Transform;
+        Hedgehog::Math::CMatrix m_WorldMatrix;
+    };
+
+    SWA_ASSERT_OFFSETOF(CMatrixNodeTransform, m_Transform, 0x60);
+    SWA_ASSERT_OFFSETOF(CMatrixNodeTransform, m_WorldMatrix, 0xC0);
+    SWA_ASSERT_SIZEOF(CMatrixNodeTransform, 0x100);
+}

UnleashedRecomp/app.cpp

@@ -28,7 +28,7 @@ void App::Exit()
     std::_Exit(0);
 }
 
-// SWA::CApplication
+// SWA::CApplication::CApplication
 PPC_FUNC_IMPL(__imp__sub_824EB490);
 PPC_FUNC(sub_824EB490)
 {
@@ -60,6 +60,7 @@ PPC_FUNC(sub_822C1130)
     }
 
     App::s_deltaTime = ctx.f1.f64;
+    App::s_time += App::s_deltaTime;
 
     // This function can also be called by the loading thread,
     // which SDL does not like. To prevent the OS from thinking
@@ -69,12 +70,28 @@ PPC_FUNC(sub_822C1130)
     {
         SDL_PumpEvents();
         SDL_FlushEvents(SDL_FIRSTEVENT, SDL_LASTEVENT);
+        GameWindow::Update();
     }
 
-    GameWindow::Update();
     AudioPatches::Update(App::s_deltaTime);
     InspirePatches::Update();
 
+    // Apply subtitles option.
+    if (auto pApplicationDocument = SWA::CApplicationDocument::GetInstance())
+        pApplicationDocument->m_InspireSubtitles = Config::Subtitles;
+
+    if (Config::EnableEventCollisionDebugView)
+        *SWA::SGlobals::ms_IsTriggerRender = true;
+
+    if (Config::EnableGIMipLevelDebugView)
+        *SWA::SGlobals::ms_VisualizeLoadedLevel = true;
+
+    if (Config::EnableObjectCollisionDebugView)
+        *SWA::SGlobals::ms_IsObjectCollisionRender = true;
+
+    if (Config::EnableStageCollisionDebugView)
+        *SWA::SGlobals::ms_IsCollisionRender = true;
+
     __imp__sub_822C1130(ctx, base);
 }
 

UnleashedRecomp/app.h

@@ -14,6 +14,7 @@ public:
     static inline ELanguage s_language;
 
     static inline double s_deltaTime;
+    static inline double s_time = 0.0; // How much time elapsed since the game started.
 
     static void Restart(std::vector<std::string> restartArgs = {});
     static void Exit();

UnleashedRecomp/apu/driver/sdl2_driver.cpp

@@ -1,6 +1,7 @@
 #include <apu/audio.h>
 #include <cpu/guest_thread.h>
 #include <kernel/heap.h>
+#include <os/logger.h>
 #include <user/config.h>
 
 static PPCFunc* g_clientCallback{};
@@ -29,6 +30,9 @@ static void CreateAudioDevice()
         g_audioDevice = SDL_OpenAudioDevice(nullptr, 0, &desired, &obtained, 0);
     }
 
+    if (!g_audioDevice)
+        LOGFN_ERROR("Failed to open audio device: {}", SDL_GetError());
+
     g_downMixToStereo = (obtained.channels == 2);
 }
 
@@ -36,7 +40,13 @@ void XAudioInitializeSystem()
 {
     SDL_SetHint(SDL_HINT_AUDIO_CATEGORY, "playback");
     SDL_SetHint(SDL_HINT_AUDIO_DEVICE_APP_NAME, "Unleashed Recompiled");
-    SDL_InitSubSystem(SDL_INIT_AUDIO);
+
+    if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0)
+    {
+        LOGFN_ERROR("Failed to init audio subsystem: {}", SDL_GetError());
+        return;
+    }
+
     CreateAudioDevice();
 }
 

UnleashedRecomp/exports.cpp

@@ -5,6 +5,7 @@
 #include <kernel/heap.h>
 #include <kernel/memory.h>
 #include <ui/game_window.h>
+#include <patches/inspire_patches.h>
 
 void Game_PlaySound(const char* pName)
 {
@@ -14,8 +15,11 @@ void Game_PlaySound(const char* pName)
     }
     else
     {
+        // Use EVENT category in cutscenes since SYSTEM gets muted by the game.
+        uint32_t category = !InspirePatches::s_sceneName.empty() ? 10 : 7;
+
         guest_stack_var<boost::anonymous_shared_ptr> soundPlayer;
-        GuestToHostFunction<void>(sub_82B4DF50, soundPlayer.get(), ((be<uint32_t>*)g_memory.Translate(0x83367900))->get(), 7, 0, 0);
+        GuestToHostFunction<void>(sub_82B4DF50, soundPlayer.get(), ((be<uint32_t>*)g_memory.Translate(0x83367900))->get(), category, 0, 0);
 
         auto soundPlayerVtable = (be<uint32_t>*)g_memory.Translate(*(be<uint32_t>*)soundPlayer->get());
         uint32_t virtualFunction = *(soundPlayerVtable + 1);
@@ -27,13 +31,3 @@ void Game_PlaySound(const char* pName)
         g_userHeap.Free(strAllocation);
     }
 }
-
-void Window_SetDisplay(int displayIndex)
-{
-    GameWindow::SetDisplay(displayIndex);
-}
-
-void Window_SetFullscreen(bool isEnabled)
-{
-    GameWindow::SetFullscreen(isEnabled);
-}

UnleashedRecomp/exports.h

@@ -1,5 +1,3 @@
 #pragma once
 
 void Game_PlaySound(const char* pName);
-void Window_SetDisplay(int displayIndex);
-void Window_SetFullscreen(bool isEnabled);

UnleashedRecomp/gpu/cache/pipeline_state_cache.h

@@ -15,10 +15,13 @@
 { reinterpret_cast<GuestShader*>(0x36DB3B40FA419EF6),reinterpret_cast<GuestShader*>(0x4FDE8FFB7DC1D1CE),reinterpret_cast<GuestVertexDeclaration*>(0x84BACD816D86543C),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
 { reinterpret_cast<GuestShader*>(0x36DB3B40FA419EF6),reinterpret_cast<GuestShader*>(0xD56D0D7219E51F1D),reinterpret_cast<GuestVertexDeclaration*>(0x84BACD816D86543C),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
 { reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0x115813F8DBF6CCFF),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
+{ reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0x3073F2C856F3333E),reinterpret_cast<GuestVertexDeclaration*>(0xF10787EFFEEC0153),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0x3382CD5552FAB33C),reinterpret_cast<GuestVertexDeclaration*>(0xB7BBCC93738C9DE4),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0x47CDF40D1C605E0D),reinterpret_cast<GuestVertexDeclaration*>(0x84BACD816D86543C),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x14 },
 { reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0x6563290A54293E7A),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
+{ reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0x6563290A54293E7A),reinterpret_cast<GuestVertexDeclaration*>(0xF10787EFFEEC0153),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0x6563290A54293E7A),reinterpret_cast<GuestVertexDeclaration*>(0xF10787EFFEEC0153),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
+{ reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0x6563290A54293E7A),reinterpret_cast<GuestVertexDeclaration*>(0xF10787EFFEEC0153),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x15 },
 { reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0x7A8F23548FF778),reinterpret_cast<GuestVertexDeclaration*>(0xC64D046063DE2F63),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x15 },
 { reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0x85E3EE1021089A76),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0x933E17818464BC39),reinterpret_cast<GuestVertexDeclaration*>(0xB7BBCC93738C9DE4),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x15 },
@@ -27,6 +30,7 @@
 { reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0xB8F71746F39A1166),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0xF9F82EC882CD3D08),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x3A4537B51DE9818),reinterpret_cast<GuestShader*>(0xF9F82EC882CD3D08),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
+{ reinterpret_cast<GuestShader*>(0x40E4064FE517DFD2),reinterpret_cast<GuestShader*>(0x11958CFF684E1F4B),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::LESS,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
 { reinterpret_cast<GuestShader*>(0x4620B236DC38100C),reinterpret_cast<GuestShader*>(0xBBDB735BEACC8F41),reinterpret_cast<GuestVertexDeclaration*>(0x28FD2057B9BD5D1B),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::D32_FLOAT,1,false,0x10 },
 { reinterpret_cast<GuestShader*>(0x4620B236DC38100C),reinterpret_cast<GuestShader*>(0xBBDB735BEACC8F41),reinterpret_cast<GuestVertexDeclaration*>(0x2A6D72391BFFFA3C),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x4620B236DC38100C),reinterpret_cast<GuestShader*>(0xBBDB735BEACC8F41),reinterpret_cast<GuestVertexDeclaration*>(0x2A6D72391BFFFA3C),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::ONE,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::D32_FLOAT,1,false,0x11 },
@@ -53,11 +57,13 @@
 { reinterpret_cast<GuestShader*>(0x624F608ACB374E12),reinterpret_cast<GuestShader*>(0xA624AF834723B59),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x624F608ACB374E12),reinterpret_cast<GuestShader*>(0xA624AF834723B59),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x624F608ACB374E12),reinterpret_cast<GuestShader*>(0xA624AF834723B59),reinterpret_cast<GuestVertexDeclaration*>(0xF10787EFFEEC0153),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
+{ reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0x2CA0127E60EB4507),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0x2E5AA3C0A9E32751),reinterpret_cast<GuestVertexDeclaration*>(0xB7BBCC93738C9DE4),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0x326BB3169FF92317),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0x3838E2D27966B21C),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0x5A75A52C3F722625),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0x86CD1B8641C60EE6),reinterpret_cast<GuestVertexDeclaration*>(0xC64D046063DE2F63),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
+{ reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0x874793F8CC9C7EB0),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0xB0F7121362A63137),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0xB0F7121362A63137),reinterpret_cast<GuestVertexDeclaration*>(0xF10787EFFEEC0153),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0xB23ACF01C99C2988),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
@@ -65,6 +71,7 @@
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0xC03A891201D4E9E7),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x15 },
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0xCE7A73C836F03E6),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0xD4D1534DD857403),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
+{ reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0xD4D1534DD857403),reinterpret_cast<GuestVertexDeclaration*>(0xF10787EFFEEC0153),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0xD4D1534DD857403),reinterpret_cast<GuestVertexDeclaration*>(0xF10787EFFEEC0153),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0xE1748A1E1E38FC5F),reinterpret_cast<GuestVertexDeclaration*>(0x6538EB0019C3A29A),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 52,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x15 },
 { reinterpret_cast<GuestShader*>(0x666E7FB7FCAE0FB7),reinterpret_cast<GuestShader*>(0xE1748A1E1E38FC5F),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x15 },
@@ -94,6 +101,7 @@
 { reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x9FA5AACB5B14A226),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
 { reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0xC47F2F91BA2A5D86),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
 { reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0xFB79F59782376846),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0xFF42BE2DBCE820C9),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
 { reinterpret_cast<GuestShader*>(0x720D6E5EDA78433B),reinterpret_cast<GuestShader*>(0x96EACBACDE1AAFAA),reinterpret_cast<GuestVertexDeclaration*>(0xA81F28FA43A9B511),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::ONE,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 36,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
 { reinterpret_cast<GuestShader*>(0x720D6E5EDA78433B),reinterpret_cast<GuestShader*>(0x96EACBACDE1AAFAA),reinterpret_cast<GuestVertexDeclaration*>(0xA81F28FA43A9B511),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::ONE,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 36,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x14 },
 { reinterpret_cast<GuestShader*>(0x734799D14CC5177E),reinterpret_cast<GuestShader*>(0xC9978EB328E1066E),reinterpret_cast<GuestVertexDeclaration*>(0x84BACD816D86543C),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
@@ -104,6 +112,7 @@
 { reinterpret_cast<GuestShader*>(0x86FE3502D5EC24AA),reinterpret_cast<GuestShader*>(0x68FCC0B90EBC457B),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::LESS,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::B8G8R8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
 { reinterpret_cast<GuestShader*>(0x86FE3502D5EC24AA),reinterpret_cast<GuestShader*>(0x94A71CC9B94E3101),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16_FLOAT,RenderFormat::UNKNOWN,1,false,0x0 },
 { reinterpret_cast<GuestShader*>(0x88F67387B88F932F),reinterpret_cast<GuestShader*>(0x49101E452DF2FE98),reinterpret_cast<GuestVertexDeclaration*>(0x84BACD816D86543C),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
+{ reinterpret_cast<GuestShader*>(0x8E4BB23465BD909E),reinterpret_cast<GuestShader*>(0x0),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::FRONT,RenderComparisonFunction::LESS_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0x0,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::UNKNOWN,RenderFormat::D32_FLOAT,1,false,0x0 },
 { reinterpret_cast<GuestShader*>(0x8E4BB23465BD909E),reinterpret_cast<GuestShader*>(0x0),reinterpret_cast<GuestVertexDeclaration*>(0xFFFDDC62D86892F1),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS_EQUAL,false,RenderBlendOperation::ADD,1,33554,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0x0,RenderPrimitiveTopology::TRIANGLE_LIST,{ 32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::UNKNOWN,RenderFormat::D32_FLOAT,1,false,0x0 },
 { reinterpret_cast<GuestShader*>(0x8E4BB23465BD909E),reinterpret_cast<GuestShader*>(0x0),reinterpret_cast<GuestVertexDeclaration*>(0xFFFDDC62D86892F1),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS_EQUAL,false,RenderBlendOperation::ADD,1,33554,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0x0,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::UNKNOWN,RenderFormat::D32_FLOAT,1,false,0x0 },
 { reinterpret_cast<GuestShader*>(0x8EA8F71BA3BE59E7),reinterpret_cast<GuestShader*>(0xA557DD8B24CD2B25),reinterpret_cast<GuestVertexDeclaration*>(0xEC0CD05EE1B1636),false,false,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::LESS,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_LIST,{ 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::UNKNOWN,1,false,0x10 },
@@ -145,6 +154,7 @@
 { reinterpret_cast<GuestShader*>(0xA4CF0215A03D9571),reinterpret_cast<GuestShader*>(0xA3A659F1590CC180),reinterpret_cast<GuestVertexDeclaration*>(0x5A2395E29F93DA3C),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_FAN,{ 32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
 { reinterpret_cast<GuestShader*>(0xA59B07C00039C660),reinterpret_cast<GuestShader*>(0x2E69CC2B4937A698),reinterpret_cast<GuestVertexDeclaration*>(0xFB4544424558E4C),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0xA59B07C00039C660),reinterpret_cast<GuestShader*>(0xF6FAD0CDA667264),reinterpret_cast<GuestVertexDeclaration*>(0xFB4544424558E4C),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
+{ reinterpret_cast<GuestShader*>(0xA790E2F622DADAD8),reinterpret_cast<GuestShader*>(0xD56D0D7219E51F1D),reinterpret_cast<GuestVertexDeclaration*>(0x84BACD816D86543C),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
 { reinterpret_cast<GuestShader*>(0xA7C9D01F7AD3B9D0),reinterpret_cast<GuestShader*>(0x481905CF40E1678D),reinterpret_cast<GuestVertexDeclaration*>(0x84BACD816D86543C),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x14 },
 { reinterpret_cast<GuestShader*>(0xA7C9D01F7AD3B9D0),reinterpret_cast<GuestShader*>(0x481905CF40E1678D),reinterpret_cast<GuestVertexDeclaration*>(0xC64D046063DE2F63),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0xAC38B793E9C54AC5),reinterpret_cast<GuestShader*>(0x24CAF5A2F1B2AF40),reinterpret_cast<GuestVertexDeclaration*>(0x3CB3EF6B1C43B8C),true,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
@@ -163,6 +173,8 @@
 { reinterpret_cast<GuestShader*>(0xBE3AD1D0FE788D2),reinterpret_cast<GuestShader*>(0x4CB3784D7108745F),reinterpret_cast<GuestVertexDeclaration*>(0xFB4544424558E4C),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0xBE3AD1D0FE788D2),reinterpret_cast<GuestShader*>(0xD57D71ED84D8F864),reinterpret_cast<GuestVertexDeclaration*>(0xFB4544424558E4C),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0xCF28F33974EC44F6),reinterpret_cast<GuestShader*>(0xD5EA32DB758EF0B8),reinterpret_cast<GuestVertexDeclaration*>(0x7F12180DC3A24B53),true,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 32,24,4,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x14 },
+{ reinterpret_cast<GuestShader*>(0xD738D79626374EBE),reinterpret_cast<GuestShader*>(0x47CDF40D1C605E0D),reinterpret_cast<GuestVertexDeclaration*>(0x84BACD816D86543C),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
+{ reinterpret_cast<GuestShader*>(0xD738D79626374EBE),reinterpret_cast<GuestShader*>(0x47CDF40D1C605E0D),reinterpret_cast<GuestVertexDeclaration*>(0xB7BBCC93738C9DE4),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0x0,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::UNKNOWN,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0xD738D79626374EBE),reinterpret_cast<GuestShader*>(0x47CDF40D1C605E0D),reinterpret_cast<GuestVertexDeclaration*>(0xFB4544424558E4C),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0xD738D79626374EBE),reinterpret_cast<GuestShader*>(0x47CDF40D1C605E0D),reinterpret_cast<GuestVertexDeclaration*>(0xFB4544424558E4C),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x15 },
 { reinterpret_cast<GuestShader*>(0xD738D79626374EBE),reinterpret_cast<GuestShader*>(0x96B8F9FDAAB9B658),reinterpret_cast<GuestVertexDeclaration*>(0x84BACD816D86543C),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x14 },
@@ -196,6 +208,7 @@
 { reinterpret_cast<GuestShader*>(0xECC9C0BD668FE449),reinterpret_cast<GuestShader*>(0x4C4032F88196B450),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0xECC9C0BD668FE449),reinterpret_cast<GuestShader*>(0xC7E2C782C058A625),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0xECC9C0BD668FE449),reinterpret_cast<GuestShader*>(0xFB66DF5D27D3891D),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
+{ reinterpret_cast<GuestShader*>(0xF060DE53CF3B9BB8),reinterpret_cast<GuestShader*>(0xEAADA73091BF526C),reinterpret_cast<GuestVertexDeclaration*>(0xDEB308DCDDF979C7),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x15 },
 { reinterpret_cast<GuestShader*>(0xF066433D33B62D54),reinterpret_cast<GuestShader*>(0xE5256B7D753C9D5F),reinterpret_cast<GuestVertexDeclaration*>(0x3CB3EF6B1C43B8C),true,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
 { reinterpret_cast<GuestShader*>(0xF1D7C544D61D055C),reinterpret_cast<GuestShader*>(0x5A75A52C3F722625),reinterpret_cast<GuestVertexDeclaration*>(0xF10787EFFEEC0153),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
 { reinterpret_cast<GuestShader*>(0xF58C10092C9EF1AF),reinterpret_cast<GuestShader*>(0x1DD6832FA7E79530),reinterpret_cast<GuestVertexDeclaration*>(0x84BACD816D86543C),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },

UnleashedRecomp/gpu/imgui/imgui_common.cpp

@@ -11,7 +11,7 @@ ImGuiCallbackData* AddImGuiCallback(ImGuiCallback callback)
     auto& callbackData = g_callbackData[g_callbackDataIndex];
     ++g_callbackDataIndex;
 
-    ImGui::GetForegroundDrawList()->AddCallback(reinterpret_cast<ImDrawCallback>(callback), callbackData.get());
+    ImGui::GetBackgroundDrawList()->AddCallback(reinterpret_cast<ImDrawCallback>(callback), callbackData.get());
 
     return callbackData.get();
 }

UnleashedRecomp/gpu/imgui/imgui_common.h

@@ -11,6 +11,7 @@
 #define IMGUI_SHADER_MODIFIER_TITLE_BEVEL              8
 #define IMGUI_SHADER_MODIFIER_CATEGORY_BEVEL           9
 #define IMGUI_SHADER_MODIFIER_RECTANGLE_BEVEL          10
+#define IMGUI_SHADER_MODIFIER_LOW_QUALITY_TEXT         11
 
 #ifdef __cplusplus
 

UnleashedRecomp/gpu/imgui/imgui_font_builder.cpp

@@ -220,6 +220,8 @@ static bool FontBuilder_Build(ImFontAtlas* atlas)
 
     for (size_t i = 0; i < atlas->ConfigData.size(); i++)
     {
+        double spaceAdvance = 0.0;
+
         auto& config = atlas->ConfigData[i];
         bool increaseSpacing = strstr(config.Name, "Seurat") != nullptr;
 
@@ -232,8 +234,15 @@ static bool FontBuilder_Build(ImFontAtlas* atlas)
             glyph.getQuadAtlasBounds(u0, v0, u1, v1);
 
             double advance = glyph.getAdvance();
-            if (increaseSpacing && glyph.getCodepoint() == ' ')
-                advance *= 1.5;
+            if (glyph.getCodepoint() == ' ')
+            {
+                if (increaseSpacing)
+                {
+                    advance *= 1.5;
+                }
+
+                spaceAdvance = advance;
+            }
 
             config.DstFont->AddGlyph(
                 &config,
@@ -248,6 +257,39 @@ static bool FontBuilder_Build(ImFontAtlas* atlas)
                 v0 / packer.height, 
                 advance);
         }
+        
+        // Used as a zero-width helper for automatic line breaks.
+        // This is useful for languages like Japanese to separate 'words'
+        // so that they don't get split mid-kana by the automatic splitter.
+        config.DstFont->AddGlyph(
+            &config,
+            0x200B,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f);
+
+        // A duplicate of the normal width space character.
+        // Overrides the unicode Four-Per-Em Space character.
+        // This can be used to add visual spacers that are ignored
+        // by the automatic line splitting logic.
+        config.DstFont->AddGlyph(
+            &config,
+            0x2005,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            spaceAdvance);
 
         config.DstFont->BuildLookupTable();
     }

UnleashedRecomp/gpu/rhi/plume_d3d12.cpp

@@ -1437,6 +1437,52 @@ namespace plume {
         return height;
     }
 
+    // D3D12QueryPool
+
+    D3D12QueryPool::D3D12QueryPool(D3D12Device *device, uint32_t queryCount) {
+        assert(device != nullptr);
+        assert(queryCount > 0);
+
+        this->device = device;
+
+        D3D12_QUERY_HEAP_DESC queryHeapDesc = {};
+        queryHeapDesc.Type = D3D12_QUERY_HEAP_TYPE_TIMESTAMP;
+        queryHeapDesc.Count = queryCount;
+
+        HRESULT res = device->d3d->CreateQueryHeap(&queryHeapDesc, IID_PPV_ARGS(&d3d));
+        if (FAILED(res)) {
+            fprintf(stderr, "CreateQueryHeap failed with error code 0x%lX.\n", res);
+            return;
+        }
+
+        readbackBuffer = device->createBuffer(RenderBufferDesc::ReadbackBuffer(sizeof(uint64_t) * queryCount));
+        results.resize(queryCount);
+    }
+
+    D3D12QueryPool::~D3D12QueryPool() {
+        if (d3d != nullptr) {
+            d3d->Release();
+        }
+    }
+
+    void D3D12QueryPool::queryResults() {
+        void *readbackData = readbackBuffer->map();
+        memcpy(results.data(), readbackData, sizeof(uint64_t) * results.size());
+        readbackBuffer->unmap();
+
+        for (uint64_t &result : results) {
+            result = result / double(device->timestampFrequency) * 1000000000.0;
+        }
+    }
+
+    const uint64_t *D3D12QueryPool::getResults() const {
+        return results.data();
+    }
+
+    uint32_t D3D12QueryPool::getCount() const {
+        return uint32_t(results.size());
+    }
+
     // D3D12CommandList
 
     D3D12CommandList::D3D12CommandList(D3D12Device *device, RenderCommandListType type) {
@@ -2004,6 +2050,19 @@ namespace plume {
         d3d->DiscardResource(interfaceTexture->d3d, nullptr);
     }
 
+    void D3D12CommandList::resetQueryPool(const RenderQueryPool *queryPool, uint32_t queryFirstIndex, uint32_t queryCount) {
+        // Do nothing.
+    }
+
+    void D3D12CommandList::writeTimestamp(const RenderQueryPool *queryPool, uint32_t queryIndex) {
+        assert(queryPool != nullptr);
+
+        const D3D12QueryPool *interfaceQueryPool = static_cast<const D3D12QueryPool *>(queryPool);
+        const D3D12Buffer *readbackBuffer = static_cast<const D3D12Buffer *>(interfaceQueryPool->readbackBuffer.get());
+        d3d->EndQuery(interfaceQueryPool->d3d, D3D12_QUERY_TYPE_TIMESTAMP, queryIndex);
+        d3d->ResolveQueryData(interfaceQueryPool->d3d, D3D12_QUERY_TYPE_TIMESTAMP, queryIndex, 1, readbackBuffer->d3d, queryIndex * sizeof(uint64_t));
+    }
+
     void D3D12CommandList::checkDescriptorHeaps() {
         if (!descriptorHeapsSet) {
             ID3D12DescriptorHeap *descriptorHeaps[] = { device->viewHeapAllocator->heap, device->samplerHeapAllocator->heap };
@@ -3259,7 +3318,7 @@ namespace plume {
 
     // D3D12Device
 
-    D3D12Device::D3D12Device(D3D12Interface *renderInterface) {
+    D3D12Device::D3D12Device(D3D12Interface *renderInterface, const std::string &preferredDeviceName) {
         assert(renderInterface != nullptr);
 
         this->renderInterface = renderInterface;
@@ -3349,9 +3408,10 @@ namespace plume {
             }
 
             // Pick this adapter and device if it has better feature support than the current one.
+            std::string deviceName = Utf16ToUtf8(adapterDesc.Description);
             bool preferOverNothing = (adapter == nullptr) || (d3d == nullptr);
             bool preferVideoMemory = adapterDesc.DedicatedVideoMemory > description.dedicatedVideoMemory;
-            bool preferUserChoice = false;//wcsstr(adapterDesc.Description, L"AMD") != nullptr;
+            bool preferUserChoice = preferredDeviceName == deviceName;
             bool preferOption = preferOverNothing || preferVideoMemory || preferUserChoice;
             if (preferOption) {
                 if (d3d != nullptr) {
@@ -3371,8 +3431,15 @@ namespace plume {
                 capabilities.triangleFan = triangleFanSupportOption;
                 capabilities.dynamicDepthBias = dynamicDepthBiasOption;
                 capabilities.uma = uma;
-                description.name = Utf16ToUtf8(adapterDesc.Description);
+                description.name = deviceName;
                 description.dedicatedVideoMemory = adapterDesc.DedicatedVideoMemory;
+                description.vendor = RenderDeviceVendor(adapterDesc.VendorId);
+
+                LARGE_INTEGER adapterVersion = {};
+                res = adapter->CheckInterfaceSupport(__uuidof(IDXGIDevice), &adapterVersion);
+                if (SUCCEEDED(res)) {
+                    description.driverVersion = adapterVersion.QuadPart;
+                }
 
                 if (preferUserChoice) {
                     break;
@@ -3460,6 +3527,13 @@ namespace plume {
         samplerHeapAllocator = std::make_unique<D3D12DescriptorHeapAllocator>(this, SamplerDescriptorHeapSize, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
         colorTargetHeapAllocator = std::make_unique<D3D12DescriptorHeapAllocator>(this, TargetDescriptorHeapSize, D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
         depthTargetHeapAllocator = std::make_unique<D3D12DescriptorHeapAllocator>(this, TargetDescriptorHeapSize, D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
+
+        // Create a command queue only for retrieving the timestamp frequency. Delete it immediately afterwards.
+        std::unique_ptr<D3D12CommandQueue> timestampCommandQueue = std::make_unique<D3D12CommandQueue>(this, RenderCommandListType::DIRECT);
+        res = timestampCommandQueue->d3d->GetTimestampFrequency(&timestampFrequency);
+        if (FAILED(res)) {
+            fprintf(stderr, "GetTimestampFrequency failed with error code 0x%lX. Timestamps will be inaccurate.\n", res);
+        }
     }
 
     D3D12Device::~D3D12Device() {
@@ -3534,6 +3608,10 @@ namespace plume {
         return std::make_unique<D3D12Framebuffer>(this, desc);
     }
 
+    std::unique_ptr<RenderQueryPool> D3D12Device::createQueryPool(uint32_t queryCount) {
+        return std::make_unique<D3D12QueryPool>(this, queryCount);
+    }
+
     void D3D12Device::setBottomLevelASBuildInfo(RenderBottomLevelASBuildInfo &buildInfo, const RenderBottomLevelASMesh *meshes, uint32_t meshCount, bool preferFastBuild, bool preferFastTrace) {
         assert(meshes != nullptr);
         assert(meshCount > 0);
@@ -3767,6 +3845,21 @@ namespace plume {
 
         // Fill capabilities.
         capabilities.shaderFormat = RenderShaderFormat::DXIL;
+
+        // Fill device names.
+        UINT adapterIndex = 0;
+        IDXGIAdapter1 *adapterOption = nullptr;
+        while (dxgiFactory->EnumAdapters1(adapterIndex++, &adapterOption) != DXGI_ERROR_NOT_FOUND) {
+            DXGI_ADAPTER_DESC1 adapterDesc;
+            adapterOption->GetDesc1(&adapterDesc);
+
+            // Ignore remote or software adapters.
+            if ((adapterDesc.Flags & (DXGI_ADAPTER_FLAG_REMOTE | DXGI_ADAPTER_FLAG_SOFTWARE)) == 0) {
+                deviceNames.emplace_back(Utf16ToUtf8(adapterDesc.Description));
+            }
+
+            adapterOption->Release();
+        }
     }
 
     D3D12Interface::~D3D12Interface() {
@@ -3775,8 +3868,8 @@ namespace plume {
         }
     }
 
-    std::unique_ptr<RenderDevice> D3D12Interface::createDevice() {
-        std::unique_ptr<D3D12Device> createdDevice = std::make_unique<D3D12Device>(this);
+    std::unique_ptr<RenderDevice> D3D12Interface::createDevice(const std::string &preferredDeviceName) {
+        std::unique_ptr<D3D12Device> createdDevice = std::make_unique<D3D12Device>(this, preferredDeviceName);
         return createdDevice->isValid() ? std::move(createdDevice) : nullptr;
     }
 
@@ -3784,6 +3877,10 @@ namespace plume {
         return capabilities;
     }
 
+    const std::vector<std::string> &D3D12Interface::getDeviceNames() const {
+        return deviceNames;
+    }
+
     bool D3D12Interface::isValid() const {
         return dxgiFactory != nullptr;
     }

UnleashedRecomp/gpu/rhi/plume_d3d12.h

@@ -144,6 +144,19 @@ namespace plume {
         uint32_t getHeight() const override;
     };
 
+    struct D3D12QueryPool : RenderQueryPool {
+        D3D12Device *device = nullptr;
+        ID3D12QueryHeap *d3d = nullptr;
+        std::vector<uint64_t> results;
+        std::unique_ptr<RenderBuffer> readbackBuffer;
+
+        D3D12QueryPool(D3D12Device *device, uint32_t queryCount);
+        virtual ~D3D12QueryPool() override;
+        virtual void queryResults() override;
+        virtual const uint64_t *getResults() const override;
+        virtual uint32_t getCount() const override;
+    };
+
     struct D3D12CommandList : RenderCommandList {
         ID3D12GraphicsCommandList9 *d3d = nullptr;
         ID3D12CommandAllocator *commandAllocator = nullptr;
@@ -196,6 +209,8 @@ namespace plume {
         void buildBottomLevelAS(const RenderAccelerationStructure *dstAccelerationStructure, RenderBufferReference scratchBuffer, const RenderBottomLevelASBuildInfo &buildInfo) override;
         void buildTopLevelAS(const RenderAccelerationStructure *dstAccelerationStructure, RenderBufferReference scratchBuffer, RenderBufferReference instancesBuffer, const RenderTopLevelASBuildInfo &buildInfo) override;
         void discardTexture(const RenderTexture* texture) override;
+        void resetQueryPool(const RenderQueryPool *queryPool, uint32_t queryFirstIndex, uint32_t queryCount) override;
+        void writeTimestamp(const RenderQueryPool *queryPool, uint32_t queryIndex) override;
         void checkDescriptorHeaps();
         void notifyDescriptorHeapWasChangedExternally();
         void checkTopology();
@@ -417,8 +432,9 @@ namespace plume {
         std::unique_ptr<D3D12DescriptorHeapAllocator> depthTargetHeapAllocator;
         RenderDeviceCapabilities capabilities;
         RenderDeviceDescription description;
+        uint64_t timestampFrequency = 1;
 
-        D3D12Device(D3D12Interface *renderInterface);
+        D3D12Device(D3D12Interface *renderInterface, const std::string &preferredDeviceName);
         ~D3D12Device() override;
         std::unique_ptr<RenderCommandList> createCommandList(RenderCommandListType type) override;
         std::unique_ptr<RenderDescriptorSet> createDescriptorSet(const RenderDescriptorSetDesc &desc) override;
@@ -436,6 +452,7 @@ namespace plume {
         std::unique_ptr<RenderCommandFence> createCommandFence() override;
         std::unique_ptr<RenderCommandSemaphore> createCommandSemaphore() override;
         std::unique_ptr<RenderFramebuffer> createFramebuffer(const RenderFramebufferDesc &desc) override;
+        std::unique_ptr<RenderQueryPool> createQueryPool(uint32_t queryCount) override;
         void setBottomLevelASBuildInfo(RenderBottomLevelASBuildInfo &buildInfo, const RenderBottomLevelASMesh *meshes, uint32_t meshCount, bool preferFastBuild, bool preferFastTrace) override;
         void setTopLevelASBuildInfo(RenderTopLevelASBuildInfo &buildInfo, const RenderTopLevelASInstance *instances, uint32_t instanceCount, bool preferFastBuild, bool preferFastTrace) override;
         void setShaderBindingTableInfo(RenderShaderBindingTableInfo &tableInfo, const RenderShaderBindingGroups &groups, const RenderPipeline *pipeline, RenderDescriptorSet **descriptorSets, uint32_t descriptorSetCount) override;
@@ -450,11 +467,13 @@ namespace plume {
     struct D3D12Interface : RenderInterface {
         IDXGIFactory4 *dxgiFactory = nullptr;
         RenderInterfaceCapabilities capabilities;
+        std::vector<std::string> deviceNames;
 
         D3D12Interface();
         ~D3D12Interface() override;
-        std::unique_ptr<RenderDevice> createDevice() override;
+        std::unique_ptr<RenderDevice> createDevice(const std::string &preferredDeviceName) override;
         const RenderInterfaceCapabilities &getCapabilities() const override;
+        const std::vector<std::string> &getDeviceNames() const override;
         bool isValid() const;
     };
 };

UnleashedRecomp/gpu/rhi/plume_render_interface.h

@@ -147,6 +147,8 @@ namespace plume {
         virtual void buildBottomLevelAS(const RenderAccelerationStructure *dstAccelerationStructure, RenderBufferReference scratchBuffer, const RenderBottomLevelASBuildInfo &buildInfo) = 0;
         virtual void buildTopLevelAS(const RenderAccelerationStructure *dstAccelerationStructure, RenderBufferReference scratchBuffer, RenderBufferReference instancesBuffer, const RenderTopLevelASBuildInfo &buildInfo) = 0;
         virtual void discardTexture(const RenderTexture* texture) = 0; // D3D12 only.
+        virtual void resetQueryPool(const RenderQueryPool *queryPool, uint32_t queryFirstIndex, uint32_t queryCount) = 0;
+        virtual void writeTimestamp(const RenderQueryPool *queryPool, uint32_t queryIndex) = 0;
 
         // Concrete implementation shortcuts.
         inline void barriers(RenderBarrierStages stages, const RenderBufferBarrier &barrier) {
@@ -208,6 +210,13 @@ namespace plume {
         virtual std::unique_ptr<RenderTexture> createTexture(const RenderTextureDesc &desc) = 0;
     };
 
+    struct RenderQueryPool {
+        virtual ~RenderQueryPool() { }
+        virtual void queryResults() = 0;
+        virtual const uint64_t *getResults() const = 0;
+        virtual uint32_t getCount() const = 0;
+    };
+
     struct RenderDevice {
         virtual ~RenderDevice() { }
         virtual std::unique_ptr<RenderCommandList> createCommandList(RenderCommandListType type) = 0;
@@ -226,6 +235,7 @@ namespace plume {
         virtual std::unique_ptr<RenderCommandFence> createCommandFence() = 0;
         virtual std::unique_ptr<RenderCommandSemaphore> createCommandSemaphore() = 0;
         virtual std::unique_ptr<RenderFramebuffer> createFramebuffer(const RenderFramebufferDesc &desc) = 0;
+        virtual std::unique_ptr<RenderQueryPool> createQueryPool(uint32_t queryCount) = 0;
         virtual void setBottomLevelASBuildInfo(RenderBottomLevelASBuildInfo &buildInfo, const RenderBottomLevelASMesh *meshes, uint32_t meshCount, bool preferFastBuild = true, bool preferFastTrace = false) = 0;
         virtual void setTopLevelASBuildInfo(RenderTopLevelASBuildInfo &buildInfo, const RenderTopLevelASInstance *instances, uint32_t instanceCount, bool preferFastBuild = true, bool preferFastTrace = false) = 0;
         virtual void setShaderBindingTableInfo(RenderShaderBindingTableInfo &tableInfo, const RenderShaderBindingGroups &groups, const RenderPipeline *pipeline, RenderDescriptorSet **descriptorSets, uint32_t descriptorSetCount) = 0;
@@ -237,7 +247,8 @@ namespace plume {
 
     struct RenderInterface {
         virtual ~RenderInterface() { }
-        virtual std::unique_ptr<RenderDevice> createDevice() = 0;
+        virtual std::unique_ptr<RenderDevice> createDevice(const std::string &preferredDeviceName = "") = 0;
+        virtual const std::vector<std::string> &getDeviceNames() const = 0;
         virtual const RenderInterfaceCapabilities &getCapabilities() const = 0;
     };
 

UnleashedRecomp/gpu/rhi/plume_render_interface_types.h

@@ -69,9 +69,17 @@ namespace plume {
     struct RenderSampler;
     struct RenderShader;
     struct RenderTexture;
+    struct RenderQueryPool;
 
     // Enums.
 
+    enum class RenderDeviceVendor {
+        UNKNOWN = 0x0,
+        AMD = 0x1002,
+        NVIDIA = 0x10DE,
+        INTEL = 0x8086
+    };
+
     enum class RenderFormat {
         UNKNOWN,
         R32G32B32A32_TYPELESS,
@@ -1769,7 +1777,8 @@ namespace plume {
     struct RenderDeviceDescription {
         std::string name = "Unknown";
         RenderDeviceType type = RenderDeviceType::UNKNOWN;
-        uint32_t driverVersion = 0;
+        RenderDeviceVendor vendor = RenderDeviceVendor::UNKNOWN;
+        uint64_t driverVersion = 0;
         uint64_t dedicatedVideoMemory = 0;
     };
 

UnleashedRecomp/gpu/rhi/plume_vulkan.cpp

@@ -2522,6 +2522,80 @@ namespace plume {
         return (depthAttachment == attachment);
     }
 
+    // VulkanQueryPool
+
+    VulkanQueryPool::VulkanQueryPool(VulkanDevice *device, uint32_t queryCount) {
+        assert(device != nullptr);
+        assert(queryCount > 0);
+
+        this->device = device;
+
+        VkQueryPoolCreateInfo createInfo = {};
+        createInfo.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
+        createInfo.queryType = VK_QUERY_TYPE_TIMESTAMP;
+        createInfo.queryCount = queryCount;
+        
+        VkResult res = vkCreateQueryPool(device->vk, &createInfo, nullptr, &vk);
+        if (res != VK_SUCCESS) {
+            fprintf(stderr, "vkCreateQueryPool failed with error code 0x%X.\n", res);
+            return;
+        }
+        
+        results.resize(queryCount);
+    }
+
+    VulkanQueryPool::~VulkanQueryPool() {
+        vkDestroyQueryPool(device->vk, vk, nullptr);
+    }
+
+    void VulkanQueryPool::queryResults() {
+	    VkResult res = vkGetQueryPoolResults(device->vk, vk, 0, uint32_t(results.size()), sizeof(uint64_t) * results.size(), results.data(), sizeof(uint64_t), VK_QUERY_RESULT_64_BIT);
+        if (res != VK_SUCCESS) {
+            fprintf(stderr, "vkGetQueryPoolResults failed with error code 0x%X.\n", res);
+            return;
+        }
+
+        // Conversion sourced from Godot Engine's Vulkan Rendering Driver.
+        auto mult64to128 = [](uint64_t u, uint64_t v, uint64_t &h, uint64_t &l) {
+            uint64_t u1 = (u & 0xffffffff);
+            uint64_t v1 = (v & 0xffffffff);
+            uint64_t t = (u1 * v1);
+            uint64_t w3 = (t & 0xffffffff);
+            uint64_t k = (t >> 32);
+    
+            u >>= 32;
+            t = (u * v1) + k;
+            k = (t & 0xffffffff);
+            uint64_t w1 = (t >> 32);
+    
+            v >>= 32;
+            t = (u1 * v) + k;
+            k = (t >> 32);
+    
+            h = (u * v) + w1 + k;
+            l = (t << 32) + w3;
+        };
+
+        // Convert results to timestamps.
+        constexpr uint64_t shift_bits = 16;
+        double timestampPeriod = double(device->physicalDeviceProperties.limits.timestampPeriod);
+        uint64_t h = 0, l = 0;
+        for (uint64_t &result : results) {
+            mult64to128(result, uint64_t(timestampPeriod * double(1 << shift_bits)), h, l);
+            result = l;
+            result >>= shift_bits;
+            result |= h << (64 - shift_bits);
+        }
+    }
+
+    const uint64_t *VulkanQueryPool::getResults() const {
+        return results.data();
+    }
+
+    uint32_t VulkanQueryPool::getCount() const {
+        return uint32_t(results.size());
+    }
+
     // VulkanCommandList
 
     VulkanCommandList::VulkanCommandList(VulkanDevice *device, RenderCommandListType type) {
@@ -3210,6 +3284,20 @@ namespace plume {
         // Not required in Vulkan.
     }
 
+    void VulkanCommandList::resetQueryPool(const RenderQueryPool *queryPool, uint32_t queryFirstIndex, uint32_t queryCount) {
+        assert(queryPool != nullptr);
+
+        const VulkanQueryPool *interfaceQueryPool = static_cast<const VulkanQueryPool *>(queryPool);
+        vkCmdResetQueryPool(vk, interfaceQueryPool->vk, queryFirstIndex, queryCount);
+    }
+
+    void VulkanCommandList::writeTimestamp(const RenderQueryPool *queryPool, uint32_t queryIndex) {
+        assert(queryPool != nullptr);
+
+        const VulkanQueryPool *interfaceQueryPool = static_cast<const VulkanQueryPool *>(queryPool);
+        vkCmdWriteTimestamp(vk, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, interfaceQueryPool->vk, queryIndex);
+    }
+
     void VulkanCommandList::checkActiveRenderPass() {
         assert(targetFramebuffer != nullptr);
         
@@ -3473,7 +3561,7 @@ namespace plume {
 
     // VulkanDevice
     
-    VulkanDevice::VulkanDevice(VulkanInterface *renderInterface) {
+    VulkanDevice::VulkanDevice(VulkanInterface *renderInterface, const std::string &preferredDeviceName) {
         assert(renderInterface != nullptr);
 
         this->renderInterface = renderInterface;
@@ -3506,15 +3594,22 @@ namespace plume {
                 continue;
             }
 
+            std::string deviceName(deviceProperties.deviceName);
             uint32_t deviceTypeScore = deviceTypeScoreTable[deviceTypeIndex];
             bool preferDeviceTypeScore = (deviceTypeScore > currentDeviceTypeScore);
-            bool preferOption = preferDeviceTypeScore;
+            bool preferUserChoice = preferredDeviceName == deviceName;
+            bool preferOption = preferDeviceTypeScore || preferUserChoice;
             if (preferOption) {
                 physicalDevice = physicalDevices[i];
-                description.name = std::string(deviceProperties.deviceName);
+                description.name = deviceName;
                 description.type = toDeviceType(deviceProperties.deviceType);
                 description.driverVersion = deviceProperties.driverVersion;
+                description.vendor = RenderDeviceVendor(deviceProperties.vendorID);
                 currentDeviceTypeScore = deviceTypeScore;
+
+                if (preferUserChoice) {
+                    break;
+                }
             }
         }
 
@@ -3885,6 +3980,10 @@ namespace plume {
         return std::make_unique<VulkanFramebuffer>(this, desc);
     }
 
+    std::unique_ptr<RenderQueryPool> VulkanDevice::createQueryPool(uint32_t queryCount) {
+        return std::make_unique<VulkanQueryPool>(this, queryCount);
+    }
+
     void VulkanDevice::setBottomLevelASBuildInfo(RenderBottomLevelASBuildInfo &buildInfo, const RenderBottomLevelASMesh *meshes, uint32_t meshCount, bool preferFastBuild, bool preferFastTrace) {
         assert(meshes != nullptr);
         assert(meshCount > 0);
@@ -4233,6 +4332,23 @@ namespace plume {
 
         // Fill capabilities.
         capabilities.shaderFormat = RenderShaderFormat::SPIRV;
+
+        // Fill device names.
+        uint32_t deviceCount = 0;
+        vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
+        if (deviceCount > 0) {
+            std::vector<VkPhysicalDevice> physicalDevices(deviceCount);
+            vkEnumeratePhysicalDevices(instance, &deviceCount, physicalDevices.data());
+
+            for (uint32_t i = 0; i < deviceCount; i++) {
+                VkPhysicalDeviceProperties deviceProperties;
+                vkGetPhysicalDeviceProperties(physicalDevices[i], &deviceProperties);
+                uint32_t deviceTypeIndex = deviceProperties.deviceType;
+                if (deviceTypeIndex <= 4) {
+                    deviceNames.emplace_back(deviceProperties.deviceName);
+                }
+            }
+        }
     }
 
     VulkanInterface::~VulkanInterface() {
@@ -4241,8 +4357,8 @@ namespace plume {
         }
     }
 
-    std::unique_ptr<RenderDevice> VulkanInterface::createDevice() {
-        std::unique_ptr<VulkanDevice> createdDevice = std::make_unique<VulkanDevice>(this);
+    std::unique_ptr<RenderDevice> VulkanInterface::createDevice(const std::string &preferredDeviceName) {
+        std::unique_ptr<VulkanDevice> createdDevice = std::make_unique<VulkanDevice>(this, preferredDeviceName);
         return createdDevice->isValid() ? std::move(createdDevice) : nullptr;
     }
 
@@ -4250,6 +4366,10 @@ namespace plume {
         return capabilities;
     }
 
+    const std::vector<std::string> &VulkanInterface::getDeviceNames() const {
+        return deviceNames;
+    }
+
     bool VulkanInterface::isValid() const {
         return instance != nullptr;
     }

UnleashedRecomp/gpu/rhi/plume_vulkan.h

@@ -271,6 +271,18 @@ namespace plume {
         bool contains(const VulkanTexture *attachment) const;
     };
 
+    struct VulkanQueryPool : RenderQueryPool {
+        VulkanDevice *device = nullptr;
+        std::vector<uint64_t> results;
+        VkQueryPool vk = VK_NULL_HANDLE;
+
+        VulkanQueryPool(VulkanDevice *device, uint32_t queryCount);
+        virtual ~VulkanQueryPool() override;
+        virtual void queryResults() override;
+        virtual const uint64_t *getResults() const override;
+        virtual uint32_t getCount() const override;
+    };
+
     struct VulkanCommandList : RenderCommandList {
         VkCommandBuffer vk = VK_NULL_HANDLE;
         VkCommandPool commandPool = VK_NULL_HANDLE;
@@ -319,6 +331,8 @@ namespace plume {
         void buildBottomLevelAS(const RenderAccelerationStructure *dstAccelerationStructure, RenderBufferReference scratchBuffer, const RenderBottomLevelASBuildInfo &buildInfo) override;
         void buildTopLevelAS(const RenderAccelerationStructure *dstAccelerationStructure, RenderBufferReference scratchBuffer, RenderBufferReference instancesBuffer, const RenderTopLevelASBuildInfo &buildInfo) override;
         void discardTexture(const RenderTexture* texture) override;
+        void resetQueryPool(const RenderQueryPool *queryPool, uint32_t queryFirstIndex, uint32_t queryCount) override;
+        void writeTimestamp(const RenderQueryPool *queryPool, uint32_t queryIndex) override;
         void checkActiveRenderPass();
         void endActiveRenderPass();
         void setDescriptorSet(VkPipelineBindPoint bindPoint, const VulkanPipelineLayout *pipelineLayout, const RenderDescriptorSet *descriptorSet, uint32_t setIndex);
@@ -391,7 +405,7 @@ namespace plume {
         VkPhysicalDeviceSampleLocationsPropertiesEXT sampleLocationProperties = {};
         bool loadStoreOpNoneSupported = false;
 
-        VulkanDevice(VulkanInterface *renderInterface);
+        VulkanDevice(VulkanInterface *renderInterface, const std::string &preferredDeviceName);
         ~VulkanDevice() override;
         std::unique_ptr<RenderCommandList> createCommandList(RenderCommandListType type) override;
         std::unique_ptr<RenderDescriptorSet> createDescriptorSet(const RenderDescriptorSetDesc &desc) override;
@@ -409,6 +423,7 @@ namespace plume {
         std::unique_ptr<RenderCommandFence> createCommandFence() override;
         std::unique_ptr<RenderCommandSemaphore> createCommandSemaphore() override;
         std::unique_ptr<RenderFramebuffer> createFramebuffer(const RenderFramebufferDesc &desc) override;
+        std::unique_ptr<RenderQueryPool> createQueryPool(uint32_t queryCount) override;
         void setBottomLevelASBuildInfo(RenderBottomLevelASBuildInfo &buildInfo, const RenderBottomLevelASMesh *meshes, uint32_t meshCount, bool preferFastBuild, bool preferFastTrace) override;
         void setTopLevelASBuildInfo(RenderTopLevelASBuildInfo &buildInfo, const RenderTopLevelASInstance *instances, uint32_t instanceCount, bool preferFastBuild, bool preferFastTrace) override;
         void setShaderBindingTableInfo(RenderShaderBindingTableInfo &tableInfo, const RenderShaderBindingGroups &groups, const RenderPipeline *pipeline, RenderDescriptorSet **descriptorSets, uint32_t descriptorSetCount) override;
@@ -424,6 +439,7 @@ namespace plume {
         VkInstance instance = VK_NULL_HANDLE;
         VkApplicationInfo appInfo = {};
         RenderInterfaceCapabilities capabilities;
+        std::vector<std::string> deviceNames;
 
 #   if SDL_VULKAN_ENABLED
         VulkanInterface(RenderWindow sdlWindow);
@@ -432,8 +448,9 @@ namespace plume {
 #   endif
 
         ~VulkanInterface() override;
-        std::unique_ptr<RenderDevice> createDevice() override;
+        std::unique_ptr<RenderDevice> createDevice(const std::string &preferredDeviceName) override;
         const RenderInterfaceCapabilities &getCapabilities() const override;
+        const std::vector<std::string> &getDeviceNames() const override;
         bool isValid() const;
     };
 };

UnleashedRecomp/gpu/shader/imgui_common.hlsli

@@ -12,6 +12,7 @@ struct PushConstants
     uint GradientBottomLeft;
     uint ShaderModifier;
     uint Texture2DDescriptorIndex;
+    float2 DisplaySize;
     float2 InverseDisplaySize;
     float2 Origin;
     float2 Scale;

UnleashedRecomp/gpu/shader/imgui_ps.hlsl

@@ -61,10 +61,10 @@ float4 SampleLinear(float2 uvTexspace)
 
 float4 PixelAntialiasing(float2 uvTexspace)
 {    
-    if ((g_PushConstants.InverseDisplaySize.y / g_PushConstants.InverseDisplaySize.x) >= (4.0 / 3.0))
-        uvTexspace *= g_PushConstants.InverseDisplaySize.y * 720.0f;
+    if ((g_PushConstants.DisplaySize.x * g_PushConstants.InverseDisplaySize.y) >= (4.0 / 3.0))
+        uvTexspace *= g_PushConstants.InverseDisplaySize.y * 720.0;
     else
-        uvTexspace *= g_PushConstants.InverseDisplaySize.x * 960.0f;
+        uvTexspace *= g_PushConstants.InverseDisplaySize.x * 960.0;
 
     float2 seam = floor(uvTexspace + 0.5);
     uvTexspace = (uvTexspace - seam) / fwidth(uvTexspace) + seam;
@@ -78,6 +78,51 @@ float median(float r, float g, float b)
     return max(min(r, g), min(max(r, g), b));
 }
 
+float4 SampleSdfFont(float4 color, Texture2D<float4> texture, float2 uv, float2 screenTexSize)
+{
+    float4 textureColor = texture.Sample(g_SamplerDescriptorHeap[0], uv);
+    
+    uint width, height;
+    texture.GetDimensions(width, height);
+            
+    float pxRange = 8.0;
+    float2 unitRange = pxRange / float2(width, height);
+    float screenPxRange = max(0.5 * dot(unitRange, screenTexSize), 1.0);
+            
+    float sd = median(textureColor.r, textureColor.g, textureColor.b) - 0.5;
+    float screenPxDistance = screenPxRange * (sd + g_PushConstants.Outline / (pxRange * 1.5));
+            
+    if (g_PushConstants.ShaderModifier == IMGUI_SHADER_MODIFIER_TITLE_BEVEL)
+    {
+        float2 normal = normalize(float3(ddx(sd), ddy(sd), 0.01)).xy;
+        float3 rimColor = float3(1, 0.8, 0.29);
+        float3 shadowColor = float3(0.84, 0.57, 0);
+
+        float cosTheta = dot(normal, normalize(float2(1, 1)));
+        float3 gradient = lerp(color.rgb, cosTheta >= 0.0 ? rimColor : shadowColor, abs(cosTheta));
+        color.rgb = lerp(gradient, color.rgb, pow(saturate(sd + 0.77), 32.0));
+    }
+    else if (g_PushConstants.ShaderModifier == IMGUI_SHADER_MODIFIER_CATEGORY_BEVEL)
+    {
+        float2 normal = normalize(float3(ddx(sd), ddy(sd), 0.25)).xy;
+        float cosTheta = dot(normal, normalize(float2(1, 1)));
+        float gradient = 1.0 + cosTheta * 0.5;
+        color.rgb = saturate(color.rgb * gradient);
+    }
+    else if (g_PushConstants.ShaderModifier == IMGUI_SHADER_MODIFIER_TEXT_SKEW)
+    {
+        float2 normal = normalize(float3(ddx(sd), ddy(sd), 0.5)).xy;
+        float cosTheta = dot(normal, normalize(float2(1, 1)));
+        float gradient = saturate(1.0 + cosTheta);
+        color.rgb = lerp(color.rgb * gradient, color.rgb, pow(saturate(sd + 0.77), 32.0));
+    }
+
+    color.a *= saturate(screenPxDistance + 0.5);
+    color.a *= textureColor.a;
+    
+    return color;
+}
+
 float4 main(in Interpolators interpolators) : SV_Target
 {
     float4 color = interpolators.Color;
@@ -86,52 +131,50 @@ float4 main(in Interpolators interpolators) : SV_Target
     if (g_PushConstants.Texture2DDescriptorIndex != 0)
     {
         Texture2D<float4> texture = g_Texture2DDescriptorHeap[g_PushConstants.Texture2DDescriptorIndex & 0x7FFFFFFF];
-        float4 textureColor = texture.Sample(g_SamplerDescriptorHeap[0], interpolators.UV);
         
         if ((g_PushConstants.Texture2DDescriptorIndex & 0x80000000) != 0)
         {
-            uint width, height;
-            texture.GetDimensions(width, height);
-            
-            float pxRange = 8.0;
-            float2 unitRange = pxRange / float2(width, height);
-            float2 screenTexSize = 1.0 / fwidth(interpolators.UV);
-            float screenPxRange = max(0.5 * dot(unitRange, screenTexSize), 1.0);
-            
-            float sd = median(textureColor.r, textureColor.g, textureColor.b) - 0.5;
-            float screenPxDistance = screenPxRange * (sd + g_PushConstants.Outline / (pxRange * 2.0));
-            
-            if (g_PushConstants.ShaderModifier == IMGUI_SHADER_MODIFIER_TITLE_BEVEL)
+            if (g_PushConstants.ShaderModifier == IMGUI_SHADER_MODIFIER_LOW_QUALITY_TEXT)
             {
-                float2 normal = normalize(float3(ddx(sd), ddy(sd), 0.01)).xy;
-                float3 rimColor = float3(1, 0.8, 0.29);
-                float3 shadowColor = float3(0.84, 0.57, 0);
-
-                float cosTheta = dot(normal, normalize(float2(1, 1)));
-                float3 gradient = lerp(color.rgb, cosTheta >= 0.0 ? rimColor : shadowColor, abs(cosTheta));
-                color.rgb = lerp(gradient, color.rgb, pow(saturate(sd + 0.8), 32.0));
+                float scale;
+                float invScale;
+                
+                if ((g_PushConstants.DisplaySize.x * g_PushConstants.InverseDisplaySize.y) >= (4.0 / 3.0))
+                {
+                    scale = g_PushConstants.InverseDisplaySize.y * 720.0;
+                    invScale = g_PushConstants.DisplaySize.y / 720.0;
+                }
+                else
+                {
+                    scale = g_PushConstants.InverseDisplaySize.x * 960.0;
+                    invScale = g_PushConstants.DisplaySize.x / 960.0;
+                }
+                
+                float2 lowQualityPosition = (interpolators.Position.xy - 0.5) * scale;                
+                float2 fracPart = frac(lowQualityPosition);
+                
+                float2 uvStep = fwidth(interpolators.UV) * invScale;
+                float2 lowQualityUV = interpolators.UV - fracPart * uvStep;
+                float2 screenTexSize = 1.0 / uvStep;
+                
+                float4 topLeft = SampleSdfFont(color, texture, lowQualityUV + float2(0, 0), screenTexSize);
+                float4 topRight = SampleSdfFont(color, texture, lowQualityUV + float2(uvStep.x, 0), screenTexSize);
+                float4 bottomLeft = SampleSdfFont(color, texture, lowQualityUV + float2(0, uvStep.y), screenTexSize);
+                float4 bottomRight = SampleSdfFont(color, texture, lowQualityUV + uvStep.xy, screenTexSize);
+                
+                float4 top = lerp(topLeft, topRight, fracPart.x);
+                float4 bottom = lerp(bottomLeft, bottomRight, fracPart.x);
+                
+                color = lerp(top, bottom, fracPart.y);
             }
-            else if (g_PushConstants.ShaderModifier == IMGUI_SHADER_MODIFIER_CATEGORY_BEVEL)
+            else
             {
-                float2 normal = normalize(float3(ddx(sd), ddy(sd), 0.25)).xy;
-                float cosTheta = dot(normal, normalize(float2(1, 1)));
-                float gradient = 1.0 + cosTheta * 0.5;
-                color.rgb = saturate(color.rgb * gradient);
+                color = SampleSdfFont(color, texture, interpolators.UV, 1.0 / fwidth(interpolators.UV));
             }
-            else if (g_PushConstants.ShaderModifier == IMGUI_SHADER_MODIFIER_TEXT_SKEW)
-            {
-                float2 normal = normalize(float3(ddx(sd), ddy(sd), 0.5)).xy;
-                float cosTheta = dot(normal, normalize(float2(1, 1)));
-                float gradient = saturate(1.0 + cosTheta);
-                color.rgb = lerp(color.rgb * gradient, color.rgb, pow(saturate(sd + 0.77), 32.0));
-            }
-
-            color.a *= saturate(screenPxDistance + 0.5);
-            color.a *= textureColor.a;
         }
         else
         {
-            color *= textureColor;
+            color *= texture.Sample(g_SamplerDescriptorHeap[0], interpolators.UV);
         }
     }
     

UnleashedRecomp/gpu/video.cpp

@@ -230,12 +230,63 @@ static void SetDirtyValue(bool& dirtyState, T& dest, const T& src)
     }
 }
 
+static constexpr size_t PROFILER_VALUE_COUNT = 256;
+static size_t g_profilerValueIndex;
+
+struct Profiler
+{
+    std::atomic<double> value;
+    double values[PROFILER_VALUE_COUNT];
+    std::chrono::steady_clock::time_point start;
+
+    void Begin()
+    {
+        start = std::chrono::steady_clock::now();
+    }
+
+    void End()
+    {
+        value = std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - start).count();
+    }
+
+    void Set(double v)
+    {
+        value = v;
+    }
+
+    void Reset()
+    {
+        End();
+        Begin();
+    }
+
+    double UpdateAndReturnAverage()
+    {
+        values[g_profilerValueIndex] = value;
+        return std::accumulate(values, values + PROFILER_VALUE_COUNT, 0.0) / PROFILER_VALUE_COUNT;
+    }
+};
+
+static double g_applicationValues[PROFILER_VALUE_COUNT];
+static Profiler g_gpuFrameProfiler;
+static Profiler g_presentProfiler;
+static Profiler g_updateDirectorProfiler;
+static Profiler g_renderDirectorProfiler;
+static Profiler g_frameFenceProfiler;
+static Profiler g_presentWaitProfiler;
+static Profiler g_swapChainAcquireProfiler;
+
+static bool g_profilerVisible;
+static bool g_profilerWasToggled;
+
 #ifdef UNLEASHED_RECOMP_D3D12
 static bool g_vulkan = false;
 #else
 static constexpr bool g_vulkan = true;
 #endif
 
+static bool g_mesaTriangleStripWorkaround = false;
+
 static constexpr bool g_hardwareResolve = true;
 static constexpr bool g_hardwareDepthResolve = true;
 
@@ -245,6 +296,7 @@ static std::unique_ptr<RenderDevice> g_device;
 static RenderDeviceCapabilities g_capabilities;
 
 static constexpr size_t NUM_FRAMES = 2;
+static constexpr size_t NUM_QUERIES = 2;
 
 static uint32_t g_frame = 0;
 static uint32_t g_nextFrame = 1;
@@ -252,6 +304,7 @@ static uint32_t g_nextFrame = 1;
 static std::unique_ptr<RenderCommandQueue> g_queue;
 static std::unique_ptr<RenderCommandList> g_commandLists[NUM_FRAMES];
 static std::unique_ptr<RenderCommandFence> g_commandFences[NUM_FRAMES];
+static std::unique_ptr<RenderQueryPool> g_queryPools[NUM_FRAMES];
 static bool g_commandListStates[NUM_FRAMES];
 
 static Mutex g_copyMutex;
@@ -1287,6 +1340,7 @@ struct ImGuiPushConstants
     ImU32 gradientBottomLeft{};
     uint32_t shaderModifier{};
     uint32_t texture2DDescriptorIndex{};
+    ImVec2 displaySize{};
     ImVec2 inverseDisplaySize{};
     ImVec2 origin{ 0.0f, 0.0f };
     ImVec2 scale{ 1.0f, 1.0f };
@@ -1476,7 +1530,11 @@ static void CheckSwapChain()
     }
 
     if (g_swapChainValid)
+    {
+        g_swapChainAcquireProfiler.Begin();
         g_swapChainValid = g_swapChain->acquireTexture(g_acquireSemaphores[g_frame].get(), &g_backBufferIndex);
+        g_swapChainAcquireProfiler.End();
+    }
 
     if (g_needsResize)
         Video::ComputeViewportDimensions();
@@ -1552,6 +1610,8 @@ static void BeginCommandList()
     auto& commandList = g_commandLists[g_frame];
 
     commandList->begin();
+    commandList->resetQueryPool(g_queryPools[g_frame].get(), 0, NUM_QUERIES);
+    commandList->writeTimestamp(g_queryPools[g_frame].get(), 0);
     commandList->setGraphicsPipelineLayout(g_pipelineLayout.get());
     commandList->setGraphicsDescriptorSet(g_textureDescriptorSet.get(), 0);
     commandList->setGraphicsDescriptorSet(g_textureDescriptorSet.get(), 1);
@@ -1567,6 +1627,8 @@ static void ApplyLowEndDefault(ConfigDef<T> &configDef, T newDefault, bool &chan
         configDef = newDefault;
         changed = true;
     }
+    
+    configDef.DefaultValue = newDefault;
 }
 
 static void ApplyLowEndDefaults()
@@ -1615,12 +1677,39 @@ bool Video::CreateHostDevice(const char *sdlVideoDriver)
         g_interface = interfaceFunction();
         if (g_interface != nullptr)
         {
-            g_device = g_interface->createDevice();
+            g_device = g_interface->createDevice(Config::GraphicsDevice);
             if (g_device != nullptr)
             {
+                const RenderDeviceDescription &deviceDescription = g_device->getDescription();
+                
 #ifdef UNLEASHED_RECOMP_D3D12
+                if (interfaceFunction == CreateD3D12Interface)
+                {
+                    if (deviceDescription.vendor == RenderDeviceVendor::AMD)
+                    {
+                        // AMD Drivers before this version have a known issue where MSAA resolve targets will fail to work correctly.
+                        // If no specific graphics API was selected, we silently destroy this one and move to the next option as it'll
+                        // just work incorrectly otherwise and result in visual glitches and 3D rendering not working in general.
+                        constexpr uint64_t MinimumAMDDriverVersion = 0x1F00005DC2005CULL; // 31.0.24002.92
+                        if ((Config::GraphicsAPI == EGraphicsAPI::Auto) && (deviceDescription.driverVersion < MinimumAMDDriverVersion))
+                        {
+                            g_device.reset();
+                            g_interface.reset();
+                            continue;
+                        }
+                    }
+                }
+
                 g_vulkan = (interfaceFunction == CreateVulkanInterfaceWrapper);
 #endif
+
+                if (interfaceFunction == CreateVulkanInterfaceWrapper)
+                {
+                    // Enable triangle strip workaround if we are on the Mesa RADV driver, as it currently has a bug where
+                    // restart indices cause triangles to be culled incorrectly. Converting them to degenerate triangles fixes it.
+                    g_mesaTriangleStripWorkaround = deviceDescription.name.find(" (RADV ") != std::string::npos;
+                }
+
                 break;
             }
         }
@@ -1655,6 +1744,9 @@ bool Video::CreateHostDevice(const char *sdlVideoDriver)
     for (auto& commandFence : g_commandFences)
         commandFence = g_device->createCommandFence();
 
+    for (auto& queryPool : g_queryPools)
+        queryPool = g_device->createQueryPool(NUM_QUERIES);
+
     g_copyQueue = g_device->createCommandQueue(RenderCommandListType::COPY);
     g_copyCommandList = g_device->createCommandList(RenderCommandListType::COPY);
     g_copyCommandFence = g_device->createCommandFence();
@@ -1875,8 +1967,12 @@ bool Video::CreateHostDevice(const char *sdlVideoDriver)
     return true;
 }
 
+static uint32_t g_waitForGPUCount = 0;
+
 void Video::WaitForGPU()
 {
+    g_waitForGPUCount++;
+
     if (g_vulkan)
     {
         g_device->waitIdle();
@@ -2125,45 +2221,6 @@ static uint32_t HashVertexDeclaration(uint32_t vertexDeclaration)
     return vertexDeclaration;
 }
 
-static constexpr size_t PROFILER_VALUE_COUNT = 256;
-static size_t g_profilerValueIndex;
-
-struct Profiler
-{
-    std::atomic<double> value;
-    double values[PROFILER_VALUE_COUNT];
-    std::chrono::steady_clock::time_point start;
-
-    void Begin()
-    {
-        start = std::chrono::steady_clock::now();
-    }
-
-    void End()
-    {
-        value = std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - start).count();
-    }
-
-    void Reset()
-    {
-        End();
-        Begin();
-    }
-
-    double UpdateAndReturnAverage()
-    {
-        values[g_profilerValueIndex] = value;
-        return std::accumulate(values, values + PROFILER_VALUE_COUNT, 0.0) / PROFILER_VALUE_COUNT;
-    }
-};
-
-static double g_applicationValues[PROFILER_VALUE_COUNT];
-static Profiler g_presentProfiler;
-static Profiler g_renderDirectorProfiler;
-
-static bool g_profilerVisible;
-static bool g_profilerWasToggled;
-
 static const char *DeviceTypeName(RenderDeviceType type)
 {
     switch (type) 
@@ -2186,8 +2243,12 @@ static void DrawProfiler()
     bool toggleProfiler = SDL_GetKeyboardState(nullptr)[SDL_SCANCODE_F1] != 0;
 
     if (!g_profilerWasToggled && toggleProfiler)
+    {
         g_profilerVisible = !g_profilerVisible;
 
+        GameWindow::SetFullscreenCursorVisibility(App::s_isInit ? g_profilerVisible : true);
+    }
+
     g_profilerWasToggled = toggleProfiler;
 
     if (!g_profilerVisible)
@@ -2203,29 +2264,51 @@ static void DrawProfiler()
         g_applicationValues[g_profilerValueIndex] = App::s_deltaTime * 1000.0;
 
         const double applicationAvg = std::accumulate(g_applicationValues, g_applicationValues + PROFILER_VALUE_COUNT, 0.0) / PROFILER_VALUE_COUNT;
+        double gpuFrameAvg = g_gpuFrameProfiler.UpdateAndReturnAverage();
         double presentAvg = g_presentProfiler.UpdateAndReturnAverage();
+        double updateDirectorAvg = g_updateDirectorProfiler.UpdateAndReturnAverage();
         double renderDirectorAvg = g_renderDirectorProfiler.UpdateAndReturnAverage();
+        double frameFenceAvg = g_frameFenceProfiler.UpdateAndReturnAverage();
+        double presentWaitAvg = g_presentWaitProfiler.UpdateAndReturnAverage();
+        double swapChainAcquireAvg = g_swapChainAcquireProfiler.UpdateAndReturnAverage();
 
         if (ImPlot::BeginPlot("Frame Time"))
         {
             ImPlot::SetupAxisLimits(ImAxis_Y1, 0.0, 20.0);
             ImPlot::SetupAxis(ImAxis_Y1, "ms", ImPlotAxisFlags_None);
             ImPlot::PlotLine<double>("Application", g_applicationValues, PROFILER_VALUE_COUNT, 1.0, 0.0, ImPlotLineFlags_None, g_profilerValueIndex);
+            ImPlot::PlotLine<double>("GPU Frame", g_gpuFrameProfiler.values, PROFILER_VALUE_COUNT, 1.0, 0.0, ImPlotLineFlags_None, g_profilerValueIndex);
             ImPlot::PlotLine<double>("Present", g_presentProfiler.values, PROFILER_VALUE_COUNT, 1.0, 0.0, ImPlotLineFlags_None, g_profilerValueIndex);
+            ImPlot::PlotLine<double>("Update Director", g_updateDirectorProfiler.values, PROFILER_VALUE_COUNT, 1.0, 0.0, ImPlotLineFlags_None, g_profilerValueIndex);
             ImPlot::PlotLine<double>("Render Director", g_renderDirectorProfiler.values, PROFILER_VALUE_COUNT, 1.0, 0.0, ImPlotLineFlags_None, g_profilerValueIndex);
+            ImPlot::PlotLine<double>("Frame Fence", g_frameFenceProfiler.values, PROFILER_VALUE_COUNT, 1.0, 0.0, ImPlotLineFlags_None, g_profilerValueIndex);
+            ImPlot::PlotLine<double>("Present Wait", g_presentWaitProfiler.values, PROFILER_VALUE_COUNT, 1.0, 0.0, ImPlotLineFlags_None, g_profilerValueIndex);
+            ImPlot::PlotLine<double>("Swap Chain Acquire", g_swapChainAcquireProfiler.values, PROFILER_VALUE_COUNT, 1.0, 0.0, ImPlotLineFlags_None, g_profilerValueIndex);
             ImPlot::EndPlot();
         }
 
         g_profilerValueIndex = (g_profilerValueIndex + 1) % PROFILER_VALUE_COUNT;
 
         ImGui::Text("Current Application: %g ms (%g FPS)", App::s_deltaTime * 1000.0, 1.0 / App::s_deltaTime);
+        ImGui::Text("Current GPU Frame: %g ms (%g FPS)", g_gpuFrameProfiler.value.load(), 1000.0 / g_gpuFrameProfiler.value.load());
         ImGui::Text("Current Present: %g ms (%g FPS)", g_presentProfiler.value.load(), 1000.0 / g_presentProfiler.value.load());
+        ImGui::Text("Current Update Director: %g ms (%g FPS)", g_updateDirectorProfiler.value.load(), 1000.0 / g_updateDirectorProfiler.value.load());
         ImGui::Text("Current Render Director: %g ms (%g FPS)", g_renderDirectorProfiler.value.load(), 1000.0 / g_renderDirectorProfiler.value.load());
+        ImGui::Text("Current Frame Fence: %g ms", g_frameFenceProfiler.value.load());
+        ImGui::Text("Current Present Wait: %g ms", g_presentWaitProfiler.value.load());
+        ImGui::Text("Current Swap Chain Acquire: %g ms", g_swapChainAcquireProfiler.value.load());
+
         ImGui::NewLine();
 
         ImGui::Text("Average Application: %g ms (%g FPS)", applicationAvg, 1000.0 / applicationAvg);
+        ImGui::Text("Average GPU Frame: %g ms (%g FPS)", gpuFrameAvg, 1000.0 / gpuFrameAvg);
         ImGui::Text("Average Present: %g ms (%g FPS)", presentAvg, 1000.0 / presentAvg);
+        ImGui::Text("Average Update Director: %g ms (%g FPS)", updateDirectorAvg, 1000.0 / updateDirectorAvg);
         ImGui::Text("Average Render Director: %g ms (%g FPS)", renderDirectorAvg, 1000.0 / renderDirectorAvg);
+        ImGui::Text("Average Frame Fence: %g ms", frameFenceAvg);
+        ImGui::Text("Average Present Wait: %g ms", presentWaitAvg);
+        ImGui::Text("Average Swap Chain Acquire: %g ms", swapChainAcquireAvg);
+
         ImGui::NewLine();
 
         O1HeapDiagnostics diagnostics, physicalDiagnostics;
@@ -2240,11 +2323,13 @@ static void DrawProfiler()
 
         ImGui::Text("Heap Allocated: %d MB", int32_t(diagnostics.allocated / (1024 * 1024)));
         ImGui::Text("Physical Heap Allocated: %d MB", int32_t(physicalDiagnostics.allocated / (1024 * 1024)));
+        ImGui::Text("GPU Waits: %d", int32_t(g_waitForGPUCount));
         ImGui::NewLine();
 
         ImGui::Text("Present Wait: %s", g_capabilities.presentWait ? "Supported" : "Unsupported");
         ImGui::Text("Triangle Fan: %s", g_capabilities.triangleFan ? "Supported" : "Unsupported");
         ImGui::Text("Dynamic Depth Bias: %s", g_capabilities.dynamicDepthBias ? "Supported" : "Unsupported");
+        ImGui::Text("Triangle Strip Workaround: %s", g_mesaTriangleStripWorkaround ? "Enabled" : "Disabled");
         ImGui::NewLine();
 
         ImGui::Text("API: %s", g_vulkan ? "Vulkan" : "D3D12");
@@ -2256,6 +2341,24 @@ static void DrawProfiler()
         const char* sdlVideoDriver = SDL_GetCurrentVideoDriver();
         if (sdlVideoDriver != nullptr)
             ImGui::Text("SDL Video Driver: %s", sdlVideoDriver);
+
+        ImGui::NewLine();
+        ImGui::Checkbox("Show FPS", &Config::ShowFPS.Value);
+        ImGui::NewLine();
+
+        if (ImGui::TreeNode("Device Names"))
+        {
+            ImGui::Indent();
+
+            uint32_t deviceIndex = 0;
+            for (const std::string &deviceName : g_interface->getDeviceNames())
+            {
+                ImGui::Text("Option #%d: %s", deviceIndex++, deviceName.c_str());
+            }
+
+            ImGui::Unindent();
+            ImGui::TreePop();
+        }
     }
     ImGui::End();
 
@@ -2263,6 +2366,43 @@ static void DrawProfiler()
     font->Scale = defaultScale;
 }
 
+static void DrawFPS()
+{
+    if (!Config::ShowFPS)
+        return;
+
+    double time = ImGui::GetTime();
+    static double updateTime = time;
+    static double fps = 0;
+    static double totalDeltaTime = 0.0;
+    static uint32_t totalDeltaCount = 0;
+
+    totalDeltaTime += g_presentProfiler.value.load();
+    totalDeltaCount++;
+
+    if (time - updateTime >= 1.0f)
+    {
+        fps = 1000.0 / std::max(totalDeltaTime / double(totalDeltaCount), 1.0);
+        updateTime = time;
+        totalDeltaTime = 0.0;
+        totalDeltaCount = 0;
+    }
+
+    auto drawList = ImGui::GetBackgroundDrawList();
+
+    auto fmt = fmt::format("FPS: {:.2f}", fps);
+    auto font = ImFontAtlasSnapshot::GetFont("FOT-SeuratPro-M.otf");
+    auto fontSize = Scale(10);
+    auto textSize = font->CalcTextSizeA(fontSize, FLT_MAX, 0, fmt.c_str());
+
+    ImVec2 min = { Scale(40), Scale(30) };
+    ImVec2 max = { min.x + std::max(Scale(75), textSize.x + Scale(10)), min.y + Scale(15) };
+    ImVec2 textPos = { min.x + Scale(2), CENTRE_TEXT_VERT(min, max, textSize) + Scale(0.2f) };
+
+    drawList->AddRectFilled(min, max, IM_COL32(0, 0, 0, 200));
+    drawList->AddText(font, fontSize, textPos, IM_COL32_WHITE, fmt.c_str());
+}
+
 static void DrawImGui()
 {
     ImGui_ImplSDL2_NewFrame();
@@ -2321,8 +2461,9 @@ static void DrawImGui()
     Fader::Draw();
     BlackBar::Draw();
 
-    assert(ImGui::GetForegroundDrawList()->_ClipRectStack.Size == 1 && "Some clip rects were not removed from the stack!");
+    assert(ImGui::GetBackgroundDrawList()->_ClipRectStack.Size == 1 && "Some clip rects were not removed from the stack!");
 
+    DrawFPS();
     DrawProfiler();
     ImGui::Render();
 
@@ -2356,6 +2497,7 @@ static void ProcDrawImGui(const RenderCommand& cmd)
     commandList->setViewports(RenderViewport(drawData.DisplayPos.x, drawData.DisplayPos.y, drawData.DisplaySize.x, drawData.DisplaySize.y));
 
     ImGuiPushConstants pushConstants{};
+    pushConstants.displaySize = drawData.DisplaySize;
     pushConstants.inverseDisplaySize = { 1.0f / drawData.DisplaySize.x, 1.0f / drawData.DisplaySize.y };
     commandList->setGraphicsPushConstants(0, &pushConstants);
 
@@ -2494,7 +2636,11 @@ void Video::WaitOnSwapChain()
     if (g_pendingWaitOnSwapChain)
     {
         if (g_swapChainValid)
+        {
+            g_presentWaitProfiler.Begin();
             g_swapChain->wait();
+            g_presentWaitProfiler.End();
+        }
 
         g_pendingWaitOnSwapChain = false;
     }
@@ -2527,7 +2673,11 @@ void Video::Present()
     if (g_swapChainValid)
     {
         if (g_pendingWaitOnSwapChain)
+        {
+            g_presentWaitProfiler.Begin();
             g_swapChain->wait(); // Never gonna happen outside loading threads as explained above.
+            g_presentWaitProfiler.End();
+        }
 
         RenderCommandSemaphore* signalSemaphores[] = { g_renderSemaphores[g_frame].get() };
         g_swapChainValid = g_swapChain->present(g_backBufferIndex, signalSemaphores, std::size(signalSemaphores));
@@ -2540,8 +2690,15 @@ void Video::Present()
 
     if (g_commandListStates[g_frame])
     {
+        g_frameFenceProfiler.Begin();
         g_queue->waitForCommandFence(g_commandFences[g_frame].get());
+        g_frameFenceProfiler.End();
         g_commandListStates[g_frame] = false;
+
+        // Update the GPU profiler with the results from the timestamps of the frame.
+        g_queryPools[g_frame]->queryResults();
+        const uint64_t *frameTimestamps = g_queryPools[g_frame]->getResults();
+        g_gpuFrameProfiler.Set(double(frameTimestamps[1] - frameTimestamps[0]) / 1000000.0);
     }
 
     g_dirtyStates = DirtyStates(true);
@@ -2676,6 +2833,7 @@ static void ProcExecuteCommandList(const RenderCommand& cmd)
     }
 
     auto &commandList = g_commandLists[g_frame];
+    commandList->writeTimestamp(g_queryPools[g_frame].get(), 1);
     commandList->end();
 
     if (g_swapChainValid)
@@ -5622,13 +5780,10 @@ PPC_FUNC(sub_8258C8A0)
 PPC_FUNC_IMPL(__imp__sub_8258CAE0);
 PPC_FUNC(sub_8258CAE0)
 {
-    g_renderDirectorProfiler.Begin();
-
     if (g_needsResize)
     {
-        // Backup fade values. These get modified by cutscenes, 
+        // Backup job values. These get modified by cutscenes, 
         // and resizing will cause the values to be forgotten.
-        // NOTE: Intentionally ignoring the shared pointers here.
         auto traverseFxJobs = [&]<typename TCallback>(const TCallback& callback)
         {
             uint32_t scheduler = PPC_LOAD_U32(ctx.r3.u32 + 0xE0);
@@ -5640,28 +5795,63 @@ PPC_FUNC(sub_8258CAE0)
                     for (uint32_t it = PPC_LOAD_U32(member + 0x24); it != PPC_LOAD_U32(member + 0x28); it += 8)
                     {
                         uint32_t job = PPC_LOAD_U32(it);
-                        if (job != NULL && PPC_LOAD_U32(job) == 0x820CA6F8) // SWA::CFxFade
+                        if (job != NULL)
                             callback(job);
                     }
                 }
             }
         };
 
-        struct FadeValues
+        union JobValues
         {
-            uint8_t field50[0x18];
-            uint8_t field88;
+            struct
+            {
+                uint8_t field50[0x18];
+                uint8_t field88;
+            } fade;
+
+            struct
+            {
+                uint8_t camera[0x120];
+                uint8_t field44;
+                uint8_t fieldA0;
+            } shadowMap;
         };
 
-        std::map<uint32_t, FadeValues> fadeValuesMap;
+        std::map<uint32_t, JobValues> jobValuesMap;
         traverseFxJobs([&](uint32_t job)
             {
-                FadeValues fadeValues{};
+                uint32_t vfTable = PPC_LOAD_U32(job);
 
-                memcpy(fadeValues.field50, base + job + 0x50, sizeof(fadeValues.field50));
-                fadeValues.field88 = PPC_LOAD_U8(job + 0x88);
+                if (vfTable == 0x820CA6F8) // SWA::CFxFade
+                {
+                    // NOTE: Intentionally not storing shared pointers here. 
+                    // Game sends messages that assign these every frame already.
+                    JobValues jobValues{};
 
-                fadeValuesMap.emplace(PPC_LOAD_U32(job + 0x48), fadeValues);
+                    memcpy(jobValues.fade.field50, base + job + 0x50, sizeof(jobValues.fade.field50));
+                    jobValues.fade.field88 = PPC_LOAD_U8(job + 0x88);
+
+                    jobValuesMap.emplace(PPC_LOAD_U32(job + 0x48), jobValues);
+                }
+                else if (vfTable == 0x820CAC5C) // SWA::CFxShadowMap
+                {
+                    for (uint32_t it = PPC_LOAD_U32(job + 0x88); it != PPC_LOAD_U32(job + 0x8C); it += 8)
+                    {
+                        uint32_t camera = PPC_LOAD_U32(it);
+                        if (camera != NULL && PPC_LOAD_U32(camera) == 0x820BF83C) // SWA::CShadowMapCameraLiSPSM
+                        {
+                            JobValues jobValues{};
+
+                            memcpy(jobValues.shadowMap.camera, base + camera, sizeof(jobValues.shadowMap.camera));
+                            jobValues.shadowMap.field44 = PPC_LOAD_U8(job + 0x44);
+                            jobValues.shadowMap.fieldA0 = PPC_LOAD_U8(job + 0xA0);
+
+                            jobValuesMap.emplace(vfTable, jobValues);
+                            break;
+                        }
+                    }
+                }
             });
 
         auto r3 = ctx.r3;
@@ -5670,14 +5860,38 @@ PPC_FUNC(sub_8258CAE0)
         __imp__sub_8258C8A0(ctx, base);
         ctx.r3 = r3;
 
-        // Restore fade values.
+        // Restore job values.
         traverseFxJobs([&](uint32_t job)
             {
-                auto findResult = fadeValuesMap.find(PPC_LOAD_U32(job + 0x48));
-                if (findResult != fadeValuesMap.end()) // May NOT actually be found.
+                uint32_t vfTable = PPC_LOAD_U32(job);
+
+                if (vfTable == 0x820CA6F8) // SWA::CFxFade
                 {
-                    memcpy(base + job + 0x50, findResult->second.field50, sizeof(findResult->second.field50));
-                    PPC_STORE_U8(job + 0x88, findResult->second.field88);
+                    auto findResult = jobValuesMap.find(PPC_LOAD_U32(job + 0x48));
+                    if (findResult != jobValuesMap.end()) // May NOT actually be found.
+                    {
+                        memcpy(base + job + 0x50, findResult->second.fade.field50, sizeof(findResult->second.fade.field50));
+                        PPC_STORE_U8(job + 0x88, findResult->second.fade.field88);
+                    }
+                }
+                else if (vfTable == 0x820CAC5C) // SWA::CFxShadowMap
+                {
+                    auto findResult = jobValuesMap.find(vfTable);
+                    if (findResult != jobValuesMap.end()) // Would be weird if this one wasn't found.
+                    {
+                        for (uint32_t it = PPC_LOAD_U32(job + 0x88); it != PPC_LOAD_U32(job + 0x8C); it += 8)
+                        {
+                            uint32_t camera = PPC_LOAD_U32(it);
+                            if (camera != NULL && PPC_LOAD_U32(camera) == 0x820BF83C) // SWA::CShadowMapCameraLiSPSM
+                            {
+                                memcpy(base + camera, findResult->second.shadowMap.camera, sizeof(findResult->second.shadowMap.camera));
+                                PPC_STORE_U32(job + 0x80, camera);
+                                PPC_STORE_U8(job + 0x44, findResult->second.shadowMap.field44);
+                                PPC_STORE_U8(job + 0xA0, findResult->second.shadowMap.fieldA0);
+                                break;
+                            }
+                        }
+                    }
                 }
             });
 
@@ -5685,7 +5899,21 @@ PPC_FUNC(sub_8258CAE0)
     }
 
     __imp__sub_8258CAE0(ctx, base);
+}
 
+PPC_FUNC_IMPL(__imp__sub_824EB5B0);
+PPC_FUNC(sub_824EB5B0)
+{
+    g_updateDirectorProfiler.Begin();
+    __imp__sub_824EB5B0(ctx, base);
+    g_updateDirectorProfiler.End();
+}
+
+PPC_FUNC_IMPL(__imp__sub_824EB290);
+PPC_FUNC(sub_824EB290)
+{
+    g_renderDirectorProfiler.Begin();
+    __imp__sub_824EB290(ctx, base);
     g_renderDirectorProfiler.End();
 }
 
@@ -7187,6 +7415,187 @@ bool FxShadowMapMidAsmHook(PPCRegister& r4, PPCRegister& r5, PPCRegister& r6, PP
     }
 }
 
+// There is a driver bug on Mesa where restart indices cause incorrect culling and prevent some triangles from being rendered.
+// Restart indices can be converted to degenerate triangles as a workaround until this issue gets fixed.
+static void ConvertToDegenerateTriangles(uint16_t* indices, uint32_t indexCount, uint16_t*& newIndices, uint32_t& newIndexCount)
+{
+    newIndices = reinterpret_cast<uint16_t*>(g_userHeap.Alloc(indexCount * sizeof(uint16_t) * 3));
+    newIndexCount = 0;
+
+    bool stripStart = true;
+    uint32_t stripSize = 0;
+    uint16_t lastIndex = 0;
+
+    for (uint32_t i = 0; i < indexCount; i++)
+    {
+        uint16_t index = indices[i];
+        if (index == 0xFFFF)
+        {
+            if ((stripSize % 2) != 0)
+                newIndices[newIndexCount++] = lastIndex;
+
+            stripStart = true;
+            stripSize = 0;
+        }
+        else 
+        {
+            if (stripStart && newIndexCount != 0)
+            {
+                newIndices[newIndexCount++] = lastIndex;
+                newIndices[newIndexCount++] = index;
+            }
+
+            newIndices[newIndexCount++] = index;
+            stripStart = false;
+            ++stripSize;
+            lastIndex = index;
+        }
+    }
+}
+
+struct MeshResource
+{
+    SWA_INSERT_PADDING(0x4);
+    be<uint32_t> indexCount;
+    be<uint32_t> indices;
+};
+
+static std::vector<uint16_t*> g_newIndicesToFree;
+
+// Hedgehog::Mirage::CMeshData::Make
+PPC_FUNC_IMPL(__imp__sub_82E44AF8);
+PPC_FUNC(sub_82E44AF8)
+{
+    uint16_t* newIndicesToFree = nullptr;
+
+    auto databaseData = reinterpret_cast<Hedgehog::Database::CDatabaseData*>(base + ctx.r3.u32);
+    if (g_mesaTriangleStripWorkaround && !databaseData->IsMadeOne())
+    {
+        auto meshResource = reinterpret_cast<MeshResource*>(base + ctx.r4.u32);
+
+        if (meshResource->indexCount != 0)
+        {
+            uint16_t* newIndices;
+            uint32_t newIndexCount;
+
+            ConvertToDegenerateTriangles(
+                reinterpret_cast<uint16_t*>(base + meshResource->indices),
+                meshResource->indexCount,
+                newIndices,
+                newIndexCount);
+
+            meshResource->indexCount = newIndexCount;
+            meshResource->indices = static_cast<uint32_t>(reinterpret_cast<uint8_t*>(newIndices) - base);
+
+            if (PPC_LOAD_U32(0x83396E98) != NULL)
+            {
+                // If index buffers are getting merged, new indices need to survive until the merge happens.
+                g_newIndicesToFree.push_back(newIndices);
+            }
+            else 
+            {
+                // Otherwise, we can free it immediately.
+                newIndicesToFree = newIndices;
+            }
+        }
+    }
+
+    __imp__sub_82E44AF8(ctx, base);
+
+    if (newIndicesToFree != nullptr)
+        g_userHeap.Free(newIndicesToFree);
+}
+
+// Hedgehog::Mirage::CShareVertexBuffer::Reset
+PPC_FUNC_IMPL(__imp__sub_82E250D0);
+PPC_FUNC(sub_82E250D0)
+{
+    __imp__sub_82E250D0(ctx, base);
+
+    for (auto newIndicesToFree : g_newIndicesToFree)
+        g_userHeap.Free(newIndicesToFree);
+
+    g_newIndicesToFree.clear();
+}
+
+struct LightAndIndexBufferResourceV1
+{
+    SWA_INSERT_PADDING(0x4);
+    be<uint32_t> indexCount;
+    be<uint32_t> indices;
+};
+
+// Hedgehog::Mirage::CLightAndIndexBufferData::MakeV1
+PPC_FUNC_IMPL(__imp__sub_82E3AFC8);
+PPC_FUNC(sub_82E3AFC8)
+{
+    uint16_t* newIndices = nullptr;
+
+    auto databaseData = reinterpret_cast<Hedgehog::Database::CDatabaseData*>(base + ctx.r3.u32);
+    if (g_mesaTriangleStripWorkaround && !databaseData->IsMadeOne())
+    {
+        auto lightAndIndexBufferResource = reinterpret_cast<LightAndIndexBufferResourceV1*>(base + ctx.r4.u32);
+
+        if (lightAndIndexBufferResource->indexCount != 0)
+        {
+            uint32_t newIndexCount;
+
+            ConvertToDegenerateTriangles(
+                reinterpret_cast<uint16_t*>(base + lightAndIndexBufferResource->indices),
+                lightAndIndexBufferResource->indexCount,
+                newIndices,
+                newIndexCount);
+
+            lightAndIndexBufferResource->indexCount = newIndexCount;
+            lightAndIndexBufferResource->indices = static_cast<uint32_t>(reinterpret_cast<uint8_t*>(newIndices) - base);
+        }
+    }
+
+    __imp__sub_82E3AFC8(ctx, base);
+
+    if (newIndices != nullptr)
+        g_userHeap.Free(newIndices);
+}
+
+struct LightAndIndexBufferResourceV5
+{
+    SWA_INSERT_PADDING(0x8);
+    be<uint32_t> indexCount;
+    be<uint32_t> indices;
+};
+
+// Hedgehog::Mirage::CLightAndIndexBufferData::MakeV5
+PPC_FUNC_IMPL(__imp__sub_82E3B1C0);
+PPC_FUNC(sub_82E3B1C0)
+{
+    uint16_t* newIndices = nullptr;
+
+    auto databaseData = reinterpret_cast<Hedgehog::Database::CDatabaseData*>(base + ctx.r3.u32);
+    if (g_mesaTriangleStripWorkaround && !databaseData->IsMadeOne())
+    {
+        auto lightAndIndexBufferResource = reinterpret_cast<LightAndIndexBufferResourceV5*>(base + ctx.r4.u32);
+
+        if (lightAndIndexBufferResource->indexCount != 0)
+        {
+            uint32_t newIndexCount;
+
+            ConvertToDegenerateTriangles(
+                reinterpret_cast<uint16_t*>(base + lightAndIndexBufferResource->indices),
+                lightAndIndexBufferResource->indexCount,
+                newIndices,
+                newIndexCount);
+
+            lightAndIndexBufferResource->indexCount = newIndexCount;
+            lightAndIndexBufferResource->indices = static_cast<uint32_t>(reinterpret_cast<uint8_t*>(newIndices) - base);
+        }
+    }
+
+    __imp__sub_82E3B1C0(ctx, base);
+
+    if (newIndices != nullptr)
+        g_userHeap.Free(newIndices);
+}
+
 GUEST_FUNCTION_HOOK(sub_82BD99B0, CreateDevice);
 
 GUEST_FUNCTION_HOOK(sub_82BE6230, DestructResource);

UnleashedRecomp/gpu/video.h

@@ -1,7 +1,7 @@
 #pragma once
 
 //#define ASYNC_PSO_DEBUG
-#define PSO_CACHING
+/////////////////////////////////////////////////////////////////////#define PSO_CACHING
 //#define PSO_CACHING_CLEANUP
 
 #include "rhi/plume_render_interface.h"

UnleashedRecomp/hid/hid.cpp

@@ -7,10 +7,14 @@ hid::EInputDevice hid::g_inputDeviceController;
 hid::EInputDeviceExplicit hid::g_inputDeviceExplicit;
 
 uint16_t hid::g_prohibitedButtons;
+bool hid::g_isLeftStickProhibited;
+bool hid::g_isRightStickProhibited;
 
-void hid::SetProhibitedButtons(uint16_t wButtons)
+void hid::SetProhibitedInputs(uint16_t wButtons, bool leftStick, bool rightStick)
 {
     hid::g_prohibitedButtons = wButtons;
+    hid::g_isLeftStickProhibited = leftStick;
+    hid::g_isRightStickProhibited = rightStick;
 }
 
 bool hid::IsInputAllowed()

UnleashedRecomp/hid/hid.h

@@ -33,6 +33,8 @@ namespace hid
     extern EInputDeviceExplicit g_inputDeviceExplicit;
 
     extern uint16_t g_prohibitedButtons;
+    extern bool g_isLeftStickProhibited;
+    extern bool g_isRightStickProhibited;
 
     void Init();
 
@@ -40,7 +42,7 @@ namespace hid
     uint32_t SetState(uint32_t dwUserIndex, XAMINPUT_VIBRATION* pVibration);
     uint32_t GetCapabilities(uint32_t dwUserIndex, XAMINPUT_CAPABILITIES* pCaps);
 
-    void SetProhibitedButtons(uint16_t wButtons);
+    void SetProhibitedInputs(uint16_t wButtons = 0, bool leftStick = false, bool rightStick = false);
     bool IsInputAllowed();
     bool IsInputDeviceController();
     std::string GetInputDeviceName();

UnleashedRecomp/install/installer.cpp

@@ -598,5 +598,5 @@ XexPatcher::Result Installer::checkGameUpdateCompatibility(const std::filesystem
     }
 
     std::vector<uint8_t> patchedBytes;
-    return XexPatcher::apply(xexBytes, patchBytes, patchedBytes, true);
+    return XexPatcher::apply(xexBytes.data(), xexBytes.size(), patchBytes.data(), patchBytes.size(), patchedBytes, true);
 }

UnleashedRecomp/install/installer.h

@@ -4,7 +4,7 @@
 #include <set>
 
 #include "virtual_file_system.h"
-#include "xex_patcher.h"
+#include <xex_patcher.h>
 
 enum class DLC {
     Unknown,

UnleashedRecomp/install/iso_file_system.h

@@ -16,7 +16,7 @@
 
 #include "virtual_file_system.h"
 
-#include "memory_mapped_file.h"
+#include <memory_mapped_file.h>
 
 struct ISOFileSystem : VirtualFileSystem
 {

UnleashedRecomp/install/memory_mapped_file.cpp

@@ -1,169 +0,0 @@
-#include "memory_mapped_file.h"
-
-#if !defined(_WIN32)
-#   include <cstring>
-#   include <cstdio>
-#   include <fcntl.h>
-#   include <unistd.h>
-#endif
-
-MemoryMappedFile::MemoryMappedFile()
-{
-    // Default constructor.
-}
-
-MemoryMappedFile::MemoryMappedFile(const std::filesystem::path &path)
-{
-    open(path);
-}
-
-MemoryMappedFile::~MemoryMappedFile()
-{
-    close();
-}
-
-MemoryMappedFile::MemoryMappedFile(MemoryMappedFile &&other)
-{
-#if defined(_WIN32)
-    fileHandle = other.fileHandle;
-    fileMappingHandle = other.fileMappingHandle;
-    fileView = other.fileView;
-    fileSize = other.fileSize;
-
-    other.fileHandle = nullptr;
-    other.fileMappingHandle = nullptr;
-    other.fileView = nullptr;
-    other.fileSize.QuadPart = 0;
-#else
-    fileHandle = other.fileHandle;
-    fileView = other.fileView;
-    fileSize = other.fileSize;
-
-    other.fileHandle = -1;
-    other.fileView = MAP_FAILED;
-    other.fileSize = 0;
-#endif
-}
-
-bool MemoryMappedFile::open(const std::filesystem::path &path)
-{
-#if defined(_WIN32)
-    fileHandle = CreateFileW(path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
-    if (fileHandle == INVALID_HANDLE_VALUE)
-    {
-        fprintf(stderr, "CreateFileW failed with error %lu.\n", GetLastError());
-        fileHandle = nullptr;
-        return false;
-    }
-
-    if (!GetFileSizeEx(fileHandle, &fileSize))
-    {
-        fprintf(stderr, "GetFileSizeEx failed with error %lu.\n", GetLastError());
-        CloseHandle(fileHandle);
-        fileHandle = nullptr;
-        return false;
-    }
-
-    fileMappingHandle = CreateFileMappingW(fileHandle, nullptr, PAGE_READONLY, 0, 0, nullptr);
-    if (fileMappingHandle == nullptr)
-    {
-        fprintf(stderr, "CreateFileMappingW failed with error %lu.\n", GetLastError());
-        CloseHandle(fileHandle);
-        fileHandle = nullptr;
-        return false;
-    }
-
-    fileView = MapViewOfFile(fileMappingHandle, FILE_MAP_READ, 0, 0, 0);
-    if (fileView == nullptr)
-    {
-        fprintf(stderr, "MapViewOfFile failed with error %lu.\n", GetLastError());
-        CloseHandle(fileMappingHandle);
-        CloseHandle(fileHandle);
-        fileMappingHandle = nullptr;
-        fileHandle = nullptr;
-        return false;
-    }
-
-    return true;
-#else
-    fileHandle = ::open(path.c_str(), O_RDONLY);
-    if (fileHandle == -1)
-    {
-        fprintf(stderr, "open for %s failed with error %s.\n", path.c_str(), strerror(errno));
-        return false;
-    }
-
-    fileSize = lseek(fileHandle, 0, SEEK_END);
-    if (fileSize == (off_t)(-1))
-    {
-        fprintf(stderr, "lseek failed with error %s.\n", strerror(errno));
-        ::close(fileHandle);
-        fileHandle = -1;
-        return false;
-    }
-
-    fileView = mmap(nullptr, fileSize, PROT_READ, MAP_PRIVATE, fileHandle, 0);
-    if (fileView == MAP_FAILED)
-    {
-        fprintf(stderr, "mmap failed with error %s.\n", strerror(errno));
-        ::close(fileHandle);
-        fileHandle = -1;
-        return false;
-    }
-
-    return true;
-#endif
-}
-
-void MemoryMappedFile::close()
-{
-#if defined(_WIN32)
-    if (fileView != nullptr)
-    {
-        UnmapViewOfFile(fileView);
-    }
-
-    if (fileMappingHandle != nullptr)
-    {
-        CloseHandle(fileMappingHandle);
-    }
-
-    if (fileHandle != nullptr)
-    {
-        CloseHandle(fileHandle);
-    }
-#else
-    if (fileView != MAP_FAILED)
-    {
-        munmap(fileView, fileSize);
-    }
-
-    if (fileHandle != -1)
-    {
-        ::close(fileHandle);
-    }
-#endif
-}
-
-bool MemoryMappedFile::isOpen() const
-{
-#if defined(_WIN32)
-    return (fileView != nullptr);
-#else
-    return (fileView != MAP_FAILED);
-#endif
-}
-
-uint8_t *MemoryMappedFile::data() const
-{
-    return reinterpret_cast<uint8_t *>(fileView);
-}
-
-size_t MemoryMappedFile::size() const
-{
-#if defined(_WIN32)
-    return fileSize.QuadPart;
-#else
-    return static_cast<size_t>(fileSize);
-#endif
-}

UnleashedRecomp/install/memory_mapped_file.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <filesystem>
-
-#if defined(_WIN32)
-#   include <Windows.h>
-#else
-#   include <sys/mman.h>
-#endif
-
-struct MemoryMappedFile {
-#if defined(_WIN32)
-    HANDLE fileHandle = nullptr;
-    HANDLE fileMappingHandle = nullptr;
-    LPVOID fileView = nullptr;
-    LARGE_INTEGER fileSize = {};
-#else
-    int fileHandle = -1;
-    void *fileView = MAP_FAILED;
-    off_t fileSize = 0;
-#endif
-
-    MemoryMappedFile();
-    MemoryMappedFile(const std::filesystem::path &path);
-    MemoryMappedFile(MemoryMappedFile &&other);
-    ~MemoryMappedFile();
-    bool open(const std::filesystem::path &path);
-    void close();
-    bool isOpen() const;
-    uint8_t *data() const;
-    size_t size() const;
-};

UnleashedRecomp/install/xcontent_file_system.h

@@ -16,7 +16,7 @@
 
 #include "virtual_file_system.h"
 
-#include "memory_mapped_file.h"
+#include <memory_mapped_file.h>
 
 enum class XContentVolumeType
 {

UnleashedRecomp/install/xex_patcher.cpp

@@ -1,693 +0,0 @@
-// Referenced from: https://github.com/xenia-canary/xenia-canary/blob/canary_experimental/src/xenia/cpu/xex_module.cc
-
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2023 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xex_patcher.h"
-
-#include <bit>
-#include <cassert>
-
-#include <aes.hpp>
-#include <lzx.h>
-#include <mspack.h>
-#include <TinySHA1.hpp>
-
-#include "memory_mapped_file.h"
-
-enum Xex2ModuleFlags
-{
-    XEX_MODULE_MODULE_PATCH = 0x10,
-    XEX_MODULE_PATCH_FULL = 0x20,
-    XEX_MODULE_PATCH_DELTA = 0x40,
-};
-
-enum Xex2HeaderKeys
-{
-    XEX_HEADER_FILE_FORMAT_INFO = 0x3FF,
-    XEX_HEADER_DELTA_PATCH_DESCRIPTOR = 0x5FF,
-};
-
-enum Xex2EncryptionType
-{
-    XEX_ENCRYPTION_NONE = 0,
-    XEX_ENCRYPTION_NORMAL = 1,
-};
-
-enum Xex2CompressionType
-{
-    XEX_COMPRESSION_NONE = 0,
-    XEX_COMPRESSION_BASIC = 1,
-    XEX_COMPRESSION_NORMAL = 2,
-    XEX_COMPRESSION_DELTA = 3,
-};
-
-enum Xex2SectionType
-{
-    XEX_SECTION_CODE = 1,
-    XEX_SECTION_DATA = 2,
-    XEX_SECTION_READONLY_DATA = 3,
-};
-
-struct Xex2OptHeader
-{
-    be<uint32_t> key;
-
-    union
-    {
-        be<uint32_t> value;
-        be<uint32_t> offset;
-    };
-};
-
-struct Xex2Header
-{
-    be<uint32_t> magic;
-    be<uint32_t> moduleFlags;
-    be<uint32_t> headerSize;
-    be<uint32_t> reserved;
-    be<uint32_t> securityOffset;
-    be<uint32_t> headerCount;
-    Xex2OptHeader headers[1];
-};
-
-struct Xex2PageDescriptor
-{
-    union
-    {
-        // Must be endian-swapped before reading the bitfield.
-        uint32_t beValue;
-        struct
-        {
-            uint32_t info : 4;
-            uint32_t pageCount : 28;
-        };
-    };
-
-    char dataDigest[0x14];
-};
-
-struct Xex2SecurityInfo
-{
-    be<uint32_t> headerSize;
-    be<uint32_t> imageSize;
-    char rsaSignature[0x100];
-    be<uint32_t> unknown;
-    be<uint32_t> imageFlags;
-    be<uint32_t> loadAddress;
-    char sectionDigest[0x14];
-    be<uint32_t> importTableCount;
-    char importTableDigest[0x14];
-    char xgd2MediaId[0x10];
-    char aesKey[0x10];
-    be<uint32_t> exportTable;
-    char headerDigest[0x14];
-    be<uint32_t> region;
-    be<uint32_t> allowedMediaTypes;
-    be<uint32_t> pageDescriptorCount;
-    Xex2PageDescriptor pageDescriptors[1];
-};
-
-struct Xex2DeltaPatch
-{
-    be<uint32_t> oldAddress;
-    be<uint32_t> newAddress;
-    be<uint16_t> uncompressedLength;
-    be<uint16_t> compressedLength;
-    char patchData[1];
-};
-
-struct Xex2OptDeltaPatchDescriptor
-{
-    be<uint32_t> size;
-    be<uint32_t> targetVersionValue;
-    be<uint32_t> sourceVersionValue;
-    uint8_t digestSource[0x14];
-    uint8_t imageKeySource[0x10];
-    be<uint32_t> sizeOfTargetHeaders;
-    be<uint32_t> deltaHeadersSourceOffset;
-    be<uint32_t> deltaHeadersSourceSize;
-    be<uint32_t> deltaHeadersTargetOffset;
-    be<uint32_t> deltaImageSourceOffset;
-    be<uint32_t> deltaImageSourceSize;
-    be<uint32_t> deltaImageTargetOffset;
-    Xex2DeltaPatch info;
-};
-
-struct Xex2FileBasicCompressionBlock
-{
-    be<uint32_t> dataSize;
-    be<uint32_t> zeroSize;
-};
-
-struct Xex2FileBasicCompressionInfo
-{
-    Xex2FileBasicCompressionBlock firstBlock;
-};
-
-struct Xex2CompressedBlockInfo
-{
-    be<uint32_t> blockSize;
-    uint8_t blockHash[20];
-};
-
-struct Xex2FileNormalCompressionInfo
-{
-    be<uint32_t> windowSize;
-    Xex2CompressedBlockInfo firstBlock;
-};
-
-struct Xex2OptFileFormatInfo
-{
-    be<uint32_t> infoSize;
-    be<uint16_t> encryptionType;
-    be<uint16_t> compressionType;
-    union
-    {
-        Xex2FileBasicCompressionInfo basic;
-        Xex2FileNormalCompressionInfo normal;
-    } compressionInfo;
-};
-
-static const void *getOptHeaderPtr(std::span<const uint8_t> moduleBytes, uint32_t headerKey)
-{
-    if ((headerKey & 0xFF) == 0)
-    {
-        assert(false && "Wrong type of method for this key. Expected return value is a number.");
-        return nullptr;
-    }
-
-    const Xex2Header *xex2Header = (const Xex2Header *)(moduleBytes.data());
-    for (uint32_t i = 0; i < xex2Header->headerCount; i++)
-    {
-        const Xex2OptHeader &optHeader = xex2Header->headers[i];
-        if (optHeader.key == headerKey)
-        {
-            if ((headerKey & 0xFF) == 1)
-            {
-                return &optHeader.value;
-            }
-            else
-            {
-                return &moduleBytes.data()[optHeader.offset];
-            }
-        }
-    }
-
-    return nullptr;
-}
-
-struct mspack_memory_file
-{
-    mspack_system sys;
-    void *buffer;
-    size_t bufferSize;
-    size_t offset;
-};
-
-static mspack_memory_file *mspack_memory_open(mspack_system *sys, void *buffer, size_t bufferSize)
-{
-    assert(bufferSize < INT_MAX);
-
-    if (bufferSize >= INT_MAX)
-    {
-        return nullptr;
-    }
-
-    mspack_memory_file *memoryFile = (mspack_memory_file *)(std::calloc(1, sizeof(mspack_memory_file)));
-    if (memoryFile == nullptr)
-    {
-        return memoryFile;
-    }
-
-    memoryFile->buffer = buffer;
-    memoryFile->bufferSize = bufferSize;
-    memoryFile->offset = 0;
-    return memoryFile;
-}
-
-static void mspack_memory_close(mspack_memory_file *file)
-{
-    std::free(file);
-}
-
-static int mspack_memory_read(mspack_file *file, void *buffer, int chars)
-{
-    mspack_memory_file *memoryFile = (mspack_memory_file *)(file);
-    const size_t remaining = memoryFile->bufferSize - memoryFile->offset;
-    const size_t total = std::min(size_t(chars), remaining);
-    std::memcpy(buffer, (uint8_t *)(memoryFile->buffer) + memoryFile->offset, total);
-    memoryFile->offset += total;
-    return int(total);
-}
-
-static int mspack_memory_write(mspack_file *file, void *buffer, int chars)
-{
-    mspack_memory_file *memoryFile = (mspack_memory_file *)(file);
-    const size_t remaining = memoryFile->bufferSize - memoryFile->offset;
-    const size_t total = std::min(size_t(chars), remaining);
-    std::memcpy((uint8_t *)(memoryFile->buffer) + memoryFile->offset, buffer, total);
-    memoryFile->offset += total;
-    return int(total);
-}
-
-static void *mspack_memory_alloc(mspack_system *sys, size_t chars)
-{
-    return std::calloc(chars, 1);
-}
-
-static void mspack_memory_free(void *ptr)
-{
-    std::free(ptr);
-}
-
-static void mspack_memory_copy(void *src, void *dest, size_t chars)
-{
-    std::memcpy(dest, src, chars);
-}
-
-static mspack_system *mspack_memory_sys_create()
-{
-    auto sys = (mspack_system *)(std::calloc(1, sizeof(mspack_system)));
-    if (!sys)
-    {
-        return nullptr;
-    }
-
-    sys->read = mspack_memory_read;
-    sys->write = mspack_memory_write;
-    sys->alloc = mspack_memory_alloc;
-    sys->free = mspack_memory_free;
-    sys->copy = mspack_memory_copy;
-    return sys;
-}
-
-static void mspack_memory_sys_destroy(struct mspack_system *sys)
-{
-    free(sys);
-}
-
-#if defined(_WIN32)
-inline bool bitScanForward(uint32_t v, uint32_t *outFirstSetIndex)
-{
-    return _BitScanForward((unsigned long *)(outFirstSetIndex), v) != 0;
-}
-
-inline bool bitScanForward(uint64_t v, uint32_t *outFirstSetIndex)
-{
-    return _BitScanForward64((unsigned long *)(outFirstSetIndex), v) != 0;
-}
-
-#else
-inline bool bitScanForward(uint32_t v, uint32_t *outFirstSetIndex)
-{
-    int i = ffs(v);
-    *outFirstSetIndex = i - 1;
-    return i != 0;
-}
-
-inline bool bitScanForward(uint64_t v, uint32_t *outFirstSetIndex)
-{
-    int i = __builtin_ffsll(v);
-    *outFirstSetIndex = i - 1;
-    return i != 0;
-}
-#endif
-
-static int lzxDecompress(const void *lzxData, size_t lzxLength, void *dst, size_t dstLength, uint32_t windowSize, void *windowData, size_t windowDataLength)
-{
-    int resultCode = 1;
-    uint32_t windowBits;
-    if (!bitScanForward(windowSize, &windowBits)) {
-        return resultCode;
-    }
-
-    mspack_system *sys = mspack_memory_sys_create();
-    mspack_memory_file *lzxSrc = mspack_memory_open(sys, (void *)(lzxData), lzxLength);
-    mspack_memory_file *lzxDst = mspack_memory_open(sys, dst, dstLength);
-    lzxd_stream *lzxd = lzxd_init(sys, (mspack_file *)(lzxSrc), (mspack_file *)(lzxDst), windowBits, 0, 0x8000, dstLength, 0);
-    if (lzxd != nullptr) {
-        if (windowData != nullptr) {
-            size_t paddingLength = windowSize - windowDataLength;
-            std::memset(&lzxd->window[0], 0, paddingLength);
-            std::memcpy(&lzxd->window[paddingLength], windowData, windowDataLength);
-            lzxd->ref_data_size = windowSize;
-        }
-
-        resultCode = lzxd_decompress(lzxd, dstLength);
-        lzxd_free(lzxd);
-    }
-
-    if (lzxSrc) {
-        mspack_memory_close(lzxSrc);
-    }
-
-    if (lzxDst) {
-        mspack_memory_close(lzxDst);
-    }
-
-    if (sys) {
-        mspack_memory_sys_destroy(sys);
-    }
-
-    return resultCode;
-}
-
-static int lzxDeltaApplyPatch(const Xex2DeltaPatch *deltaPatch, uint32_t patchLength, uint32_t windowSize, uint8_t *dstData)
-{
-    const void *patchEnd = (const uint8_t *)(deltaPatch) + patchLength;
-    const Xex2DeltaPatch *curPatch = deltaPatch;
-    while (patchEnd > curPatch)
-    {
-        int patchSize = -4; 
-        if (curPatch->compressedLength == 0 && curPatch->uncompressedLength == 0 && curPatch->newAddress == 0 && curPatch->oldAddress == 0)
-        {
-            // End of patch.
-            break;
-        }
-
-        switch (curPatch->compressedLength)
-        {
-        case 0:
-            // Set the data to zeroes.
-            std::memset(&dstData[curPatch->newAddress], 0, curPatch->uncompressedLength);
-            break;
-        case 1:
-            // Move the data.
-            std::memcpy(&dstData[curPatch->newAddress], &dstData[curPatch->oldAddress], curPatch->uncompressedLength);
-            break;
-        default:
-            // Decompress the data into the destination.
-            patchSize = curPatch->compressedLength - 4;
-            int result = lzxDecompress(curPatch->patchData, curPatch->compressedLength, &dstData[curPatch->newAddress], curPatch->uncompressedLength, windowSize, &dstData[curPatch->oldAddress], curPatch->uncompressedLength);
-            if (result != 0)
-            {
-                return result;
-            }
-
-            break;
-        }
-
-        curPatch++;
-        curPatch = (const Xex2DeltaPatch *)((const uint8_t *)(curPatch) + patchSize);
-    }
-
-    return 0;
-}
-
-XexPatcher::Result XexPatcher::apply(std::span<const uint8_t> xexBytes, std::span<const uint8_t> patchBytes, std::vector<uint8_t> &outBytes, bool skipData)
-{
-    // Validate headers.
-    static const char Xex2Magic[] = "XEX2";
-    const Xex2Header *xexHeader = (const Xex2Header *)(xexBytes.data());
-    if (memcmp(xexBytes.data(), Xex2Magic, 4) != 0)
-    {
-        return Result::XexFileInvalid;
-    }
-
-    const Xex2Header *patchHeader = (const Xex2Header *)(patchBytes.data());
-    if (memcmp(patchBytes.data(), Xex2Magic, 4) != 0)
-    {
-        return Result::PatchFileInvalid;
-    }
-
-    if ((patchHeader->moduleFlags & (XEX_MODULE_MODULE_PATCH | XEX_MODULE_PATCH_DELTA | XEX_MODULE_PATCH_FULL)) == 0)
-    {
-        return Result::PatchFileInvalid;
-    }
-
-    // Validate patch.
-    const Xex2OptDeltaPatchDescriptor *patchDescriptor = (const Xex2OptDeltaPatchDescriptor *)(getOptHeaderPtr(patchBytes, XEX_HEADER_DELTA_PATCH_DESCRIPTOR));
-    if (patchDescriptor == nullptr)
-    {
-        return Result::PatchFileInvalid;
-    }
-    
-    const Xex2OptFileFormatInfo *patchFileFormatInfo = (const Xex2OptFileFormatInfo *)(getOptHeaderPtr(patchBytes, XEX_HEADER_FILE_FORMAT_INFO));
-    if (patchFileFormatInfo == nullptr)
-    {
-        return Result::PatchFileInvalid;
-    }
-
-    if (patchFileFormatInfo->compressionType != XEX_COMPRESSION_DELTA)
-    {
-        return Result::PatchFileInvalid;
-    }
-
-    if (patchDescriptor->deltaHeadersSourceOffset > xexHeader->headerSize)
-    {
-        return Result::PatchIncompatible;
-    }
-
-    if (patchDescriptor->deltaHeadersSourceSize > (xexHeader->headerSize - patchDescriptor->deltaHeadersSourceOffset))
-    {
-        return Result::PatchIncompatible;
-    }
-
-    if (patchDescriptor->deltaHeadersTargetOffset > patchDescriptor->sizeOfTargetHeaders)
-    {
-        return Result::PatchIncompatible;
-    }
-
-    uint32_t deltaTargetSize = patchDescriptor->sizeOfTargetHeaders - patchDescriptor->deltaHeadersTargetOffset;
-    if (patchDescriptor->deltaHeadersSourceSize > deltaTargetSize)
-    {
-        return Result::PatchIncompatible;
-    }
-
-    // Apply patch.
-    uint32_t headerTargetSize = patchDescriptor->sizeOfTargetHeaders;
-    if (headerTargetSize == 0)
-    {
-        headerTargetSize = patchDescriptor->deltaHeadersTargetOffset + patchDescriptor->deltaHeadersSourceSize;
-    }
-
-    // Create the bytes for the new XEX header. Copy over the existing data.
-    uint32_t newXexHeaderSize = std::max(headerTargetSize, xexHeader->headerSize.get());
-    outBytes.resize(newXexHeaderSize);
-    memset(outBytes.data(), 0, newXexHeaderSize);
-    memcpy(outBytes.data(), xexBytes.data(), headerTargetSize);
-
-    Xex2Header *newXexHeader = (Xex2Header *)(outBytes.data());
-    if (patchDescriptor->deltaHeadersSourceOffset > 0)
-    {
-        memcpy(&outBytes[patchDescriptor->deltaHeadersTargetOffset], &outBytes[patchDescriptor->deltaHeadersSourceOffset], patchDescriptor->deltaHeadersSourceSize);
-    }
-
-    int resultCode = lzxDeltaApplyPatch(&patchDescriptor->info, patchDescriptor->size, patchFileFormatInfo->compressionInfo.normal.windowSize, outBytes.data());
-    if (resultCode != 0)
-    {
-        return Result::PatchFailed;
-    }
-
-    // Make the header the specified size by the patch.
-    outBytes.resize(headerTargetSize);
-    newXexHeader = (Xex2Header *)(outBytes.data());
-
-    // Copy the rest of the data.
-    const Xex2SecurityInfo *newSecurityInfo = (const Xex2SecurityInfo *)(&outBytes[newXexHeader->securityOffset]);
-    outBytes.resize(outBytes.size() + newSecurityInfo->imageSize);
-    memset(&outBytes[headerTargetSize], 0, outBytes.size() - headerTargetSize);
-    memcpy(&outBytes[headerTargetSize], &xexBytes[xexHeader->headerSize], xexBytes.size() - xexHeader->headerSize);
-    newXexHeader = (Xex2Header *)(outBytes.data());
-    newSecurityInfo = (const Xex2SecurityInfo *)(&outBytes[newXexHeader->securityOffset]);
-    
-    // Decrypt the keys and validate that the patch is compatible with the base file.
-    static const uint32_t KeySize = 16;
-    static const uint8_t Xex2RetailKey[16] = { 0x20, 0xB1, 0x85, 0xA5, 0x9D, 0x28, 0xFD, 0xC3, 0x40, 0x58, 0x3F, 0xBB, 0x08, 0x96, 0xBF, 0x91 };
-    static const uint8_t AESBlankIV[AES_BLOCKLEN] = {};
-    const Xex2SecurityInfo *originalSecurityInfo = (const Xex2SecurityInfo *)(&xexBytes[xexHeader->securityOffset]);
-    const Xex2SecurityInfo *patchSecurityInfo = (const Xex2SecurityInfo *)(&patchBytes[patchHeader->securityOffset]);
-    uint8_t decryptedOriginalKey[KeySize];
-    uint8_t decryptedNewKey[KeySize];
-    uint8_t decryptedPatchKey[KeySize];
-    uint8_t decrpytedImageKeySource[KeySize];
-    memcpy(decryptedOriginalKey, originalSecurityInfo->aesKey, KeySize);
-    memcpy(decryptedNewKey, newSecurityInfo->aesKey, KeySize);
-    memcpy(decryptedPatchKey, patchSecurityInfo->aesKey, KeySize);
-    memcpy(decrpytedImageKeySource, patchDescriptor->imageKeySource, KeySize);
-
-    AES_ctx aesContext;
-    AES_init_ctx_iv(&aesContext, Xex2RetailKey, AESBlankIV);
-    AES_CBC_decrypt_buffer(&aesContext, decryptedOriginalKey, KeySize);
-
-    AES_ctx_set_iv(&aesContext, AESBlankIV);
-    AES_CBC_decrypt_buffer(&aesContext, decryptedNewKey, KeySize);
-
-    AES_init_ctx_iv(&aesContext, decryptedNewKey, AESBlankIV);
-    AES_CBC_decrypt_buffer(&aesContext, decryptedPatchKey, KeySize);
-
-    AES_ctx_set_iv(&aesContext, AESBlankIV);
-    AES_CBC_decrypt_buffer(&aesContext, decrpytedImageKeySource, KeySize);
-
-    // Validate the patch's key matches the one from the original XEX.
-    if (memcmp(decrpytedImageKeySource, decryptedOriginalKey, KeySize) != 0)
-    {
-        return Result::PatchIncompatible;
-    }
-
-    // Don't process the rest of the patch.
-    if (skipData)
-    {
-        return Result::Success;
-    }
-    
-    // Decrypt base XEX if necessary.
-    const Xex2OptFileFormatInfo *fileFormatInfo = (const Xex2OptFileFormatInfo *)(getOptHeaderPtr(xexBytes, XEX_HEADER_FILE_FORMAT_INFO));
-    if (fileFormatInfo == nullptr)
-    {
-        return Result::XexFileInvalid;
-    }
-
-    if (fileFormatInfo->encryptionType == XEX_ENCRYPTION_NORMAL)
-    {
-        AES_init_ctx_iv(&aesContext, decryptedOriginalKey, AESBlankIV);
-        AES_CBC_decrypt_buffer(&aesContext, &outBytes[headerTargetSize], xexBytes.size() - xexHeader->headerSize);
-    }
-    else if (fileFormatInfo->encryptionType != XEX_ENCRYPTION_NONE)
-    {
-        return Result::XexFileInvalid;
-    }
-
-    // Decompress base XEX if necessary.
-    if (fileFormatInfo->compressionType == XEX_COMPRESSION_BASIC)
-    {
-        const Xex2FileBasicCompressionBlock *blocks = &fileFormatInfo->compressionInfo.basic.firstBlock;
-        int32_t numBlocks = (fileFormatInfo->infoSize / sizeof(Xex2FileBasicCompressionBlock)) - 1;
-        int32_t baseCompressedSize = 0;
-        int32_t baseImageSize = 0;
-        for (int32_t i = 0; i < numBlocks; i++) {
-            baseCompressedSize += blocks[i].dataSize;
-            baseImageSize += blocks[i].dataSize + blocks[i].zeroSize;
-        }
-
-        if (outBytes.size() < (headerTargetSize + baseImageSize))
-        {
-            return Result::XexFileInvalid;
-        }
-        
-        // Reverse iteration allows to perform this decompression in place.
-        uint8_t *srcDataCursor = outBytes.data() + headerTargetSize + baseCompressedSize;
-        uint8_t *outDataCursor = outBytes.data() + headerTargetSize + baseImageSize;
-        for (int32_t i = numBlocks - 1; i >= 0; i--)
-        {
-            outDataCursor -= blocks[i].zeroSize;
-            memset(outDataCursor, 0, blocks[i].zeroSize);
-            outDataCursor -= blocks[i].dataSize;
-            srcDataCursor -= blocks[i].dataSize;
-            memmove(outDataCursor, srcDataCursor, blocks[i].dataSize);
-        }
-    }
-    else if (fileFormatInfo->compressionType == XEX_COMPRESSION_NORMAL || fileFormatInfo->compressionType == XEX_COMPRESSION_DELTA)
-    {
-        return Result::XexFileUnsupported;
-    }
-    else if (fileFormatInfo->compressionType != XEX_COMPRESSION_NONE)
-    {
-        return Result::XexFileInvalid;
-    }
-
-    Xex2OptFileFormatInfo *newFileFormatInfo = (Xex2OptFileFormatInfo *)(getOptHeaderPtr(outBytes, XEX_HEADER_FILE_FORMAT_INFO));
-    if (newFileFormatInfo == nullptr)
-    {
-        return Result::PatchFailed;
-    }
-    
-    // Update the header to indicate no encryption or compression is used.
-    newFileFormatInfo->encryptionType = XEX_ENCRYPTION_NONE;
-    newFileFormatInfo->compressionType = XEX_COMPRESSION_NONE;
-
-    // Copy and decrypt patch data if necessary.
-    std::vector<uint8_t> patchData;
-    patchData.resize(patchBytes.size() - patchHeader->headerSize);
-    memcpy(patchData.data(), &patchBytes[patchHeader->headerSize], patchData.size());
-
-    if (patchFileFormatInfo->encryptionType == XEX_ENCRYPTION_NORMAL)
-    {
-        AES_init_ctx_iv(&aesContext, decryptedPatchKey, AESBlankIV);
-        AES_CBC_decrypt_buffer(&aesContext, patchData.data(), patchData.size());
-    }
-    else if (patchFileFormatInfo->encryptionType != XEX_ENCRYPTION_NONE)
-    {
-        return Result::PatchFileInvalid;
-    }
-
-    const Xex2CompressedBlockInfo *currentBlock = &patchFileFormatInfo->compressionInfo.normal.firstBlock;
-    uint8_t *outExe = &outBytes[newXexHeader->headerSize];
-    if (patchDescriptor->deltaImageSourceOffset > 0)
-    {
-        memcpy(&outExe[patchDescriptor->deltaImageTargetOffset], &outExe[patchDescriptor->deltaImageSourceOffset], patchDescriptor->deltaImageSourceSize);
-    }
-
-    static const uint32_t DigestSize = 20;
-    uint8_t sha1Digest[DigestSize];
-    sha1::SHA1 sha1Context;
-    uint8_t *patchDataCursor = patchData.data();
-    while (currentBlock->blockSize > 0)
-    {
-        const Xex2CompressedBlockInfo *nextBlock = (const Xex2CompressedBlockInfo *)(patchDataCursor);
-
-        // Hash and validate the block.
-        sha1Context.reset();
-        sha1Context.processBytes(patchDataCursor, currentBlock->blockSize);
-        sha1Context.finalize(sha1Digest);
-        if (memcmp(sha1Digest, currentBlock->blockHash, DigestSize) != 0)
-        {
-            return Result::PatchFailed;
-        }
-
-        patchDataCursor += 24;
-
-        // Apply the block's patch data.
-        uint32_t blockDataSize = currentBlock->blockSize - 24;
-        if (lzxDeltaApplyPatch((const Xex2DeltaPatch *)(patchDataCursor), blockDataSize, patchFileFormatInfo->compressionInfo.normal.windowSize, outExe) != 0)
-        {
-            return Result::PatchFailed;
-        }
-
-        patchDataCursor += blockDataSize;
-        currentBlock = nextBlock;
-    }
-
-    return Result::Success;
-}
-
-XexPatcher::Result XexPatcher::apply(const std::filesystem::path &baseXexPath, const std::filesystem::path &patchXexPath, const std::filesystem::path &newXexPath)
-{
-    MemoryMappedFile baseXexFile(baseXexPath);
-    MemoryMappedFile patchFile(patchXexPath);
-    if (!baseXexFile.isOpen() || !patchFile.isOpen())
-    {
-        return Result::FileOpenFailed;
-    }
-
-    std::vector<uint8_t> newXexBytes;
-    Result result = apply({ baseXexFile.data(), baseXexFile.size() }, { patchFile.data(), patchFile.size() }, newXexBytes, false);
-    if (result != Result::Success)
-    {
-        return result;
-    }
-
-    std::ofstream newXexFile(newXexPath, std::ios::binary);
-    if (!newXexFile.is_open())
-    {
-        return Result::FileOpenFailed;
-    }
-
-    newXexFile.write((const char *)(newXexBytes.data()), newXexBytes.size());
-    newXexFile.close();
-
-    if (newXexFile.bad())
-    {
-        std::filesystem::remove(newXexPath);
-        return Result::FileWriteFailed;
-    }
-
-    return Result::Success;
-}

UnleashedRecomp/install/xex_patcher.h

@@ -1,35 +0,0 @@
-// Referenced from: https://github.com/xenia-canary/xenia-canary/blob/canary_experimental/src/xenia/cpu/xex_module.cc
-
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2023 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#pragma once
-
-#include <cstdint>
-#include <filesystem>
-#include <span>
-#include <vector>
-
-struct XexPatcher
-{
-    enum class Result {
-        Success,
-        FileOpenFailed,
-        FileWriteFailed,
-        XexFileUnsupported,
-        XexFileInvalid,
-        PatchFileInvalid,
-        PatchIncompatible,
-        PatchFailed,
-        PatchUnsupported
-    };
-
-    static Result apply(std::span<const uint8_t> xexBytes, std::span<const uint8_t> patchBytes, std::vector<uint8_t> &outBytes, bool skipData);
-    static Result apply(const std::filesystem::path &baseXexPath, const std::filesystem::path &patchXexPath, const std::filesystem::path &newXexPath);
-};

UnleashedRecomp/kernel/io/file_system.cpp

@@ -1,11 +1,12 @@
-#include <stdafx.h>
 #include "file_system.h"
+#include <cpu/guest_thread.h>
 #include <kernel/xam.h>
 #include <kernel/xdm.h>
 #include <kernel/function.h>
-#include <cpu/guest_thread.h>
-#include <os/logger.h>
 #include <mod/mod_loader.h>
+#include <os/logger.h>
+#include <user/config.h>
+#include <stdafx.h>
 
 struct FileHandle : KernelObject
 {
@@ -365,8 +366,14 @@ std::filesystem::path FileSystem::ResolvePath(const std::string_view& path, bool
     if (checkForMods)
     {
         std::filesystem::path resolvedPath = ModLoader::ResolvePath(path);
+
         if (!resolvedPath.empty())
+        {
+            if (ModLoader::s_isLogTypeConsole)
+                LOGF_IMPL(Utility, "Mod Loader", "Loading file: \"{}\"", reinterpret_cast<const char*>(resolvedPath.u8string().c_str()));
+
             return resolvedPath;
+        }
     }
 
     thread_local std::string builtPath;

UnleashedRecomp/kernel/xam.cpp

@@ -466,6 +466,18 @@ uint32_t XamInputGetState(uint32_t userIndex, uint32_t flags, XAMINPUT_STATE* st
 
     state->Gamepad.wButtons &= ~hid::g_prohibitedButtons;
 
+    if (hid::g_isLeftStickProhibited)
+    {
+        state->Gamepad.sThumbLX = 0;
+        state->Gamepad.sThumbLY = 0;
+    }
+
+    if (hid::g_isRightStickProhibited)
+    {
+        state->Gamepad.sThumbRX = 0;
+        state->Gamepad.sThumbRY = 0;
+    }
+
     ByteSwapInplace(state->Gamepad.wButtons);
     ByteSwapInplace(state->Gamepad.sThumbLX);
     ByteSwapInplace(state->Gamepad.sThumbLY);

UnleashedRecomp/kernel/xdbf.h

@@ -10,12 +10,12 @@ namespace xdbf
 {
     inline std::string& FixInvalidSequences(std::string& str)
     {
-        static std::vector<std::string> invalidSequences =
+        static std::array<std::string_view, 1> invalidSequences =
         {
             "\xE2\x80\x99"
         };
 
-        static std::vector<std::string> replaceSequences =
+        static std::array<std::string_view, 1> replaceSequences =
         {
             "'"
         };

UnleashedRecomp/locale/config_locale.cpp

@@ -15,6 +15,34 @@
       360, which is one of the few consoles to have a port of Sonic
       Unleashed.
 
+    - Ensure your locale is added in the correct order following the language enum.
+
+      Correct:
+      {
+          { ELanguage::English,  "Example" },
+          { ELanguage::Japanese, "Example" },
+          { ELanguage::German,   "Example" },
+          { ELanguage::French,   "Example" },
+          { ELanguage::Spanish,  "Example" },
+          { ELanguage::Italian,  "Example" }
+      }
+
+      Incorrect:
+      {
+          { ELanguage::English,  "Example" },
+          { ELanguage::French,   "Example" },
+          { ELanguage::Spanish,  "Example" },
+          { ELanguage::German,   "Example" },
+          { ELanguage::Italian,  "Example" },
+          { ELanguage::Japanese, "Example" }
+      }
+
+    - Japanese localization should use furigana for message windows, options items,
+    options descriptions and installer text.
+
+      Furigana should be included in the text as such:
+      "[私:わたし]はジョージです。"
+
     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 */
 
@@ -24,16 +52,18 @@
 #define CONFIG_DEFINE_ENUM_LOCALE(type) \
     CONFIG_ENUM_LOCALE(type) g_##type##_locale =
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(Language)
 {
     { ELanguage::English,  { "Language", "Change the language used for text and logos." } },
-    { ELanguage::Japanese, { "言語", "" } },
-    { ELanguage::German,   { "Sprache", "" } },
-    { ELanguage::French,   { "Langue", "" } },
-    { ELanguage::Spanish,  { "Idioma", "" } },
-    { ELanguage::Italian,  { "Lingua", "" } }
+    { ELanguage::Japanese, { "[言語:げんご]", "ゲーム[内:ない]の\u200B[表示言語:ひょうじげんご]を\u200B[変更:へんこう]できます" } },
+    { ELanguage::German,   { "Sprache", "Ändere die Sprache für Text und Logos." } },
+    { ELanguage::French,   { "Langue", "Modifie la langue utilisée pour le texte et logos." } },
+    { ELanguage::Spanish,  { "Idioma", "Cambia el idioma utilizado para el texto y los logos." } },
+    { ELanguage::Italian,  { "Lingua", "Cambia la lingua utilizzata per i testi e i logo." } }
 };
 
+// Notes: do not localise this.
 CONFIG_DEFINE_ENUM_LOCALE(ELanguage)
 {
     {
@@ -95,26 +125,51 @@ CONFIG_DEFINE_ENUM_LOCALE(EVoiceLanguage)
     },
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(Hints)
 {
-    { ELanguage::English, { "Hints", "Show hint rings in stages." } }
+    { ELanguage::English,  { "Hints", "Show hints during gameplay." } },
+    { ELanguage::Japanese, { "ヒントリング", "ゲーム[内:ない]に\u200Bヒントリングを\u200B[表示:ひょうじ]するか\u200B[選択:せんたく]できます" } },
+    { ELanguage::German,   { "Hinweise", "Zeige Hinweise während des Spiels." } },
+    { ELanguage::French,   { "Indices", "Affiche les indices pendant le jeu." } },
+    { ELanguage::Spanish,  { "Pistas", "Muestra pistas durante el juego." } },
+    { ELanguage::Italian,  { "Indizi", "Mostra degli indizzi durante il gioco." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(ControlTutorial)
 {
-    { ELanguage::English, { "Control Tutorial", "Show controller hints in stages." } }
+    { ELanguage::English,  { "Control Tutorial", "Show controller hints during gameplay.\n\nThe Werehog Critical Attack prompt will be unaffected." } },
+    { ELanguage::Japanese, { "アクションナビ", "ゲーム[内:ない]に\u200Bアクションナビを\u200B[表示:ひょうじ]するか\u200B[選択:せんたく]できます\n\n「チャンスアタック」の\u200B[表示:ひょうじ]は\u200B[影響:えいきょう]されません" } },
+    { ELanguage::German,   { "Steuerungsanleitung", "Zeige Steuerungshinweise während des Spiels.\n\nKritische Angriffe des Werehogs werden hiervon nicht beeinflusst." } },
+    { ELanguage::French,   { "Indication des commandes", "Affiche les indications des commandes pendant le jeu.\n\nCeci n'affecte pas les Coup critiques du Werehog." } },
+    { ELanguage::Spanish,  { "Tutorial de controles", "Muestra pistas de controles durante el juego.\n\nEl indicador de ataque crítico del Werehog no se verá afectado." } },
+    { ELanguage::Italian,  { "Tutorial dei comandi", "Mostra i tutorial dei comandi durante il gioco.\n\nIl tutorial per l'attacco critico del Werehog non verrà influenzato da questa opzione." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(AchievementNotifications)
 {
-    { ELanguage::English, { "Achievement Notifications", "Show notifications for unlocking achievements.\n\nAchievements will still be rewarded with notifications disabled." } }
+    { ELanguage::English,  { "Achievement Notifications", "Show notifications for unlocking achievements.\n\nAchievements will still be rewarded with notifications disabled." } },
+    { ELanguage::Japanese, { "[実績通知:じっせきつうち]", "[実績通知:じっせきつうち]の\u200B[有無:うむ]を\u200B[選択:せんたく]できます\n\nオフにしても\u200B[実績:じっせき]は\u200B[付与:ふよ]されます" } },
+    { ELanguage::German,   { "Erfolgsbenachrichtigungen", "Zeige Benachrichtigungen für das Freischalten von Erfolgen.\n\nErfolge werden weiterhin freigeschaltet, auch wenn die Benachrichtigungen ausgeschaltet sind." } },
+    { ELanguage::French,   { "Notification des succès", "Affiche les notifications pour le déverrouillage des succès.\n\nLes succès seront toujours obtenus même si les notifications sont désactivées." } },
+    { ELanguage::Spanish,  { "Notificaciones de logros", "Muestra notificaciones al desbloquear logros.\n\nLos logros se seguirán obteniendo aunque las notificaciones estén desactivadas." } },
+    { ELanguage::Italian,  { "Notifiche obiettivi", "Mostra delle notifiche quando sblocchi degli obiettivi.\n\nGli obiettivi verranno comunque assegnati anche con le notifiche disattivate." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(TimeOfDayTransition)
 {
-    { ELanguage::English, { "Time of Day Transition", "Change how the loading screen appears when switching time of day in the hub areas." } }
+    { ELanguage::English,  { "Time of Day Transition", "Change how the loading screen appears when switching time of day in the hub areas." } },
+    { ELanguage::Japanese, { "[昼夜:ちゅうや]きりかえのシーン", "[昼夜:ちゅうや]きりかえの\u200Bシーンを\u200B[選択:せんたく]できます" } },
+    { ELanguage::German,   { "Tageszeit Übergang", "Verändere den Ladebildschirm beim Verändern der Tageszeit in Städten und Eingangslevel." } },
+    { ELanguage::French,   { "Transition jour/nuit", "Change l'écran de chargement lors de la transition dans le hub." } },
+    { ELanguage::Spanish,  { "Transición de hora del día", "Cambia cómo aparece la pantalla de carga al cambiar la hora del día en las áreas principales." } },
+    { ELanguage::Italian,  { "Transizione giorno/notte", "Modifica l'aspetto della schermata di caricamento quando fai scorrere il tempo." } }
 };
 
+// Japanese Notes: This localization should include furigana in its description.
 CONFIG_DEFINE_ENUM_LOCALE(ETimeOfDayTransition)
 {
     {
@@ -123,14 +178,56 @@ CONFIG_DEFINE_ENUM_LOCALE(ETimeOfDayTransition)
             { ETimeOfDayTransition::Xbox,        { "XBOX", "Xbox: the transformation cutscene will play with artificial loading times." } },
             { ETimeOfDayTransition::PlayStation, { "PLAYSTATION", "PlayStation: a spinning medal loading screen will be used instead." } }
         }
+    },
+    {
+        ELanguage::Japanese,
+        {
+            { ETimeOfDayTransition::Xbox,        { "XBOX", "Xbox: [変身:へんしん]シーンは\u200B[人工的:じんこうてき]な\u200B[読:よ]み[込:こ]み[時間:じかん]で\u200B[再生:さいせい]されます" } },
+            { ETimeOfDayTransition::PlayStation, { "PLAYSTATION", "PlayStation: [回転:かいてん]するメダル\u200B[読:よ]み[込:こ]み[画面:がめん]が\u200B[使用:しよう]されます" } }
+        }
+    },
+    {
+        ELanguage::German,
+        {
+            { ETimeOfDayTransition::Xbox,        { "XBOX", "Xbox: Eine Transformationszwischensequenz mit künstlicher Ladezeit wird abgespielt." } },
+            { ETimeOfDayTransition::PlayStation, { "PLAYSTATION", "PlayStation: Eine sich drehende Medallie wird stattdessen als Ladebildschirm verwendet." } }
+        }
+    },
+    {
+        ELanguage::French,
+        {
+            { ETimeOfDayTransition::Xbox,        { "XBOX", "Xbox: la scène de transformation sera jouée avec des temps de chargement artificiel." } },
+            { ETimeOfDayTransition::PlayStation, { "PLAYSTATION", "PlayStation: un écran de chargement avec une médaille tournoyante sera utilisé à la place." } }
+        }
+    },
+    {
+        ELanguage::Spanish,
+        {
+            { ETimeOfDayTransition::Xbox,        { "XBOX", "Xbox: la cinemática de transformación se reproducirá con tiempos de carga artificiales." } },
+            { ETimeOfDayTransition::PlayStation, { "PLAYSTATION", "PlayStation: se usará una pantalla de carga con una medalla giratoria." } }
+        }
+    },
+    {
+        ELanguage::Italian,
+        {
+            { ETimeOfDayTransition::Xbox,        { "XBOX", "Xbox: la scena di trasformazione verrà riprodotta con tempi di caricamento artificiali." } },
+            { ETimeOfDayTransition::PlayStation, { "PLAYSTATION", "PlayStation: verrà utilizzata una schermata di caricamento con una medaglia che gira." } }
+        }
     }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(ControllerIcons)
 {
-    { ELanguage::English, { "Controller Icons", "Change the icons to match your controller." } }
+    { ELanguage::English,  { "Controller Icons", "Change the icons to match your controller." } },
+    { ELanguage::Japanese, { "コントローライコン", "ゲーム[内:ない]の\u200Bコントローライコンを\u200B[変更:へんこう]できます" } },
+    { ELanguage::German,   { "Controllersymbole", "Ändere die Controllersymbole, um sie auf dein Modell anzupassen." } },
+    { ELanguage::French,   { "Icône des boutons", "Modifie les icônes pour les faire correspondre à votre manette." } },
+    { ELanguage::Spanish,  { "Iconos del mando", "Cambia los iconos para que coincidan con tu mando." } },
+    { ELanguage::Italian,  { "Icone dei tasti", "Modifica le icone per farle corrispondere con il tuo controller." } }
 };
 
+// Japanese Notes: This localization should include furigana in its description.
 CONFIG_DEFINE_ENUM_LOCALE(EControllerIcons)
 {
     {
@@ -140,17 +237,69 @@ CONFIG_DEFINE_ENUM_LOCALE(EControllerIcons)
             { EControllerIcons::Xbox,        { "XBOX", "" } },
             { EControllerIcons::PlayStation, { "PLAYSTATION", "" } }
         }
+    },
+    {
+        ELanguage::Japanese,
+        {
+            { EControllerIcons::Auto,        { "自動検出", "[自動検出:じどうけんしゅつ]: ゲーム[内:ない]の\u200Bコントローライコンを\u200B[自動検出:じどうけんしゅつ]されます" } },
+            { EControllerIcons::Xbox,        { "XBOX", "" } },
+            { EControllerIcons::PlayStation, { "PLAYSTATION", "" } }
+        }
+    },
+    {
+        ELanguage::German,
+        {
+            { EControllerIcons::Auto,        { "AUTO", "Auto: Das Spiel erkennt automatisch deinen Controller um die Symbole dementsprechend anzupassen." } },
+            { EControllerIcons::Xbox,        { "XBOX", "" } },
+            { EControllerIcons::PlayStation, { "PLAYSTATION", "" } }
+        }
+    },
+    {
+        ELanguage::French,
+        {
+            { EControllerIcons::Auto,        { "AUTO", "Auto: le jeu déterminera automatiquement quelles icônes utiliser en fonction du périphérique d'entrée." } },
+            { EControllerIcons::Xbox,        { "XBOX", "" } },
+            { EControllerIcons::PlayStation, { "PLAYSTATION", "" } }
+        }
+    },
+    {
+        ELanguage::Spanish,
+        {
+            { EControllerIcons::Auto,        { "AUTO", "Auto: el juego determinará de forma automática qué iconos utilizar dependiendo del dispositivo de entrada actual." } },
+            { EControllerIcons::Xbox,        { "XBOX", "" } },
+            { EControllerIcons::PlayStation, { "PLAYSTATION", "" } }
+        }
+    },
+    {
+        ELanguage::Italian,
+        {
+            { EControllerIcons::Auto,        { "AUTO", "Auto: il gioco determinerà quali icone da utilizzare in base al dispositivo di input attuale." } },
+            { EControllerIcons::Xbox,        { "XBOX", "" } },
+            { EControllerIcons::PlayStation, { "PLAYSTATION", "" } }
+        }
     }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(HorizontalCamera)
 {
-    { ELanguage::English, { "Horizontal Camera", "Change how the camera moves left and right." } }
+    { ELanguage::English,  { "Horizontal Camera", "Change how the camera moves left and right." } },
+    { ELanguage::Japanese, { "カメラの[左右:さゆう]", "カメラ[左右:さゆう]の\u200B[動:うご]く[方向:ほうこう]を\u200B[選択:せんたく]できます" } },
+    { ELanguage::German,   { "Horizontale Kamera", "Ändere wie sich die Kamera nach links und rechts bewegt." } },
+    { ELanguage::French,   { "Caméra horizontale", "Modifie la rotation horizontale de la caméra." } },
+    { ELanguage::Spanish,  { "Cámara horizontal", "Cambia cómo se mueve la camara hacia la izquierda y la derecha." } },
+    { ELanguage::Italian,  { "Telecamera orizzontale", "Modifica come la telecamera si muove da sinistra a destra." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(VerticalCamera)
 {
-    { ELanguage::English, { "Vertical Camera", "Change how the camera moves up and down." } }
+    { ELanguage::English,  { "Vertical Camera", "Change how the camera moves up and down." } },
+    { ELanguage::Japanese, { "カメラの[上下:じょうげ]", "カメラ[上下:じょうげ]の\u200B[動:うご]く[方向:ほうこう]を\u200B[選択:せんたく]できます" } },
+    { ELanguage::German,   { "Vertikale Kamera", "Ändere wie sich die Kamera nach oben und unten bewegt." } },
+    { ELanguage::French,   { "Caméra verticale", "Modifie la rotation verticale de la caméra." } },
+    { ELanguage::Spanish, { "Cámara vertical", "Cambia cómo se mueve la camara hacia arriba y abajo." } },
+    { ELanguage::Italian,  { "Telecamera verticale", "Modifica come la telecamera si muove su e giù." } }
 };
 
 CONFIG_DEFINE_ENUM_LOCALE(ECameraRotationMode)
@@ -161,42 +310,119 @@ CONFIG_DEFINE_ENUM_LOCALE(ECameraRotationMode)
             { ECameraRotationMode::Normal,  { "NORMAL", "" } },
             { ECameraRotationMode::Reverse, { "REVERSE", "" } }
         }
+    },
+    {
+        ELanguage::Japanese,
+        {
+            { ECameraRotationMode::Normal,  { "ノーマル", "" } },
+            { ECameraRotationMode::Reverse, { "リバース", "" } }
+        }
+    },
+    {
+        ELanguage::German,
+        {
+            { ECameraRotationMode::Normal,  { "NORMAL", "" } },
+            { ECameraRotationMode::Reverse, { "INVERTIERT", "" } }
+        }
+    },
+    {
+        ELanguage::French,
+        {
+            { ECameraRotationMode::Normal,  { "NORMALE", "" } },
+            { ECameraRotationMode::Reverse, { "INVERSÉE", "" } }
+        }
+    },
+    {
+        ELanguage::Spanish,
+        {
+            { ECameraRotationMode::Normal,  { "NORMAL", "" } },
+            { ECameraRotationMode::Reverse, { "INVERTIDO", "" } }
+        }
+    },
+    {
+        ELanguage::Italian,
+        {
+            { ECameraRotationMode::Normal,  { "NORMALE", "" } },
+            { ECameraRotationMode::Reverse, { "INVERTITA", "" } }
+        }
     }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(Vibration)
 {
-    { ELanguage::English, { "Vibration", "Toggle controller vibration." } }
+    { ELanguage::English,  { "Vibration", "Toggle controller vibration." } },
+    { ELanguage::Japanese, { "[振動:しんどう]", "[振動:しんどう]の\u200B[有無:うむ]を\u200B[選択:せんたく]できます" } },
+    { ELanguage::German,   { "Vibration", "Schalte die Controllervibration an oder aus." } },
+    { ELanguage::French,   { "Vibration", "Active les vibrations manette." } },
+    { ELanguage::Spanish,  { "Vibración", "Activa o desactiva la vibración del mando." } },
+    { ELanguage::Italian,  { "Vibrazione", "Attiva/disattiva la vibrazione del controller." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(AllowBackgroundInput)
 {
-    { ELanguage::English, { "Allow Background Input", "Allow controller input whilst the game window is unfocused." } }
+    { ELanguage::English,  { "Allow Background Input", "Allow controller input whilst the game window is unfocused." } },
+    { ELanguage::Japanese, { "バックグラウンド[入力:にゅうりょく]", "フォーカスされていない\u200Bゲームに\u200B[入力:にゅうりょく]できるか\u200B[選択:せんたく]できます" } },
+    { ELanguage::German,   { "Erlaube Hintergrundeingaben", "Erlaube Eingaben deines Controllers auch wenn das Spielfenster nicht fokussiert ist." } },
+    { ELanguage::French,   { "Manette en arrière plan", "Permet d'utiliser la manette dans le jeu lorsque qu'il n'est pas au premier plan." } },
+    { ELanguage::Spanish,  { "Control en segundo plano", "Permite controlar el juego con un mando mientras la ventana esté en segundo plano." } },
+    { ELanguage::Italian,  { "Input con la finestra inattiva", "Attiva/disattiva i tasti del controller mentre la finestra è inattiva." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(MasterVolume)
 {
-    { ELanguage::English, { "Master Volume", "Adjust the overall volume." } }
+    { ELanguage::English,  { "Master Volume", "Adjust the overall volume." } },
+    { ELanguage::Japanese, { "マスターボリューム", "[全体:ぜんたい]ボリュームの\u200B[大:おお]きさを\u200B[調整:ちょうせい]できます" } },
+    { ELanguage::German,   { "Gesamtlautstärke", "Passe die Gesamtlautstärke an." } },
+    { ELanguage::French,   { "Volume général", "Réglage du volume général." } },
+    { ELanguage::Spanish,  { "Volumen maestro", "Ajusta el volumen general." } },
+    { ELanguage::Italian,  { "Volume principale", "Regola il volume principale" } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(MusicVolume)
 {
-    { ELanguage::English, { "Music Volume", "Adjust the volume for the music." } }
+    { ELanguage::English,  { "Music Volume", "Adjust the volume for the music." } },
+    { ELanguage::Japanese, { "BGMボリューム", "BGMボリュームの\u200B[大:おお]きさを\u200B[調整:ちょうせい]できます" } },
+    { ELanguage::German,   { "Musiklautstärke", "Passe die Lautstärke der Musik an." } },
+    { ELanguage::French,   { "Volume de la musique", "Réglage du volume de la musique." } },
+    { ELanguage::Spanish,  { "Volumen de la música", "Ajusta el volumen de la música." } },
+    { ELanguage::Italian,  { "Volume musica di sottofondo", "Regola il volume della musica di sottofondo." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(EffectsVolume)
 {
-    { ELanguage::English, { "Effects Volume", "Adjust the volume for sound effects." } }
+    { ELanguage::English,  { "Effects Volume", "Adjust the volume for sound effects." } },
+    { ELanguage::Japanese, { "SEボリューム", "SEボリュームの\u200B[大:おお]きさを\u200B[調整:ちょうせい]できます" } },
+    { ELanguage::German,   { "Soundeffektlautstärke", "Passe die Lautstärke der Soundeffekte an." } },
+    { ELanguage::French,   { "Volume des effets sonores", "Réglage du volume des effets sonores." } },
+    { ELanguage::Spanish,  { "Volumen de efectos", "Ajusta el volumen de los efectos de sonido." } },
+    { ELanguage::Italian,  { "Volume effetti sonori", "Regola il volume degli effetti sonori." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(MusicAttenuation)
 {
-    { ELanguage::English, { "Music Attenuation", "Fade out the game's music when external media is playing." } }
+    { ELanguage::English,  { "Music Attenuation", "Fade out the game's music when external media is playing." } },
+    { ELanguage::Japanese, { "BGM[減衰:げんすい]", "[外部:がいぶ]メディアを\u200B[再生:さいせい]すると\u200Bゲームの\u200B[音楽:おんがく]を\u200Bフェードアウトされます" } },
+    { ELanguage::German,   { "Musikdämpfung", "Stelle die Musik des Spiels stumm während externe Medien abgespielt werden." } },
+    { ELanguage::French,   { "Atténuation audio", "Abaisse le volume des musiques du jeu lorsqu'un média externe est en cours de lecture." } },
+    { ELanguage::Spanish,  { "Atenuación de música", "Atenúa la música del juego cuando un reproductor multimedia se encuentra activo." } },
+    { ELanguage::Italian,  { "Attenuazione musica", "Abbassa il volume della musica di sottofondo quando un'altra applicazione riproduce dei suoni." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(ChannelConfiguration)
 {
-    { ELanguage::English, { "Channel Configuration", "Change the output mode for your playback device." } }
+    { ELanguage::English,  { "Channel Configuration", "Change the output mode for your audio device." } },
+    { ELanguage::Japanese, { "チャンネル[設定:せってい]", "オーディオデバイスの\u200B[\u2005出\u2005力\u2005:しゅつりょく]モード\u200Bを[変更:へんこう]できます" } },
+    { ELanguage::German,   { "Kanalkonfiguration", "Ändere den Ausgabemodus für dein Audioausgabegerät." } },
+    { ELanguage::French,   { "Configuration sortie audio", "Modifie le mode de sortie pour votre périphérique audio." } },
+    { ELanguage::Spanish,  { "Configuración de canales", "Cambia el modo de salida para tu dispositivo de audio." } },
+    { ELanguage::Italian,  { "Configurazione canali audio", "Modifica la modalità di output per il tuo dispositivo audio." } }
 };
 
 CONFIG_DEFINE_ENUM_LOCALE(EChannelConfiguration)
@@ -207,39 +433,111 @@ CONFIG_DEFINE_ENUM_LOCALE(EChannelConfiguration)
             { EChannelConfiguration::Stereo,   { "STEREO", "" } },
             { EChannelConfiguration::Surround, { "SURROUND", "" } }
         }
+    },
+    {
+        ELanguage::Japanese,
+        {
+            { EChannelConfiguration::Stereo,   { "ステレオ", "" } },
+            { EChannelConfiguration::Surround, { "サラウンド", "" } }
+        }
+    },
+    {
+        ELanguage::German,
+        {
+            { EChannelConfiguration::Stereo,   { "STEREO", "" } },
+            { EChannelConfiguration::Surround, { "SURROUND", "" } }
+        }
+    },
+    {
+        ELanguage::French,
+        {
+            { EChannelConfiguration::Stereo,   { "STÉRÉO", "" } },
+            { EChannelConfiguration::Surround, { "SURROUND", "" } }
+        }
+    },
+    {
+        ELanguage::Spanish,
+        {
+            { EChannelConfiguration::Stereo,   { "ESTÉREO", "" } },
+            { EChannelConfiguration::Surround, { "ENVOLVENTE", "" } }
+        }
+    },
+    {
+        ELanguage::Italian,
+        {
+            { EChannelConfiguration::Stereo,   { "STEREO", "" } },
+            { EChannelConfiguration::Surround, { "SURROUND", "" } }
+        }
     }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(VoiceLanguage)
 {
-    { ELanguage::English, { "Voice Language", "Change the language used for character voices." } }
+    { ELanguage::English,  { "Voice Language", "Change the language used for character voices." } },
+    { ELanguage::Japanese, { "[音声言語:おんせいげんご]", "ゲーム[内:ない]の\u200B[音声言語:おんせいげんご]を\u200B[変更:へんこう]できます" } },
+    { ELanguage::German,   { "Stimmeinstellung", "Ändere die Sprache, die für Charakterstimmen benutzt wird." } },
+    { ELanguage::French,   { "Langue de doublage", "Modifie la langue utilisée pour la voix des personnages." } },
+    { ELanguage::Spanish,  { "Idioma de voz", "Cambia el idioma utilizado para las voces de los personajes." } },
+    { ELanguage::Italian, { "Lingua delle voci", "Modifica la lingua utilizzata per le voci dei personaggi." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(Subtitles)
 {
-    { ELanguage::English, { "Subtitles", "Show subtitles during dialogue." } }
+    { ELanguage::English,  { "Subtitles", "Show subtitles during dialogue." } },
+    { ELanguage::Japanese, { "[字幕:じまく]", "[字幕:じまく]の[表示:ひょうじ]を\u200B[選択:せんたく]できます" } },
+    { ELanguage::German,   { "Untertitel", "Zeige Untertitel bei Dialogen." } },
+    { ELanguage::French,   { "Sous-titres", "Affiche les sous-titres pendant les dialogues." } },
+    { ELanguage::Spanish,  { "Subtítulos", "Muestra subtítulos durante los diálogos." } },
+    { ELanguage::Italian,  { "Sottotitoli", "Mostra i sottotitoli durante i dialoghi." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(BattleTheme)
 {
-    { ELanguage::English, { "Battle Theme", "Play the Werehog battle theme during combat.\n\nThis option will apply the next time you're in combat." } }
+    { ELanguage::English,  { "Battle Theme", "Play the Werehog battle theme during combat.\n\nThis option will apply the next time you're in combat.\n\nExorcism missions and miniboss themes will be unaffected." } },
+    { ELanguage::Japanese, { "バトルテーマ", "バトル[中:ちゅう]に\u200Bウェアホッグの\u200Bバトルテーマを\u200B[再生:さいせい]するか\u200B[選択:せんたく]できます\n\nこのオプションは\u200B[次回:じかい]のバトルに\u200B[適用:てきよう]されます\n\n[\u2005除\u2005霊\u2005:エクソシズム]ミッションと\u200Bミニボステーマは\u200B[影響:えいきょう]されません" } },
+    { ELanguage::German,   { "Kampfmusik", "Spiele die Kampfmusik des Werehogs während dem Kämpfen ab.\n\nDiese Option tritt das nächste Mal, wenn du in einen Kampf gerätst, in Kraft.\n\nExorzismen und Mini-Bosse werden hiervon nicht beeinflusst." } },
+    { ELanguage::French,   { "Thème de combat", "Joue le thème de combat du Werehog pendant les combat.\n\nCette option s'appliquera la prochaine fois que vous serez en combat.\n\nLes missions d'exorcisme et les thèmes des miniboss ne seront pas affectés." } },
+    { ELanguage::Spanish,  { "Tema de batalla", "Reproduce el tema de batalla del Werehog durante el combate.\n\nEsta opción se aplicará la próxima vez que entres en combate.\n\nLas misiones de exorcismo y los temas de los minijefes no se verán afectados." } },
+    { ELanguage::Italian,  { "Musica di combattimento", "Riproduci la musica di combattimento del Werehog quando inizi una battaglia.\n\nQuesta opzione verrà applicata la prossima volta che sei in battaglia.\n\nLa traccia musicale verrà riprodotta ugualmente nelle missioni di Esorcismo e i miniboss." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(WindowSize)
 {
-    { ELanguage::English, { "Window Size", "Adjust the size of the game window in windowed mode." } }
+    { ELanguage::English,  { "Window Size", "Adjust the size of the game window in windowed mode." } },
+    { ELanguage::Japanese, { "ウィンドウサイズ", "ウィンドウモードで\u200Bゲームの\u200Bウィンドウサイズを\u200B[調整:ちょうせい]できます" } },
+    { ELanguage::German,   { "Fenstergröße", "Ändere die Größe des Spielfensters im Fenstermodus." } },
+    { ELanguage::French,   { "Taille de la fenêtre", "Modifie la taille de la fenêtre de jeu en mode fenêtré." } },
+    { ELanguage::Spanish,  { "Tamaño de ventana", "Ajusta el tamaño de la ventana de juego." } },
+    { ELanguage::Italian,  { "Dimensioni finestra", "Regola le dimensioni della finestra del gioco in modalità finestra." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(Monitor)
 {
-    { ELanguage::English, { "Monitor", "Change which monitor to display the game on." } }
+    { ELanguage::English,  { "Monitor", "Change which monitor to display the game on." } },
+    { ELanguage::Japanese, { "モニター[選択:せんたく]", "ゲームを[表示:ひょうじ]する\u200Bモニターを\u200B[変更:へんこう]できます" } },
+    { ELanguage::German,   { "Monitor", "Ändere auf welchem Monitor das Spiel angezeigt wird." } },
+    { ELanguage::French,   { "Moniteur", "Change le moniteur sur lequel le jeu sera affiché." } },
+    { ELanguage::Spanish,  { "Pantalla", "Cambia la pantalla en la cuál se muestra el juego." } },
+    { ELanguage::Italian,  { "Schermo", "Cambia lo schermo su cui visualizzare il gioco." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(AspectRatio)
 {
-    { ELanguage::English, { "Aspect Ratio", "Change the aspect ratio." } }
+    { ELanguage::English,  { "Aspect Ratio", "Change the aspect ratio." } },
+    { ELanguage::Japanese, { "アスペクト[比:ひ]", "アスペクト[比:ひ]を\u200B[変更:へんこう]できます" } },
+    { ELanguage::German,   { "Seitenverhältnis", "Verändere das Seitenverhältnis." } },
+    { ELanguage::French,   { "Format d'image", "Modifie le format d'image." } },
+    { ELanguage::Spanish,  { "Relación de aspecto", "Cambia la relación de aspecto." } },
+    { ELanguage::Italian,  { "Rapporto d'aspetto", "Modifica il rapporto d'aspetto." } }
 };
 
+// Japanese Notes: This localization should include furigana in its description.
 CONFIG_DEFINE_ENUM_LOCALE(EAspectRatio)
 {
     {
@@ -250,37 +548,118 @@ CONFIG_DEFINE_ENUM_LOCALE(EAspectRatio)
             { EAspectRatio::Narrow, { "4:3", "4:3: locks the game to a narrow aspect ratio." } },
             { EAspectRatio::OriginalNarrow, { "ORIGINAL 4:3", "Original 4:3: locks the game to a narrow aspect ratio and retains parity with the game's original implementation." } }
         }
+    },
+    {
+        ELanguage::Japanese,
+        {
+            { EAspectRatio::Auto, { "自動検出", "[自動検出:じどうけんしゅつ]: ゲーム[内:ない]の\u200Bコントローライコンを\u200B[自動検出:じどうけんしゅつ]されます" } },
+            { EAspectRatio::Wide, { "16:9", "16:9: ワイドスクリーンの\u200Bアスペクト[比:ひ]に\u200B[固定:こてい]されます" } },
+            { EAspectRatio::Narrow, { "4:3", "4:3: ナローの\u200Bアスペクト[比:ひ]に\u200B[固定:こてい]されます" } },
+            { EAspectRatio::OriginalNarrow, { "オリジナル 4:3", "オリジナル 4:3: オリジナルの\u200Bアスペクト[比:ひ]に\u200B[固定:こてい]されます" } }
+        }
+    },
+    {
+        ELanguage::German,
+        {
+            { EAspectRatio::Auto, { "AUTO", "Auto: Das Seitenverhältnis passt sich automatisch der Fenstergröße an." } },
+            { EAspectRatio::Wide, { "16:9", "16:9: Stellt das Spiel in einem Breitbildschirm-Vormat dar." } },
+            { EAspectRatio::Narrow, { "4:3", "4:3: Stellt das Spiel in einem Mittel-Vormat dar." } },
+            { EAspectRatio::OriginalNarrow, { "ORIGINAL 4:3", "Original 4:3: Stellt das Spiel in einem Mittel-Vormat dar, was der ursprünglichen Implementation originalgetreut bleibt." } }
+        }
+    },
+    {
+        ELanguage::French,
+        {
+            { EAspectRatio::Auto, { "AUTO", "Auto: le format d'image s'adapte automatiquement à la taille de la fenêtre." } },
+            { EAspectRatio::Wide, { "16:9", "16:9: force le jeu sur un format d'image large." } },
+            { EAspectRatio::Narrow, { "4:3", "4:3: force le jeu sur un format d'image carré." } },
+            { EAspectRatio::OriginalNarrow, { "4:3 ORIGINAL", "4:3 Original: force le jeu à un format d'image carré et conserve la parité avec l'implémentation d'origine du jeu." } }
+        }
+    },
+    {
+        ELanguage::Spanish,
+        {
+            { EAspectRatio::Auto, { "AUTO", "Auto: la relación de aspecto se ajusta de forma dinámica al tamaño de la ventana." } },
+            { EAspectRatio::Wide, { "16:9", "16:9: muestra el juego en relación de aspecto de pantalla ancha." } },
+            { EAspectRatio::Narrow, { "4:3", "4:3: muestra el juego en relación de aspecto de pantalla estrecha." } },
+            { EAspectRatio::OriginalNarrow, { "ORIGINAL 4:3", "Original 4:3: muestra el juego en relación de aspecto de pantalla estrecha y mantiene paridad con la implementación original del juego." } }
+        }
+    },
+    {
+        ELanguage::Italian,
+        {
+            { EAspectRatio::Auto, { "AUTO", "Auto: il rapporto d'aspetto verra cambiato automaticamente in base alle dimensioni della finestra." } },
+            { EAspectRatio::Wide, { "16:9", "16:9: blocca il gioco a un rapporto d'aspetto widescreen." } },
+            { EAspectRatio::Narrow, { "4:3", "4:3: blocca il gioco a un rapporto d'aspetto stretto." } },
+            { EAspectRatio::OriginalNarrow, { "4:3 ORIGINALE", "4:3 Originale: blocca il gioco a un rapporto d'aspetto stretto e mantiene la parità con l'implementazione originale del gioco." } }
+        }
     }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(ResolutionScale)
 {
-    { ELanguage::English, { "Resolution Scale", "Adjust the internal resolution of the game.\n\n%dx%d" } }
+    { ELanguage::English,  { "Resolution Scale", "Adjust the internal resolution of the game.\n\n%dx%d" } },
+    { ELanguage::Japanese, { "[解像度:かいぞうど]スケール", "ゲームの\u200B[内部解像度:ないぶかいぞうど]を\u200B[調整:ちょうせい]できます\n\n%dx%d" } },
+    { ELanguage::German,   { "Rendering-Auflösung", "Passe die Auflösung der internen Darstellung an.\n\n%dx%d" } },
+    { ELanguage::French,   { "Échelle de rendu", "Modifie la résolution interne du jeu.\n\n%dx%d" } },
+    { ELanguage::Spanish,  { "Escala de resolución", "Ajusta la resolución interna del juego.\n\n%dx%d" } },
+    { ELanguage::Italian, { "Scala risoluzione", "Regola la risoluzione interna del gioco.\n\n%dx%d" } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(Fullscreen)
 {
-    { ELanguage::English, { "Fullscreen", "Toggle between borderless fullscreen or windowed mode." } }
+    { ELanguage::English,  { "Fullscreen", "Toggle between borderless fullscreen or windowed mode." } },
+    { ELanguage::Japanese, { "フルスクリーン", "ボーダーレス\u200Bフルスクリーンか\u200Bウィンドウモードを\u200B[選択:せんたく]できます" } },
+    { ELanguage::German,   { "Vollbild", "Wechsle zwischen dem randlosen Vollbildmodus und dem Fenstermodus." } },
+    { ELanguage::French,   { "Plein écran", "Alterne entre le mode plein écran sans bordure et le mode fenêtré." } },
+    { ELanguage::Spanish,  { "Pantalla completa", "Cambia entre modo de pantalla completa o ventana." } },
+    { ELanguage::Italian,  { "Schermo pieno", "Attiva/disattiva tra modalità finestra senza cornice e modalità finestra." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(VSync)
 {
-    { ELanguage::English, { "V-Sync", "Synchronize the game to the refresh rate of the display to prevent screen tearing." } }
+    { ELanguage::English,  { "V-Sync", "Synchronize the game to the refresh rate of the display to prevent screen tearing." } },
+    { ELanguage::Japanese, { "[垂直同期:すいちょくどうき]", "[垂直同期:すいちょくどうき]の\u200B[設定:せってい]を\u200B[変更:へんこう]できます" } },
+    { ELanguage::German,   { "V-Sync", "Synchronisiere das Spiel mit der Bildwiederholrate deines Bildschirms um Bildverzerrungen zu vermeiden." } },
+    { ELanguage::French,   { "V-Sync", "Synchronise le jeu avec la fréquence de rafraîchissement de l'écran pour éviter le screen tearing." } },
+    { ELanguage::Spanish,  { "V-Sync", "Sincroniza el juego a la tasa de refresco de la pantalla para prevenir el rasgado de la imagen." } },
+    { ELanguage::Italian,  { "V-Sync", "Sincronizza il gioco con la frequenza d'aggiornamento del display per evitare lo screen tearing." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(FPS)
 {
-    { ELanguage::English, { "FPS", "Set the max frame rate the game can run at.\n\nWARNING: this may introduce glitches at frame rates higher than 60 FPS." } }
+    { ELanguage::English,  { "FPS", "Set the max frame rate the game can run at.\n\nWARNING: this may introduce glitches at frame rates higher than 60 FPS." } },
+    { ELanguage::Japanese, { "フレームレート[上限:じょうげん]", "ゲームの\u200B[最大:さいだい]フレームレートを\u200B[設定:せってい]できます\n\n[警告:けいこく]: 60 FPSを\u200B[超:こ]えるフレームレートで\u200B[不具合:ふぐあい]が\u200B[発生:はっせい]する\u200B[可能性:かのうせい]が\u200Bあります" } },
+    { ELanguage::German,   { "FPS", "Setze die maximale Anzahl der Bilder pro Sekunde, die das Spiel darstellen kann.\n\nWARNUNG: Das Spiel kann bei höheren FPS als 60 ungewolltes Verhalten aufweisen." } },
+    { ELanguage::French,   { "FPS", "Détermine la fréquence d'images maximale du jeu.\n\nATTENTION: cela peut entraîner des problèmes à des taux de rafraîchissement supérieurs à 60 FPS." } },
+    { ELanguage::Spanish,  { "FPS", "Establece la tasa de fotogramas máxima a la que puede correr el juego.\n\nADVERTENCIA: esto puede introducir fallos en tasas mayores a 60 FPS." } },
+    { ELanguage::Italian,  { "FPS", "Imposta il frame rate massimo del gioco.\n\nATTENZIONE: questa opzione può causare dei glitch a frame rate più alti di 60 FPS." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(Brightness)
 {
-    { ELanguage::English, { "Brightness", "Adjust the brightness level until the symbol on the left is barely visible." } }
+    { ELanguage::English,  { "Brightness", "Adjust the brightness level until the symbol on the left is barely visible." } },
+    { ELanguage::Japanese, { "[明:おか]るさの[設定:せってい]", "[画面:がめん]の\u200B[明:おか]るさを\u200B[調整:ちょうせい]できます" } },
+    { ELanguage::German,   { "Helligkeit", "Passe die Helligkeit des Spiels an bis das linke Symbol noch gerade so sichtbar ist." } },
+    { ELanguage::French,   { "Luminosité", "Règle le niveau de luminosité jusqu'à ce que le symbole à gauche soit à peine visible." } },
+    { ELanguage::Spanish,  { "Brillo", "Ajusta el nivel de brillo hasta que el símbolo a la izquierda sea apenas visible." } },
+    { ELanguage::Italian,  { "Luminosità", "Regola la luminosità dello schermo fino a quando il simbolo a sinistra diventa leggermente visibile." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(AntiAliasing)
 {
-    { ELanguage::English, { "Anti-Aliasing", "Adjust the amount of smoothing applied to jagged edges." } }
+    { ELanguage::English,  { "Anti-Aliasing", "Adjust the amount of smoothing applied to jagged edges." } },
+    { ELanguage::Japanese, { "アンチエイリアス", "アンチエイリアスの\u200B[種類:しゅるい]を\u200B[選択:せんたく]できます" } },
+    { ELanguage::German,   { "Kantenglättung", "Passe die Menge an Kantenglättung an." } },
+    { ELanguage::French,   { "Anticrénelage", "Ajuste le niveau d'anticrénelage appliqué aux bords des objets." } },
+    { ELanguage::Spanish,  { "Anti-Aliasing", "Ajusta el nivel de suavizado aplicado a los dientes de sierra." } },
+    { ELanguage::Italian,  { "Anti-Aliasing", "Regola la quantità di smussamento applicata ai bordi." } }
 };
 
 CONFIG_DEFINE_ENUM_LOCALE(EAntiAliasing)
@@ -288,21 +667,64 @@ CONFIG_DEFINE_ENUM_LOCALE(EAntiAliasing)
     {
         ELanguage::English,
         {
-            { EAntiAliasing::None, { "NONE", "" } },
+            { EAntiAliasing::None, { "NONE", "" } }
         }
-    }
+    },
+    {
+        ELanguage::Japanese,
+        {
+            { EAntiAliasing::None, { "オフ", "" } },
+        }
+    },
+    {
+        ELanguage::German,
+        {
+            { EAntiAliasing::None, { "KEINE", "" } }
+        }
+    },
+    {
+        ELanguage::French,
+        {
+            { EAntiAliasing::None, { "SANS", "" } }
+        }
+    },
+    {
+        ELanguage::Spanish,
+        {
+            { EAntiAliasing::None, { "NO", "" } },
+        }
+    },
+    {
+        ELanguage::Italian,
+        {
+            { EAntiAliasing::None, { "NULLO", "" } }
+        }
+    },
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(TransparencyAntiAliasing)
 {
-    { ELanguage::English, { "Transparency Anti-Aliasing", "Apply anti-aliasing to alpha transparent textures." } }
+    { ELanguage::English,  { "Transparency Anti-Aliasing", "Apply anti-aliasing to alpha transparent textures." } },
+    { ELanguage::Japanese, { "アンチエイリアスのトランスペアレンシー", "アルファ[透明:とうめい]\u200Bテクスチャに\u200Bアンチエイリアシングを\u200B[適用:てきよう]されます" } },
+    { ELanguage::German,   { "Transparenz-Kantenglättung", "Wende Kantenglättung auf Alpha-Transparenz-Texturen an." } },
+    { ELanguage::French,   { "Anticrénelage de transparence", "Applique l'anticrénelage sur les textures transparentes." } },
+    { ELanguage::Spanish,  { "Anti-Aliasing de transparencias", "Aplica antialiasing a las texturas transparentes." } },
+    { ELanguage::Italian,  { "Anti-Aliasing su texture trasparenti", "Applica l'anti-aliasing alle texture trasparenti." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(ShadowResolution)
 {
-    { ELanguage::English, { "Shadow Resolution", "Set the resolution of real-time shadows." } }
+    { ELanguage::English,  { "Shadow Resolution", "Set the resolution of real-time shadows." } },
+    { ELanguage::Japanese, { "[影:かげ]の[解像度:かいぞうど]", "[影:かげ]の[解像度:かいぞうど]を\u200B[設定:せってい]できます" } },
+    { ELanguage::German,   { "Schattenauflösung", "Stelle die Auflösung der Echtzeit-Schatten ein." } },
+    { ELanguage::French,   { "Résolution des ombres", "Défini la résolution des ombres en temps réel." } },
+    { ELanguage::Spanish,  { "Resolución de sombras", "Establece la resolución de las sombras de tiempo real." } },
+    { ELanguage::Italian,  { "Risoluzione ombre", "Imposta la risoluzioni delle ombre in tempo reale." } }
 };
 
+// Japanese Notes: This localization should include furigana in its description.
 CONFIG_DEFINE_ENUM_LOCALE(EShadowResolution)
 {
     {
@@ -310,12 +732,48 @@ CONFIG_DEFINE_ENUM_LOCALE(EShadowResolution)
         {
             { EShadowResolution::Original, { "ORIGINAL", "Original: the game will automatically determine the resolution of the shadows." } }
         }
+    },
+    {
+        ELanguage::Japanese,
+        {
+            { EShadowResolution::Original, { "オリジナル", "オリジナル: [影:かげ]の[解像度:かいぞうど]を\u200B[自動検出:じどうけんしゅつ]されます" } }
+        }
+    },
+    {
+        ELanguage::German,
+        {
+            { EShadowResolution::Original, { "ORIGINAL", "Original: Das Spiel bestimmt die Auflösung der Schatten automatisch." } }
+        }
+    },
+    {
+        ELanguage::French,
+        {
+            { EShadowResolution::Original, { "ORIGINALE", "Originale: le jeu déterminera automatiquement la résolution des ombres." } }
+        }
+    },
+    {
+        ELanguage::Spanish,
+        {
+            { EShadowResolution::Original, { "ORIGINAL", "Original: el juego determinará de forma automática la resolución de las sombras." } }
+        }
+    },
+    {
+        ELanguage::Italian,
+        {
+            { EShadowResolution::Original, { "ORIGINALE", "Originale: il gioco determinerà automaticamente la risoluzione delle ombre." } }
+        }
     }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(GITextureFiltering)
 {
-    { ELanguage::English, { "GI Texture Filtering", "Change the quality of the filtering used for global illumination textures." } }
+    { ELanguage::English,  { "GI Texture Filtering", "Change the quality of the filtering used for global illumination textures." } },
+    { ELanguage::Japanese, { "GIテクスチャフィルタリング", "GIテクスチャに\u200B[使用:しよう]する\u200Bフィルタリングの\u200B[品質:ひんしつ]を\u200B[変更:へんこう]できます" } },
+    { ELanguage::German,   { "GI Texturfilterung", "Ändere die Qualität der Filterung für Global-Illumination-Texturen." } },
+    { ELanguage::French,   { "Filtre des textures IG", "Modifie la qualité du filtre utilisé pour les textures d'illumination globale." } },
+    { ELanguage::Spanish,  { "Filtrado de texturas de GI", "Cambia la calidad del filtrado utilizado en las texturas de iluminación global." } },
+    { ELanguage::Italian,  { "Filtraggio delle texture GI", "Regola la qualità del sistema di filtraggio utilizzato per le texture dell'illuminazione." } }
 };
 
 CONFIG_DEFINE_ENUM_LOCALE(EGITextureFiltering)
@@ -324,16 +782,58 @@ CONFIG_DEFINE_ENUM_LOCALE(EGITextureFiltering)
         ELanguage::English,
         {
             { EGITextureFiltering::Bilinear, { "BILINEAR", "" } },
-            { EGITextureFiltering::Bicubic,  { "BICUBIC", "" } },
+            { EGITextureFiltering::Bicubic,  { "BICUBIC", "" } }
+        }
+    },
+    {
+        ELanguage::Japanese,
+        {
+            { EGITextureFiltering::Bilinear, { "バイリニア", "" } },
+            { EGITextureFiltering::Bicubic,  { "バイキュービック", "" } },
+        }
+    },
+    {
+        ELanguage::German,
+        {
+            { EGITextureFiltering::Bilinear, { "BILINEAR", "" } },
+            { EGITextureFiltering::Bicubic,  { "BICUBIC", "" } }
+        }
+    },
+    {
+        ELanguage::French,
+        {
+            { EGITextureFiltering::Bilinear, { "BILINÉAIRE", "" } },
+            { EGITextureFiltering::Bicubic,  { "BICUBIQUE", "" } },
+        }
+    },
+    {
+        ELanguage::Spanish,
+        {
+            { EGITextureFiltering::Bilinear, { "BILINEAR", "" } },
+            { EGITextureFiltering::Bicubic,  { "BICÚBICO", "" } },
+        }
+    },
+    {
+        ELanguage::Italian,
+        {
+            { EGITextureFiltering::Bilinear, { "BILINEARE", "" } },
+            { EGITextureFiltering::Bicubic,  { "BICUBICO", "" } }
         }
     }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(MotionBlur)
 {
-    { ELanguage::English, { "Motion Blur", "Change the quality of the motion blur." } }
+    { ELanguage::English,  { "Motion Blur", "Change the quality of the motion blur." } },
+    { ELanguage::Japanese, { "モーションブラー", "モーションブラーの\u200B[品質:ひんしつ]を\u200B[変更:へんこう]できます" } },
+    { ELanguage::German,   { "Bewegungsunschärfe", "Verändere die Qualität der Bewegungsunschärfe." } },
+    { ELanguage::French,   { "Flou de mouvement", "Modifie la qualité du flou de mouvement." } },
+    { ELanguage::Spanish,  { "Desenfoque de movimiento", "Cambia la calidad del desenfoque de movimiento." } },
+    { ELanguage::Italian,  { "Sfocatura di movimento", "Regola la qualità della sfocatura di movimento." } }
 };
 
+// Japanese Notes: This localization should include furigana in its description.
 CONFIG_DEFINE_ENUM_LOCALE(EMotionBlur)
 {
     {
@@ -343,42 +843,172 @@ CONFIG_DEFINE_ENUM_LOCALE(EMotionBlur)
             { EMotionBlur::Original, { "ORIGINAL", "" } },
             { EMotionBlur::Enhanced, { "ENHANCED", "Enhanced: uses more samples for smoother motion blur at the cost of performance." } }
         }
+    },
+    {
+        ELanguage::Japanese,
+        {
+            { EMotionBlur::Off,      { "オフ", "" } },
+            { EMotionBlur::Original, { "オリジナル", "" } },
+            { EMotionBlur::Enhanced, { "エンハンスド", "エンハンスド: パフォーマンスを\u200B[犠牲:ぎせい]にして\u200Bより[多:おお]くの\u200Bサンプルを\u200B[使用:しよう]してより\u200B[滑:なめ]らかな\u200Bモーションブラーを\u200B[実現:じつげん]されます" } }
+        }
+    },
+    {
+        ELanguage::German,
+        {
+            { EMotionBlur::Off,      { "AUS", "" } },
+            { EMotionBlur::Original, { "ORIGINAL", "" } },
+            { EMotionBlur::Enhanced, { "VERBESSERT", "Verbessert: Benutzt mehr Samples um eine weichere Bewegungsunschärfe auf Kosten von Performanz zu erzeugen." } }
+        }
+    },
+    {
+        ELanguage::French,
+        {
+            { EMotionBlur::Off,      { "AUCUN", "" } },
+            { EMotionBlur::Original, { "ORIGINAL", "" } },
+            { EMotionBlur::Enhanced, { "AMÉLIORÉ", "Amélioré: utilise plus d'échantillons pour un flou de mouvement plus lisse au détriment des performances." } }
+        }
+    },
+    {
+        ELanguage::Spanish,
+        {
+            { EMotionBlur::Off,      { "APAGADO", "" } },
+            { EMotionBlur::Original, { "ORIGINAL", "" } },
+            { EMotionBlur::Enhanced, { "MEJORADO", "Mejorado: utiliza más muestras para suavizar el desenfoque de movimiento a costa del rendimiento." } }
+        }
+    },
+    {
+        ELanguage::Italian,
+        {
+            { EMotionBlur::Off,      { "DISATTIVATO", "" } },
+            { EMotionBlur::Original, { "ORIGINALE", "" } },
+            { EMotionBlur::Enhanced, { "AUMENTATO", "Aumentato: usa più passaggi per una sfocatura più fluida, con un impatto sulle prestazioni." } }
+        }
     }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(XboxColorCorrection)
 {
-    { ELanguage::English, { "Xbox Color Correction", "Use the warm tint from the Xbox version of the game." } }
+    { ELanguage::English,  { "Xbox Color Correction", "Use the warm tint from the Xbox version of the game." } },
+    { ELanguage::Japanese, { "Xboxの[色補正:いろほせい]", "Xbox[版:ばん]のゲームの\u200B[暖色系:だんしょくけい]の[色合:いろあ]いを\u200B[使用:しよう]されます" } },
+    { ELanguage::German,   { "Xbox Farbkorrektur", "Benutzt den warmen Farbstich aus der Xbox-Version des Spiels." } },
+    { ELanguage::French,   { "Correction couleurs Xbox", "Utilise le filtre de couleur provenant de la version Xbox du jeu." } },
+    { ELanguage::Spanish,  { "Corrección de color de Xbox", "Utiliza el tono cálido de la versión Xbox del juego." } },
+    { ELanguage::Italian,  { "Correzione dei colori Xbox", "Applica il filtro di colori più caldi utilizzato dalla versione Xbox del gioco." } }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(CutsceneAspectRatio)
 {
-    { ELanguage::English, { "Cutscene Aspect Ratio", "Change the aspect ratio of the real-time cutscenes." } }
+    { ELanguage::English,  { "Cutscene Aspect Ratio", "Change the aspect ratio of the real-time cutscenes." } },
+    { ELanguage::Japanese, { "アスペクト[比:ひ]のカットシーン", "リアルタイム\u200Bカットシーンの\u200Bアスペクト[比:ひ]を\u200B[変更:へんこう]できます" } },
+    { ELanguage::German,   { "Zwischensequenz-Seitenverhältnis", "Verändere das Seitenverhältnis der Echtzeit-Zwischensequenzen." } },
+    { ELanguage::French,   { "Format des cinématiques", "Modifie le format d'image des cinématiques en temps réel." } },
+    { ELanguage::Spanish,  { "Relación de aspecto de cinemáticas", "Cambia la relación de aspecto de las cinemáticas de tiempo real." } },
+    { ELanguage::Italian,  { "Rapporto d'aspetto dei filmati", "Cambia il rapporto d'aspetto dei filmati in tempo reale." } }
 };
 
+// Japanese Notes: This localization should include furigana in its description.
 CONFIG_DEFINE_ENUM_LOCALE(ECutsceneAspectRatio)
 {
     {
         ELanguage::English,
         {
             { ECutsceneAspectRatio::Original, { "ORIGINAL", "Original: locks cutscenes to their original 16:9 aspect ratio." } },
-            { ECutsceneAspectRatio::Unlocked, { "UNLOCKED", "Unlocked: allows cutscenes to adjust their aspect ratio to the window size.\n\nWARNING: this will introduce visual oddities past the original 16:9 aspect ratio." } },
+            { ECutsceneAspectRatio::Unlocked, { "UNLOCKED", "Unlocked: allows cutscenes to adjust their aspect ratio to the window size.\n\nWARNING: this will introduce visual oddities past the original 16:9 aspect ratio." } }
+        }
+    },
+    {
+        ELanguage::Japanese,
+        {
+            { ECutsceneAspectRatio::Original, { "オリジナル", "オリジナル: カットシーンを\u200B[元:もと]の\u200B16:9の\u200Bアスペクト[比:ひ]に\u200B[固定:こてい]されます" } },
+            { ECutsceneAspectRatio::Unlocked, { "解除", "[解除:かいじょ]: カットシーンの\u200Bアスペクト[比:ひ]を\u200Bウィンドウサイズに\u200B[合:あ]わせて\u200B[調整:ちょうせい]されます\n\n[警告:けいこく]: [元:もと]の\u200B16:9の\u200Bアスペクト[比:ひ]を\u200B[超:こ]えると\u200B[視覚的:しかくてき]な\u200B[異常:いじょう]が\u200B[発生:はっせい]します" } },
+        }
+    },
+    {
+        ELanguage::German,
+        {
+            { ECutsceneAspectRatio::Original, { "ORIGINAL", "Original: Behält die Zwischensequenzen in ihrem originalen 16:9 Seitenverhältnis." } },
+            { ECutsceneAspectRatio::Unlocked, { "ENTSPERRT", "Entsperrt: Erlaubt Zwischensequenzen ihr Seitenverhältnis der Fenstergröße anzupassen.\n\nWARNUNG: Diese Option kann zu visuellen Fehlern außerhalb der Grenzen des ursprünglichen Seitenverhältnisses führen." } }
+        }
+    },
+    {
+        ELanguage::French,
+        {
+            { ECutsceneAspectRatio::Original, { "ORIGINAL", "Original: force les cinématiques dans leur format 16:9 d'origine." } },
+            { ECutsceneAspectRatio::Unlocked, { "LIBRE", "Libre: permet aux cinématiques d'adapter leur format d'image à la taille de la fenêtre.\n\nAttention: au dela du format 16:9 d'origine, des bugs visuels apparaitront." } },
+        }
+    },
+    {
+        ELanguage::Spanish,
+        {
+            { ECutsceneAspectRatio::Original, { "ORIGINAL", "Original: muestra las cinemáticas en su relación de aspecto original de 16:9." } },
+            { ECutsceneAspectRatio::Unlocked, { "DESBLOQUEADO", "Desbloqueado: permite que las cinemáticas ajusten su relación de aspecto al tamaño de la ventana.\n\nADVERTENCIA: esto introducirá rarezas visuales más allá de la relación de aspecto original de 16:9." } },
+        }
+    },
+    {
+        ELanguage::Italian,
+        {
+            { ECutsceneAspectRatio::Original, { "ORIGINALE", "Originale: blocca il rapporto d'aspetto dei filmati a 16:9." } },
+            { ECutsceneAspectRatio::Unlocked, { "SBLOCCATO", "Sbloccato: il rapporto d'aspetto verrà regolato in base alle dimensioni della finestra.\n\nATTENZIONE: questa opzione potrebbe causare dei problemi visivi se il rapporto d'aspetto è oltre 16:9." } }
         }
     }
 };
 
+// Japanese Notes: This localization should include furigana.
 CONFIG_DEFINE_LOCALE(UIAlignmentMode)
 {
-    { ELanguage::English, { "UI Alignment Mode", "Change how the UI aligns with the display." } }
+    { ELanguage::English,  { "UI Alignment Mode", "Change how the UI aligns with the display." } },
+    { ELanguage::Japanese, { "UIアライメントモード", "UIとディスプレイの\u200B[配置:はいち]を\u200B[変更:へんこう]できます" } },
+    { ELanguage::German,   { "Benutzeroberflächenausrichtung", "Verändere wie die Benutzeroberfläche sich mit dem Bildschirm ausrichtet." } },
+    { ELanguage::French,   { "Alignement de l'IU", "Modifie l'alignement de l'interface utilisateur sur l'écran." } },
+    { ELanguage::Spanish,  { "Modo de alineamiento de UI", "Cambia la alineación de la interfaz de usuario con la pantalla." } },
+    { ELanguage::Italian,  { "Modalità allineamento interfaccia", "Modifica come l'interfaccia si allinea con lo schermo." } }
 };
 
+// Japanese Notes: This localization should include furigana in its description.
 CONFIG_DEFINE_ENUM_LOCALE(EUIAlignmentMode)
 {
     {
         ELanguage::English,
         {
             { EUIAlignmentMode::Edge,    { "EDGE", "Edge: the UI will align with the edges of the display." } },
-            { EUIAlignmentMode::Centre,  { "CENTER", "Center: the UI will align with the center of the display." } },
+            { EUIAlignmentMode::Centre,  { "CENTER", "Center: the UI will align with the center of the display." } }
+        }
+    },
+    {
+        ELanguage::Japanese,
+        {
+            { EUIAlignmentMode::Edge,    { "エッジ", "エッジ: UIはディスプレイの\u200B[端:はし]に\u200B[揃:そろ]います" } },
+            { EUIAlignmentMode::Centre,  { "センター", "センター: UIはディスプレイの\u200B[中央:ちゅうおう]に\u200B[揃:そろ]います" } },
+        }
+    },
+    {
+        ELanguage::German,
+        {
+            { EUIAlignmentMode::Edge,    { "RAND", "Rand: Die Benutzeroberfläche richtet sich zum Rand des Bildschirms aus." } },
+            { EUIAlignmentMode::Centre,  { "MITTE", "Mitte: Die Benutzeroberfläche richtet sich zur Mitte des Bildschirms aus." } }
+        }
+    },
+    {
+        ELanguage::French,
+        {
+            { EUIAlignmentMode::Edge,    { "BORD", "Bord: l'interface utilisateur sera alignée sur les bords de l'écran." } },
+            { EUIAlignmentMode::Centre,  { "CENTRÉE", "Centrée: l'interface utilisateur sera alignée sur le centre de l'écran." } },
+        }
+    },
+    {
+        ELanguage::Spanish,
+        {
+            { EUIAlignmentMode::Edge,    { "BORDE", "Borde: la interfaz de usuario se alineará con los bordes de la pantalla." } },
+            { EUIAlignmentMode::Centre,  { "CENTRO", "Centro: la interfaz de usuario se alineará con el centro de la pantalla." } },
+        }
+    },
+    {
+        ELanguage::Italian,
+        {
+            { EUIAlignmentMode::Edge,    { "BORDI", "Bordi: l'interfaccia si allineerà con i bordi dello schermo." } },
+            { EUIAlignmentMode::Centre,  { "CENTRO", "Centro: l'interfaccia si allineerà con il centro dello schermo." } }
         }
     }
 };

UnleashedRecomp/locale/locale.cpp

@@ -16,355 +16,615 @@
       360, which is one of the few consoles to have a port of Sonic
       Unleashed.
 
+    - Ensure your locale is added in the correct order following the language enum.
+
+      Correct:
+      {
+          { ELanguage::English,  "Example" },
+          { ELanguage::Japanese, "Example" },
+          { ELanguage::German,   "Example" },
+          { ELanguage::French,   "Example" },
+          { ELanguage::Spanish,  "Example" },
+          { ELanguage::Italian,  "Example" }
+      }
+
+      Incorrect:
+      {
+          { ELanguage::English,  "Example" },
+          { ELanguage::French,   "Example" },
+          { ELanguage::Spanish,  "Example" },
+          { ELanguage::German,   "Example" },
+          { ELanguage::Italian,  "Example" },
+          { ELanguage::Japanese, "Example" }
+      }
+
+    - Japanese localization should use furigana for message windows, options items,
+    options descriptions and installer text.
+
+      Furigana should be included in the text as such:
+      "[私:わたし]はジョージです。"
+
     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 */
 
-std::unordered_map<std::string, std::unordered_map<ELanguage, std::string>> g_locale =
+std::unordered_map<std::string_view, std::unordered_map<ELanguage, std::string>> g_locale =
 {
     {
         "Options_Header_Name",
         {
-            { ELanguage::English, "OPTIONS" },
+            { ELanguage::English,  "OPTIONS" },
             { ELanguage::Japanese, "OPTION" },
-            { ELanguage::German, "OPTIONEN" },
-            { ELanguage::French, "OPTIONS" },
-            { ELanguage::Spanish, "OPCIONES" },
-            { ELanguage::Italian, "OPZIONI" }
+            { ELanguage::German,   "OPTIONEN" },
+            { ELanguage::French,   "OPTIONS" },
+            { ELanguage::Spanish,  "OPCIONES" },
+            { ELanguage::Italian,  "OPZIONI" }
         }
     },
     {
         "Options_Category_System",
         {
-            { ELanguage::English, "SYSTEM" }
+            { ELanguage::English,  "SYSTEM" },
+            { ELanguage::Japanese, "SYSTEM" },
+            { ELanguage::German,   "SYSTEM" },
+            { ELanguage::French,   "SYSTÈME" },
+            { ELanguage::Spanish,  "SISTEMA" },
+            { ELanguage::Italian,  "SISTEMA" }
         }
     },
     {
         "Options_Category_Input",
         {
-            { ELanguage::English, "INPUT" }
+            { ELanguage::English,  "INPUT" },
+            { ELanguage::Japanese, "INPUT" },
+            { ELanguage::German,   "EINGABE" },
+            { ELanguage::French,   "COMMANDES" },
+            { ELanguage::Spanish,  "CONTROLES" },
+            { ELanguage::Italian,  "COMANDI" }
         }
     },
     {
         "Options_Category_Audio",
         {
-            { ELanguage::English, "AUDIO" }
+            { ELanguage::English,  "AUDIO" },
+            { ELanguage::Japanese, "AUDIO" },
+            { ELanguage::German,   "AUDIO" },
+            { ELanguage::French,   "SON" },
+            { ELanguage::Spanish,  "AUDIO" },
+            { ELanguage::Italian,  "AUDIO" }
         }
     },
     {
         "Options_Category_Video",
         {
-            { ELanguage::English, "VIDEO" }
+            { ELanguage::English,  "VIDEO" },
+            { ELanguage::Japanese, "VIDEO" },
+            { ELanguage::German,   "VIDEO" },
+            { ELanguage::French,   "AFFICHAGE" },
+            { ELanguage::Spanish,  "VÍDEO" },
+            { ELanguage::Italian,  "VIDEO" }
         }
     },
     {
         // Notes: integer values in the options menu (e.g. FPS) when at their maximum value.
         "Options_Value_Max",
         {
-            { ELanguage::English, "MAX" }
+            { ELanguage::English,  "MAX" },
+            { ELanguage::Japanese, "MAX" },
+            { ELanguage::German,   "MAX" },
+            { ELanguage::French,   "MAX" },
+            { ELanguage::Spanish,  "MÁX" },
+            { ELanguage::Italian,  "MAX" }
         }
     },
     {
         "Options_Name_WindowSize",
         {
-            { ELanguage::English, "Window Size" }
+            { ELanguage::English,  "Window Size" },
+            { ELanguage::Japanese, "ウィンドウサイズ" },
+            { ELanguage::German,   "Fenstergröße" },
+            { ELanguage::French,   "Taille de la fenêtre" },
+            { ELanguage::Spanish,  "Tamaño de ventana" },
+            { ELanguage::Italian,  "Dimensioni della finestra" }
         }
     },
     {
+        // Japanese Notes: This localization should include furigana.
         "Options_Desc_WindowSize",
         {
-            { ELanguage::English, "Adjust the size of the game window in windowed mode." }
+            { ELanguage::English,  "Adjust the size of the game window in windowed mode." },
+            { ELanguage::Japanese, "ゲームの\u200Bウィンドウサイズを\u200B[設定:せってい]できます" },
+            { ELanguage::German,   "Passe die Fenstergröße des Spiels im Fenstermodus an." },
+            { ELanguage::French,   "Définir la résolution de jeu en mode fenêtré." },
+            { ELanguage::Spanish,  "Ajusta el tamaño de la ventana de juego en modo ventana." },
+            { ELanguage::Italian,  "Regola la dimensione della finestra del gioco in modalità finestra." }
         }
     },
     {
         // Notes: description for options that cannot be accessed anywhere but the title screen or world map (e.g. Language).
+        // Japanese Notes: This localization should include furigana.
         "Options_Desc_NotAvailable",
         {
-            { ELanguage::English, "This option is not available at this location." }
+            { ELanguage::English,  "This option is not available at this location." },
+            { ELanguage::Japanese, "この\u200Bオプションは\u200B[現在:げんざい]の\u200B[画面:がめん]で\u200B[変更:へんこう]\u200Bできません" },
+            { ELanguage::German,   "Diese Option ist an dieser Stelle nicht verfügbar." },
+            { ELanguage::French,   "Cette option n'est pas disponible pour l'instant." },
+            { ELanguage::Spanish,  "Esta opción no está disponible en este momento." },
+            { ELanguage::Italian,  "Questa opzione non può essere modificata in questo momento." }
         }
     },
     {
         // Notes: currently the description for Window Size when in fullscreen.
+        // Japanese Notes: This localization should include furigana.
         "Options_Desc_NotAvailableFullscreen",
         {
-            { ELanguage::English, "This option is not available in fullscreen mode." }
+            { ELanguage::English,  "This option is not available in fullscreen mode." },
+            { ELanguage::Japanese, "この\u200Bオプションは\u200Bフルスクリーンモードで\u200B[変更:へんこう]\u200Bできません" },
+            { ELanguage::German,   "Diese Option ist im Vollbildmodus nicht verfügbar." },
+            { ELanguage::French,   "Cette option n'est pas disponible en mode plein écran." },
+            { ELanguage::Spanish,  "Esta opción no está disponible en modo pantalla completa." },
+            { ELanguage::Italian,  "Questa opzione non è disponibile in modalità schermo pieno." }
         }
     },
     {
         // Notes: currently the description for Monitor when in fullscreen.
+        // Japanese Notes: This localization should include furigana.
         "Options_Desc_NotAvailableWindowed",
         {
-            { ELanguage::English, "This option is not available in windowed mode." }
+            { ELanguage::English,  "This option is not available in windowed mode." },
+            { ELanguage::Japanese, "この\u200Bオプションは\u200Bウィンドウモードで\u200B[変更:へんこう]\u200Bできません" },
+            { ELanguage::German,   "Diese Option ist im Fenstermodus nicht verfügbar." },
+            { ELanguage::French,   "Cette option n'est pas disponible en mode fenêtré." },
+            { ELanguage::Spanish,  "Esta opción no está disponible en modo ventana." },
+            { ELanguage::Italian,  "Questa opzione non è disponibile in modalità finestra." }
         }
     },
     {
         // Notes: currently the description for Monitor when the user only has one display connected.
+        // Japanese Notes: This localization should include furigana.
         "Options_Desc_NotAvailableHardware",
         {
-            { ELanguage::English, "This option is not available with your current hardware configuration." }
+            { ELanguage::English,  "This option is not available with your current hardware configuration." },
+            { ELanguage::Japanese, "この\u200Bオプションは\u200B[現在:げんざい]の\u200Bハードウェア[構成:こうせい]で\u200B[変更:へんこう]\u200Bできません" },
+            { ELanguage::German,   "Diese Option ist mit der momentanen Hardwarekonfiguration nicht verfügbar." },
+            { ELanguage::French,   "Cette option n'est pas disponible avec votre configuration matérielle actuelle." },
+            { ELanguage::Spanish,  "Esta opción no está disponible con tu configuración actual de hardware." },
+            { ELanguage::Italian,  "Questa opzione non è disponibile con l'hardware in tuo possesso." }
         }
     },
     {
         // Notes: description for Transparency Anti-Aliasing when MSAA is disabled.
+        // Japanese Notes: This localization should include furigana.
         "Options_Desc_NotAvailableMSAA",
         {
-            { ELanguage::English, "This option is not available without MSAA." }
+            { ELanguage::English,  "This option is not available without MSAA." },
+            { ELanguage::Japanese, "この\u200Bオプションは\u200BMSAAなしで\u200B[変更:へんこう]\u200Bできません" },
+            { ELanguage::German,   "Diese Option ist ohne MSAA nicht verfügbar." },
+            { ELanguage::French,   "Cette option n'est pas disponible sans MSAA." },
+            { ELanguage::Spanish,  "Esta opción no está disponible sin MSAA." },
+            { ELanguage::Italian,  "Questa opzione non è disponibile senza MSAA." }
         }
     },
     {
         // Notes: description for Music Attenuation when the user is not running a supported OS.
+        // Japanese Notes: This localization should include furigana.
         "Options_Desc_OSNotSupported",
         {
-            { ELanguage::English, "This option is not supported by your operating system." }
+            { ELanguage::English,  "This option is not supported by your operating system." },
+            { ELanguage::Japanese, "この\u200Bオプションは\u200B[現在:げんざい]の\u200BOSで\u200B[変更:へんこう]\u200Bできません" },
+            { ELanguage::German,   "Diese Option wird von diesem Betriebssystem nicht unterstützt." },
+            { ELanguage::French,   "Cette option n'est pas prise en charge par votre système d'exploitation." },
+            { ELanguage::Spanish,  "Está opción no está soportada por tu sistema operativo." },
+            { ELanguage::Italian,  "Questa opzione non è disponibile con il tuo sistema operativo." }
         }
     },
     {
         // Notes: message appears when changing the Language option and backing out of the options menu.
+        // Japanese Notes: This localization should include furigana.
         "Options_Message_Restart",
         {
-            { ELanguage::English, "The game will now restart." }
+            { ELanguage::English,  "The game will now restart." },
+            { ELanguage::Japanese, "ゲームが[再起動:さいきどう]されます" },
+            { ELanguage::German,   "Das Spiel wird jetzt neu starten." },
+            { ELanguage::French,   "Le jeu va maintenant redémarrer." },
+            { ELanguage::Spanish,  "El juego se va a reiniciar." },
+            { ELanguage::Italian,  "Il gioco verrà riavviato." }
         }
     },
     {
         // Notes: used for the button guide at the pause menu.
         "Achievements_Name",
         {
-            { ELanguage::English, "Achievements" }
+            { ELanguage::English,  "Achievements" },
+            { ELanguage::Japanese, "実績" },
+            { ELanguage::German,   "Erfolge" },
+            { ELanguage::French,   "Succès" },
+            { ELanguage::Spanish,  "Logros" },
+            { ELanguage::Italian,  "Obiettivi" }
         }
     },
     {
         // Notes: used for the header in the achievements menu.
         "Achievements_Name_Uppercase",
         {
-            { ELanguage::English, "ACHIEVEMENTS" }
+            { ELanguage::English,  "ACHIEVEMENTS" },
+            { ELanguage::Japanese, "実績" },
+            { ELanguage::German,   "ERFOLGE" },
+            { ELanguage::French,   "SUCCÈS" },
+            { ELanguage::Spanish,  "LOGROS" },
+            { ELanguage::Italian,  "OBIETTIVI" }
         }
     },
     {
         "Achievements_Unlock",
         {
-            { ELanguage::English, "Achievement Unlocked!" }
+            { ELanguage::English,  "Achievement Unlocked!" },
+            { ELanguage::Japanese, "実績のロックが解除されました" },
+            { ELanguage::German,   "Erfolg Freigeschaltet!" },
+            { ELanguage::French,   "Succès déverrouillé !" },
+            { ELanguage::Spanish,  "¡Logro desbloqueado!" },
+            { ELanguage::Italian,  "Obiettivo sbloccato!" }
         }
     },
     {
         "Installer_Header_Installer",
         {
-            { ELanguage::English, "INSTALLER" },
-            { ELanguage::Spanish, "INSTALADOR" },
-            { ELanguage::Italian, "INSTALLATORE" },
+            { ELanguage::English,  "INSTALLER" },
+            { ELanguage::Japanese, "INSTALL" },
+            { ELanguage::German,   "INSTALLATION" },
+            { ELanguage::French,   "INSTALLATEUR" },
+            { ELanguage::Spanish,  "INSTALADOR" },
+            { ELanguage::Italian,  "INSTALLATORE" },
         },
     },
     {
         "Installer_Header_Installing",
         {
-            { ELanguage::English, "INSTALLING" },
-            { ELanguage::Spanish, "INSTALANDO" },
-            { ELanguage::Italian, "INSTALLANDO" },
+            { ELanguage::English,  "INSTALLING" },
+            { ELanguage::Japanese, "INSTALL" },
+            { ELanguage::German,   "INSTALLATION" },
+            { ELanguage::French,   "INSTALLATION" },
+            { ELanguage::Spanish,  "INSTALANDO" },
+            { ELanguage::Italian,  "INSTALLANDO" },
         }
     },
     {
+        // Japanese Notes: This localization should include furigana.
         "Installer_Page_SelectLanguage",
         {
-            { ELanguage::English, "Please select a language." },
-            { ELanguage::Italian, "Seleziona una lingua." }
+            { ELanguage::English,  "Please select a language." },
+            { ELanguage::Japanese, "[言語:げんご]を[選択:せんたく]してください" },
+            { ELanguage::German,   "Bitte eine Sprache auswählen." },
+            { ELanguage::French,   "Choisissez une langue." },
+            { ELanguage::Spanish,  "Selecciona un idioma." },
+            { ELanguage::Italian,  "Seleziona una lingua." }
         }
     },
     {
+        // Japanese Notes: This localization should include furigana.
         "Installer_Page_Introduction",
         {
-            { ELanguage::English, "Welcome to\nUnleashed Recompiled!\n\nYou'll need an Xbox 360 copy\nof Sonic Unleashed in order to proceed with the installation." },
-            { ELanguage::Italian, "Benvenuto a\nUnleashed Recompiled!\n\nDovrai avere una copia di\nSonic Unleashed per la Xbox 360\nper proseguire con l'installazione." }
+            { ELanguage::English,  "Welcome to\nUnleashed Recompiled!\n\nYou'll need an Xbox 360 copy\nof Sonic Unleashed in order to proceed with the installation." },
+            { ELanguage::Japanese, "Unleashed Recompiledへようこそ！\nインストールにはXbox 360[版:ばん]の\n「ソニック ワールドアドベンチャー」\nが必要です" },
+            { ELanguage::German,   "Willkommen zu\nUnleashed Recompiled!\nEs wird eine Xbox 360 Kopie von Sonic Unleashed benötigt um mit der Installation fortfahren zu können." },
+            { ELanguage::French,   "Bienvenue sur\nUnleashed Recompiled !\n\nVous aurez besoin d'une copie de Sonic Unleashed pour Xbox\n360 pour procéder à l'installation." },
+            { ELanguage::Spanish,  "¡Bienvenido a\nUnleashed Recompiled!\n\nNecesitas una copia de\nSonic Unleashed de Xbox 360\npara continuar con la instalación." },
+            { ELanguage::Italian,  "Benvenuto a\nUnleashed Recompiled!\n\nDovrai avere una copia di\nSonic Unleashed per la Xbox 360\nper proseguire con l'installazione." }
         }
     },
     {
+        // Japanese Notes: This localization should include furigana.
         "Installer_Page_SelectGameAndUpdate",
         {
-            { ELanguage::English, "Add the sources for the game and its title update." }
+            { ELanguage::English,  "Add the sources for the game and its title update." },
+            { ELanguage::Japanese, "ゲームのソースとタイトルアップデート\nを[追加:ついか]" },
+            { ELanguage::German,   "Füge die Quellen für das Spiel und dessen Update hinzu." },
+            { ELanguage::French,   "Ajouter les fichiers du jeu ainsi que ses mises à jour." },
+            { ELanguage::Spanish,  "Añade las fuentes para el juego y su actualización." },
+            { ELanguage::Italian,  "Aggiungi le fonti per il gioco e per il suo file d'aggiornamento." }
         }
     },
     {
+        // Japanese Notes: This localization should include furigana.
         "Installer_Page_SelectDLC",
         {
-            { ELanguage::English, "Add the sources for the DLC." }
+            { ELanguage::English,  "Add the sources for the DLC." },
+            { ELanguage::Japanese, "DLCのソースを[追加:ついか]" },
+            { ELanguage::German,   "Füge die Quellen für die Erweiterungen des Spiels hinzu." },
+            { ELanguage::French,   "Ajouter les fichiers pour les DLCs." },
+            { ELanguage::Spanish,  "Añade las fuentes para el DLC." },
+            { ELanguage::Italian,  "Aggiungi le fonti per i DLC." }
         }
     },
     {
+        // Japanese Notes: This localization should include furigana.
         "Installer_Page_CheckSpace",
         {
-            { ELanguage::English, "The content will be installed to the program's folder.\n\n" },
-            { ELanguage::Italian, "Il contenuto verrà installato nella cartella di questo programma.\n\n" }
+            { ELanguage::English,  "The content will be installed to the program's folder.\n\n" },
+            { ELanguage::Japanese, "コンテンツはプログラムのフォルダに\nインストールされます\n" },
+            { ELanguage::German,   "Der Inhalt wird in dem Ordner des Programms installiert.\n" },
+            { ELanguage::French,   "Le contenu sera installé dans le même dossier que le programme.\n" },
+            { ELanguage::Spanish,  "El contenido será instalado a la carpeta del programa.\n\n" },
+            { ELanguage::Italian,  "Il contenuto verrà installato nella cartella di questo programma.\n\n" }
         }
     },
     {
+        // Japanese Notes: This localization should include furigana.
         "Installer_Page_Installing",
         {
-            { ELanguage::English, "Please wait while the content is being installed..." },
-            { ELanguage::Italian, "Attendi mentre il contenuto viene installato... " }
+            { ELanguage::English,  "Please wait while the content is being installed..." },
+            { ELanguage::Japanese, "コンテンツのインストール[中:ちゅう]はお[待:ま]ち\nください" },
+            { ELanguage::German,   "Bitte warten. Der Inhalt wird installiert..." },
+            { ELanguage::French,   "Veuillez patienter pendant l'installation du contenu..." },
+            { ELanguage::Spanish,  "Por favor, espera mientras el contenido se instala... " },
+            { ELanguage::Italian,  "Attendi mentre il contenuto viene installato... " }
         }
     },
     {
+        // Japanese Notes: This localization should include furigana.
         "Installer_Page_InstallSucceeded",
         {
-            { ELanguage::English, "Installation complete!\nThis project is brought to you by:" }
+            { ELanguage::English,  "Installation complete!\nThis project is brought to you by:" },
+            { ELanguage::Japanese, "インストール[完了:かんりょう]！\nプロジェクト[制作:せいさく]：" },
+            { ELanguage::German,   "Installation abgeschlossen!\nDieses Projekt wird präsentiert von:" },
+            { ELanguage::French,   "Installation terminée !\nCe projet vous est présenté par:" },
+            { ELanguage::Spanish,  "¡Instalación completada!\nEste proyecto ha sido posible gracias a:" },
+            { ELanguage::Italian,  "Installazione completata!\nQuesto progetto è stato creato da:" }
         }
     },
     {
+        // Japanese Notes: This localization should include furigana.
         "Installer_Page_InstallFailed",
         {
-            { ELanguage::English, "Installation failed.\n\nError:\n\n" },
-            { ELanguage::Italian, "Installazione fallita.\n\nErrore:\n\n" }
+            { ELanguage::English,  "Installation failed.\n\nError: " },
+            { ELanguage::Japanese, "インストールに[失敗:しっぱい]しました\n\nエラー： " },
+            { ELanguage::German,   "Installation fehlgeschlagen.\n\nFehler: " },
+            { ELanguage::French,   "L'installation a échouée.\n\nErreur : " },
+            { ELanguage::Spanish,  "La instalación falló.\n\nError: " },
+            { ELanguage::Italian,  "Installazione fallita.\n\nErrore: " }
         }
     },
     {
         "Installer_Step_Game",
         {
-            { ELanguage::English, "GAME" },
-            { ELanguage::Italian, "GIOCO" }
+            { ELanguage::English,  "GAME" },
+            { ELanguage::Japanese, "ゲーム" },
+            { ELanguage::German,   "SPIEL" },
+            { ELanguage::French,   "JEU" },
+            { ELanguage::Spanish,  "JUEGO" },
+            { ELanguage::Italian,  "GIOCO" }
         }
     },
     {
         "Installer_Step_Update",
         {
-            { ELanguage::English, "UPDATE" },
-            { ELanguage::Italian, "AGGIORNAMENTO" }
+            { ELanguage::English,  "UPDATE" },
+            { ELanguage::Japanese, "アップデート" },
+            { ELanguage::German,   "UPDATE" },
+            { ELanguage::French,   "MISE À JOUR" },
+            { ELanguage::Spanish,  "ACTUALIZACIÓN" },
+            { ELanguage::Italian,  "AGGIORNAMENTO" }
         }
     },
     {
+        // Japanese Notes: This localization should include furigana.
         "Installer_Step_RequiredSpace",
         {
-            { ELanguage::English, "Required space: %2.2f GiB" },
-            { ELanguage::Italian, "Spazio necessario: %2.2f GiB" }
+            { ELanguage::English,  "Required space: %2.2f GiB" },
+            { ELanguage::Japanese, "[必要:ひつよう]な[容量:ようりょう]: %2.2f GiB" },
+            { ELanguage::German,   "Benötigter Speicherplatz:\n%2.2f GiB" },
+            { ELanguage::French,   "Espace nécessaire :\n%2.2f Gio" },
+            { ELanguage::Spanish,  "Espacio necesario: %2.2f GiB" },
+            { ELanguage::Italian,  "Spazio necessario: %2.2f GiB" }
         }
     },
     {
+        // Japanese Notes: This localization should include furigana.
         "Installer_Step_AvailableSpace",
         {
-            { ELanguage::English, "Available space: %2.2f GiB" },
-            { ELanguage::Italian, "Spazio disponibile: %2.2f GiB" }
+            { ELanguage::English,  "Available space: %2.2f GiB" },
+            { ELanguage::Japanese, "[使用:しよう][可能:かのう]な[容量:ようりょう]: %2.2f GiB" },
+            { ELanguage::German,   "Verfügbarer Speicherplatz:\n%2.2f GiB" },
+            { ELanguage::French,   "Espace disponible :\n%2.2f Gio" },
+            { ELanguage::Spanish,  "Espacio disponible: %2.2f GiB" },
+            { ELanguage::Italian,  "Spazio disponibile: %2.2f GiB" }
         }
     },
     {
         "Installer_Button_Next",
         {
-            { ELanguage::English, "NEXT" },
-            { ELanguage::Spanish, "SIGUIENTE" },
-            { ELanguage::German, "WEITER" },
-            { ELanguage::Italian, "CONTINUA" }
+            { ELanguage::English,  "NEXT" },
+            { ELanguage::Japanese, "次へ" },
+            { ELanguage::German,   "WEITER" },
+            { ELanguage::French,   "SUIVANT" },
+            { ELanguage::Spanish,  "SIGUIENTE" },
+            { ELanguage::Italian,  "CONTINUA" }
         }
     },
     {
         "Installer_Button_Skip",
         {
-            { ELanguage::English, "SKIP" },
-            { ELanguage::Spanish, "SALTAR" },
-            { ELanguage::German, "ÜBERSPRINGEN" },
-            { ELanguage::Italian, "SALTA" }
+            { ELanguage::English,  "SKIP" },
+            { ELanguage::Japanese, "スキップ" },
+            { ELanguage::German,   "ÜBERSPRINGEN" },
+            { ELanguage::French,   "IGNORER" },
+            { ELanguage::Spanish,  "SALTAR" },
+            { ELanguage::Italian,  "SALTA" }
         }
     },
     {
         "Installer_Button_Retry",
         {
-            { ELanguage::English, "RETRY" }
+            { ELanguage::English,  "RETRY" },
+            { ELanguage::Japanese, "リトライ" },
+            { ELanguage::German,   "ERNEUT VERSUCHEN" },
+            { ELanguage::French,   "RÉESSAYER" },
+            { ELanguage::Spanish,  "REINTENTAR" },
+            { ELanguage::Italian,  "RIPROVA" }
         }
     },
     {
         "Installer_Button_AddFiles",
         {
-            { ELanguage::English, "ADD FILES" },
-            { ELanguage::Spanish, "AÑADIR ARCHIVOS" },
-            { ELanguage::German, "DATEIEN HINZUFÜGEN" },
-            { ELanguage::Italian, "AGGIUNGI FILE" }
+            { ELanguage::English,  "ADD FILES" },
+            { ELanguage::Japanese, "ファイルを追加" },
+            { ELanguage::German,   "DATEIEN HINZUFÜGEN" },
+            { ELanguage::French,   "AJOUTER DES FICHIERS" },
+            { ELanguage::Spanish,  "AÑADIR ARCHIVOS" },
+            { ELanguage::Italian,  "AGGIUNGI FILE" }
         }
     },
     {
         "Installer_Button_AddFolder",
         {
-            { ELanguage::English, "ADD FOLDER" },
-            { ELanguage::Spanish, "AÑADIR CARPETA" },
-            { ELanguage::German, "ORDNER HINZUFÜGEN" },
-            { ELanguage::Italian, "AGGIUNGI CARTELLA" }
+            { ELanguage::English,  "ADD FOLDER" },
+            { ELanguage::Japanese, "フォルダを追加" },
+            { ELanguage::German,   "ORDNER HINZUFÜGEN" },
+            { ELanguage::French,   "AJOUTER UN DOSSIER" },
+            { ELanguage::Spanish,  "AÑADIR CARPETA" },
+            { ELanguage::Italian,  "AGGIUNGI CARTELLA" }
         }
     },
     {
         // Notes: message appears when using the "Add Files" option and choosing any file that is not an Xbox 360 game dump.
+        // Japanese Notes: This localization should include furigana.
         "Installer_Message_InvalidFilesList",
         {
-            { ELanguage::English, "The following selected files are invalid:" },
-            { ELanguage::Italian, "I seguenti file non sono validi:" }
+            { ELanguage::English,  "The following selected files are invalid:" },
+            { ELanguage::Japanese, "[選択:せんたく]した[次:つぎ]のファイルは[無効:むこう]です：" },
+            { ELanguage::German,   "Die folgenden Dateien sind ungültig:" },
+            { ELanguage::French,   "Les fichiers suivants ne sont pas valides :" },
+            { ELanguage::Spanish,  "Los siguientes archivos no son válidos:" },
+            { ELanguage::Italian,  "I seguenti file non sono validi:" }
         }
     },
     {
         // Notes: message appears in the event there are some invalid files after adding the DLC and moving onto the next step.
+        // Japanese Notes: This localization should include furigana.
         "Installer_Message_InvalidFiles",
         {
-            { ELanguage::English, "Some of the files that have\nbeen provided are not valid.\n\nPlease make sure all the\nspecified files are correct\nand try again." },
-            { ELanguage::Italian, "Alcuni dei file che sono stati\nselezionati non sono validi.\n\nAssicurati che tutti\ni file sono quelli corretti\ne riprova." }
+            { ELanguage::English,  "Some of the files that have\nbeen provided are not valid.\n\nPlease make sure all the\nspecified files are correct\nand try again." },
+            { ELanguage::Japanese, "[提供:ていきょう]されたファイルの[一部:いちぶ]が[有効:ゆうこう]ではありません\n[指定:してい]されたファイルがすべて[正:ただ]しいことを[確認:かくにん]して\nもう[一度:いちど]お[試:ため]しください" },
+            { ELanguage::German,   "Einige Dateien, die bereitgestellt\nwurden sind ungültig.\n\nBitte stelle sicher, dass\ndie angegebenen Dateien korrekt\nsind und versuche es erneut." },
+            { ELanguage::French,   "Certains fichiers fournis ne\nsont pas valides.\n\nVeuillez vous assurer que tous\nles fichiers spécifiés sont\ncorrects et réessayez." },
+            { ELanguage::Spanish,  "Algunos de los archivos\nseleccionados no son válidos.\n\nPor favor, asegúrate de que\ntodos los archivos son correctos\ne inténtalo de nuevo.\n" },
+            { ELanguage::Italian,  "Alcuni dei file che sono stati\nselezionati non sono validi.\n\nAssicurati che tutti\ni file sono quelli corretti\ne riprova." }
         }
     },
     {
         // Notes: message appears when clicking the "Add Files" option for the first time.
+        // Japanese Notes: This localization should include furigana.
         "Installer_Message_FilePickerTutorial",
         {
-            { ELanguage::English, "Select a digital dump with\ncontent from the game.\n\nThese files can be obtained from\nyour Xbox 360 hard drive by\nfollowing the instructions on\nthe GitHub page.\n\nFor choosing a folder with extracted\nand unmodified game files, use\nthe \"Add Folder\" option instead." },
+            { ELanguage::English,  "Select a digital dump with\ncontent from the game.\n\nThese files can be obtained from\nyour Xbox 360 hard drive by\nfollowing the instructions on\nthe GitHub page.\n\nFor choosing a folder with extracted\nand unmodified game files, use\nthe \"Add Folder\" option instead." },
+            { ELanguage::Japanese, "ゲームのコンテンツを[含:ふく]む デジタルダンプを[選択:せんたく]してください\n\nこれらのファイルは GitHubページの[指示:しじ]に[従:したが]って\nXbox 360ハードドライブから[取得:しゅとく]できます\n\n[抽出:ちゅうしゅつ]された[変更:へんこう]されていない\nゲームファイルを[含:ふく]むフォルダーを[選択:せんたく]するには\n[代:か]わりに「フォルダの[追加:ついか]」オプションを[使用:しよう]してください" },
+            { ELanguage::German,   "Wähle einen digitalen Dump von dem Spiel.\n\nDie Dateien können über die Festplatte deiner\nXbox 360 erlangt werden.\nFolge hierfür den Anweisungen auf der GitHub Seite.\n\nUm einen Ordner mit unmodifizierten Spieldateien auszuwählen, benutze die \"Ordner Hinzufügen\" Option stattdessen." },
+            { ELanguage::French,   "Sélectionnez une copie\ndématérialisée avec le contenu du\njeu de base.\n\nCes fichiers peuvent être obtenus\nà partir du disque dur de votre\nXbox 360 en suivant les\ninstructions de la page GitHub.\n\nPour choisir un dossier contenant\nles fichiers de jeu extraits et\nnon modifiés, utilisez plutôt\nl'option \"Ajouter un dossier\"." },
+            { ELanguage::Spanish,  "Selecciona una copia digital\ncon contenido del juego.\n\nPuedes obtener los archivos\nde tu disco duro de Xbox 360\nsiguiendo las instrucciones de\nla página de GitHub.\n\nPara elegir una carpeta con\narchivos extraídos sin modificar,\nutiliza la opción \"Añadir Carpeta\"." },
+            { ELanguage::Italian,  "Seleziona una copia digitale\ncon i contenuti del gioco.\n\nQuesti file possono essere ottenuti\ndall'hard drive della tua Xbox 360\nseguendo le istruzioni\nsulla pagina GitHub.\n\nPer selezionare una cartella\ncon file estratti e non modificati\nusa l'opzione \"Aggiungi cartella\"." }
         }
     },
     {
         // Notes: message appears when clicking the "Add Folder" option for the first time.
+        // Japanese Notes: This localization should include furigana.
         "Installer_Message_FolderPickerTutorial",
         {
-            { ELanguage::English, "Select a folder that contains the\nunmodified files that have been\nextracted from the game.\n\nThese files can be obtained from\nyour Xbox 360 hard drive by\nfollowing the instructions on\nthe GitHub page.\n\nFor choosing a digital dump,\nuse the\"Add Files\" option instead." },
+            { ELanguage::English,  "Select a folder that contains the\nunmodified files that have been\nextracted from the game.\n\nThese files can be obtained from\nyour Xbox 360 hard drive by\nfollowing the instructions on\nthe GitHub page.\n\nFor choosing a digital dump,\nuse the \"Add Files\" option instead." },
+            { ELanguage::Japanese, "ゲームから[抽出:ちゅうしゅつ]された[変更:へんこう]されていない\nファイルを含むフォルダを[選択:せんたく]してください\n\nこれらのファイルは GitHubページの[指示:しじ]に[従:したが]って\nXbox 360ハードドライブから[取得:しゅとく]できます\n\nデジタルダンプを[選択:せんたく]するには\n[代:か]わりに「ファイルの[追加:ついか]」オプションを[使用:しよう]してください" },
+            { ELanguage::German,   "Wähle einen Ordner, der unmodifizierte Dateien, die vom Spiel extrahiert wurden enthält.\n\nDie Dateien können über die Festplatte deiner\nXbox 360 erlangt werden.\nFolge hierfür den Anweisungen auf der GitHub Seite.\n\nUm einen digitalen Dump auszuwählen, benutze die \"Datei Hinzufügen\" Option stattdessen." },
+            { ELanguage::French,   "Sélectionnez un dossier contenant\nles fichiers extraits du jeu de\nbase.\n\nCes fichiers peuvent être obtenus\nà partir du disque dur de votre\nXbox 360 en suivant les\ninstructions de la page GitHub.\n\nPour choisir une copie\ndématérialisée, utilisez plutôt\nl'option \"Ajouter des fichiers\"." },
+            { ELanguage::Spanish,  "Selecciona una carpeta que\ncontenga los archivos sin\nmodificar extraídos del juego.\n\nPuedes obtener los archivos\nde tu disco duro de Xbox 360\nsiguiendo las instrucciones de\nla página de GitHub.\n\nPara elegir una copia digital,\nutiliza la opción \"Añadir Archivos\"." },
+            { ELanguage::Italian,  "Seleziona una cartella che contiene\ni file non modificati che sono stati\nestratti dal gioco.\n\nQuesti file possono essere ottenuti\ndall'hard drive della tua Xbox 360\nseguendo le istruzioni\nsulla pagina GitHub.\n\nPer selezionare una copia digitale\nusa l'opzione \"Aggiungi file\"." }
         }
     },
     {
         // Notes: message appears when providing a title update that does not match the region or version of the game dump.
+        // Japanese Notes: This localization should include furigana.
         "Installer_Message_IncompatibleGameData",
         {
-            { ELanguage::English, "The specified game and\ntitle update are incompatible.\n\nPlease ensure the files are\nfor the same version and\nregion and try again." },
-            { ELanguage::Italian, "I file del gioco\ne dell'aggiornamento sono incompatibili.\n\nAssicurati che i file sono\ndella stessa versione\ne regione e riprova." }
+            { ELanguage::English,  "The specified game and\ntitle update are incompatible.\n\nPlease ensure the files are\nfor the same version and\nregion and try again." },
+            { ELanguage::Japanese, "[指定:してい]されたゲームとタイトルアップデートは[互換性:ごかんせい]がありません\n\nファイルのバージョンと[地域:ちいき]が\n[同:おな]じであることを[確認:かくにん]して\nもう[一度:いちど]お[試:ため]しください" },
+            { ELanguage::German,   "Die ausgewählten Spiel- und\nUpdatedateien sind inkompatibel.\n\nBitte stelle sicher, dass\ndie Dateien für die selbe\nVersion und Region vorgesehen sind\nund versuche es erneut." },
+            { ELanguage::French,   "Les fichiers du jeu et la mise à\njour sont incompatibles.\n\nVeuillez vous assurer que les\nfichiers sont pour la même\nversion/région puis réessayez." },
+            { ELanguage::Spanish,  "El juego seleccionado\ny su actualización son incompatibles.\n\nPor favor, asegúrate de que que los archivos\nson de la misma versión y\nregión e inténtalo de nuevo." },
+            { ELanguage::Italian,  "I file del gioco\ne dell'aggiornamento sono incompatibili.\n\nAssicurati che i file sono\ndella stessa versione\ne regione e riprova." }
         }
     },
     {
         // Notes: message appears when clicking Skip at the DLC step.
+        // Japanese Notes: This localization should include furigana.
         "Installer_Message_DLCWarning",
         {
-            { ELanguage::English, "It is highly recommended\nthat you install all of the\nDLC, as it includes high\nquality lighting textures\nfor the base game.\n\nAre you sure you want to\nskip this step?" },
-            { ELanguage::Italian, "Si consiglia di installare\ntutti i DLC, poichè includono\ntexture di illuminazione di qualità migliore.\n\nSei sicuro di voler saltare?" }
+            { ELanguage::English,  "It is highly recommended\nthat you install all of the\nDLC, as it includes high\nquality lighting textures\nfor the base game.\n\nAre you sure you want to\nskip this step?" },
+            { ELanguage::Japanese, "ベースゲーム[用:よう]の[高品質:こうひんしつ]の\n[照明:しょうめい]テクスチャが[含:ふく]まれているため\nすべてのDLCをインストールすることを\n[強:つよ]くお[勧:すす]めします\n\nこの[手順:てじゅん]をスキップしてもよろしいですか？" },
+            { ELanguage::German,   "Es wird empgohlen alle Erweiterungen zu installieren, da sie Beleuchtungs-Texturen in einer höheren Qualität für das Basisspiel beinhalten.\n\nBist du dir sicher, dass du diesen Schritt überspringen möchtest?" },
+            { ELanguage::French,   "Il est fortement recommandé\nd'installer l'ensemble du\nDLC car elle inclut des\ntextures de lumière de\nhaute qualité pour le jeu\nde base.\n\nÊtes-vous sûr de vouloir\nignorer cette étape ?" },
+            { ELanguage::Spanish,  "Se recomienda encarecidamente\ninstalar todo el DLC, ya que\ncontiene texturas de iluminación\nde alta calidad para el juego base.\n\n¿Seguro que quieres saltar este paso?" },
+            { ELanguage::Italian,  "Si consiglia di installare\ntutti i DLC, poichè includono\ntexture di illuminazione di qualità migliore.\n\nSei sicuro di voler saltare?" }
         }
     },
     {
         // Notes: message appears when choosing the Install option at the title screen when the user is missing DLC content.
+        // Japanese Notes: This localization should include furigana.
         "Installer_Message_TitleMissingDLC",
         {
-            { ELanguage::English, "This will restart the game to\nallow you to install any DLC\nthat you are missing.\n\nInstalling DLC will improve the\nlighting quality across the game.\n\nWould you like to install missing\ncontent?" },
-            { ELanguage::Italian, "Questa opzione riavviera il gioco\nper farti installare qualsiasi DLC\nche non hai installato.\n\nL'installazione dei DLC migliorerà la qualità\ndell'illuminazione del gioco.\n\nVuoi installare i DLC mancanti?" }
+            { ELanguage::English,  "This will restart the game to\nallow you to install any DLC\nthat you are missing.\n\nInstalling DLC will improve the\nlighting quality across the game.\n\nWould you like to install missing\ncontent?" },
+            { ELanguage::Japanese, "これによりゲームが[再起動:さいきどう]し[不足:ふそく]しているDLCを\nインストールできるようになります\n\nDLCをインストールすると\nゲーム[全体:ぜんたい]の [照明品質:しょうめいひんしつ] が[向上:こうじょう]します\n\n[不足:ふそく]しているコンテンツを\nインストールしますか？" },
+            { ELanguage::German,   "Das Spiel wird neu gestartet\num die Installation einer fehlenden\nErweiterung zu ermöglichen.\n\nDie Installation einer\nErweiterung erhöht die Qualität\nder Beleuchtung im gesamten Spiel.\n\nMöchtest du den fehlenden\nInhalt installieren?" },
+            { ELanguage::French,   "Cela redémarrera le jeu pour vous\npermettre d'installer les DLC\nmanquants.\n\nL'installation du DLC améliorera\nla qualité de l'éclairage dans le\njeu.\n\nSouhaitez-vous installer le\ncontenu manquant ?" },
+            { ELanguage::Spanish,  "Esta opción reiniciará el juego\npara permitirte instalar los DLC\nque falten.\n\nInstalar el DLC mejorará la calidad\nde iluminación en todo el juego.\n\n¿Quieres instalar el contenido\nque falta?" },
+            { ELanguage::Italian,  "Questa opzione riavviera il gioco\nper farti installare qualsiasi DLC\nche non hai installato.\n\nL'installazione dei DLC migliorerà la qualità\ndell'illuminazione del gioco.\n\nVuoi installare i DLC mancanti?" }
         }
     },
     {
         // Notes: message appears when choosing the Install option at the title screen when the user is not missing any content.
+        // Japanese Notes: This localization should include furigana.
         "Installer_Message_Title",
         {
-            { ELanguage::English, "This restarts the game to\nallow you to install any DLC\nthat you may be missing.\n\nYou are not currently\nmissing any DLC.\n\nWould you like to proceed\nanyway?" },
-            { ELanguage::Italian, "Questa opzione riavviera il gioco\nper farti installare qualsiasi DLC\nche non hai installato.\n\nHai già installato tutti i DLC.\n\nVuoi procedere comunque?" }
+            { ELanguage::English,  "This restarts the game to\nallow you to install any DLC\nthat you may be missing.\n\nYou are not currently\nmissing any DLC.\n\nWould you like to proceed\nanyway?" },
+            { ELanguage::Japanese, "これによりゲームが[再起動:さいきどう]され\n[不足:ふそく]しているDLCを\nインストールできるようになります\n\n[現在:げんざい] [不足:ふそく]しているDLCはありません\n\nそれでも[続行:ぞっこう]しますか？" },
+            { ELanguage::German,   "Das Spiel wird neu gestartet\num die Installation einer fehlenden\nErweiterung zu ermöglichen.\n\nEs kann keine weitere Erweiterung\ninstalliert werden.\n\nMöchtest du trotzdem fortfahren?" },
+            { ELanguage::French,   "Cela redémarrera le jeu pour vous\npermettre d'installer les DLC\nmanquants.\n\nIl ne vous manque aucun DLC.\n\nVoulez-vous quand même continuer ?" },
+            { ELanguage::Spanish,  "Esto reiniciará el juego\npara permitirte instalar\nlos DLC que falten.\n\nActualmente, no falta ningún\nDLC por instalarse.\n\n¿Quieres continuar de todos\nmodos?" },
+            { ELanguage::Italian,  "Questa opzione riavviera il gioco\nper farti installare qualsiasi DLC\nche non hai installato.\n\nHai già installato tutti i DLC.\n\nVuoi procedere comunque?" }
         }
     },
     {
         // Notes: message appears when user chooses "Quit" on the first available installation screen.
+        // Japanese Notes: This localization should include furigana.
         "Installer_Message_Quit",
         {
-            { ELanguage::English, "Are you sure you want to quit?" },
+            { ELanguage::English,  "Are you sure you want to quit?" },
+            { ELanguage::Japanese, "[終了:しゅうりょう]してもよろしいですか？" },
+            { ELanguage::German,   "Installation verlassen?" },
+            { ELanguage::French,   "Êtes-vous sûr de vouloir quitter ?" },
+            { ELanguage::Spanish,  "¿Estás seguro de que quieres\nsalir?" },
+            { ELanguage::Italian,  "Sicuro di voler uscire?" }
         }
     },
     {
         // Notes: message appears when user chooses "Cancel" during installation.
+        // Japanese Notes: This localization should include furigana.
         "Installer_Message_Cancel",
         {
-            { ELanguage::English, "Are you sure you want to cancel the installation?" },
+            { ELanguage::English,  "Are you sure you want to cancel the installation?" },
+            { ELanguage::Japanese, "インストールをキャンセルしてもよろしいですか？" },
+            { ELanguage::German,   "Bist du dir sicher, dass du die Installation abbrechen möchtest?" },
+            { ELanguage::French,   "Êtes-vous sûr de vouloir annuler l'installation ?" },
+            { ELanguage::Spanish,  "¿Estás seguro de que quieres cancelar la instalación?" },
+            { ELanguage::Italian,  "Sicuro di voler annullare l'installazione?" }
         }
     },
     {
         // Notes: message appears when pressing B at the title screen.
+        // Japanese Notes: This localization should include furigana.
         "Title_Message_Quit",
         {
-            { ELanguage::English, "Are you sure you want to quit?" },
-            { ELanguage::Italian, "Sei sicuro di voler uscire?" }
+            { ELanguage::English,  "Are you sure you want to quit?" },
+            { ELanguage::Japanese, "[終了:しゅうりょう]してもよろしいですか？" },
+            { ELanguage::German,   "Spiel verlassen?" },
+            { ELanguage::French,   "Êtes-vous sûr de vouloir quitter ?" },
+            { ELanguage::Spanish,  "¿Estás seguro de que quieres\nsalir?" },
+            { ELanguage::Italian,  "Sicuro di voler uscire ?" }
         }
     },
     {
@@ -373,40 +633,63 @@ std::unordered_map<std::string, std::unordered_map<ELanguage, std::string>> g_lo
         // Do not localise this unless absolutely necessary, these strings are from the XEX.
         "Title_Message_SaveDataCorrupt",
         {
-            { ELanguage::English, "The save file appears to be\ncorrupted and cannot be loaded." },
+            { ELanguage::English,  "The save file appears to be\ncorrupted and cannot be loaded." },
             { ELanguage::Japanese, "ゲームデータの読み込みに失敗しました。\nこのまま続けるとゲームデータをセーブすることはできません" },
-            { ELanguage::German, "Diese Speicherdatei ist beschädigt\nund kann nicht geladen werden." },
-            { ELanguage::French, "Le fichier de sauvegarde semble être\nendommagé et ne peut être chargé." },
-            { ELanguage::Spanish, "El archivo parece estar dañado\ny no se puede cargar." },
-            { ELanguage::Italian, "I file di salvataggio sembrano danneggiati\ne non possono essere caricati." }
+            { ELanguage::German,   "Diese Speicherdatei ist beschädigt\nund kann nicht geladen werden." },
+            { ELanguage::French,   "Le fichier de sauvegarde semble être\nendommagé et ne peut être chargé." },
+            { ELanguage::Spanish,  "El archivo parece estar dañado\ny no se puede cargar." },
+            { ELanguage::Italian,  "I file di salvataggio sembrano danneggiati\ne non possono essere caricati." }
         }
     },
     {
         // Notes: message appears when ACH-DATA is corrupted (mismatching file size, bad signature, incorrect version or invalid checksum) upon pressing start at the title screen.
         // To make this occur, open the file in any editor and just remove a large chunk of data.
+        // Japanese Notes: This localization should include furigana.
         "Title_Message_AchievementDataCorrupt",
         {
-            { ELanguage::English, "The achievement data appears to be\ncorrupted and cannot be loaded.\n\nProceeding from this point will\nclear your achievement data." }
+            { ELanguage::English,  "The achievement data appears to be\ncorrupted and cannot be loaded.\n\nProceeding from this point will\nclear your achievement data." },
+            { ELanguage::Japanese, "[実績:じっせき]データが[破損:はそん]しているため\n[読:よ]み[込:こ]むことができません\n\nこの[先:さき]に[進:すす]むと[実績:じっせき]データが\n[消去:しょうきょ]されます" },
+            { ELanguage::German,   "Die Erfolgsdaten sind möglicherweise\nfehlerhaft und können nicht\ngeladen werden.\n\nDurch das Fortfahren werden\ndeine bisherigen Erfolgsdaten gelöscht." },
+            { ELanguage::French,   "Les données des succès semblent être\nendommagées et ne peuvent être\nchargées.\n\nSi vous continuez, vos données\nseront écrasées." },
+            { ELanguage::Spanish,  "Los datos de logros parecen estar\ncorruptos y no pueden cargarse.\n\nContinuar a partir de este punto\neliminará los datos de logros." },
+            { ELanguage::Italian,  "I file degli obiettivi sembrano danneggiati\ne non possono essere caricati.\n\nSe prosegui da questo punto\ni tuoi obiettivi verranno cancellati." }
         }
     },
     {
         // Notes: message appears when ACH-DATA cannot be loaded upon pressing start at the title screen.
         // To make this occur, lock the ACH-DATA file using an external program so that it cannot be accessed by the game.
+        // Japanese Notes: This localization should include furigana.
         "Title_Message_AchievementDataIOError",
         {
-            { ELanguage::English, "The achievement data could not be loaded.\nYour achievements will not be saved." }
+            { ELanguage::English,  "The achievement data could not be loaded.\nYour achievements will not be saved." },
+            { ELanguage::Japanese, "[実績:じっせき]データを[読:よ]み[込:こ]めませんでした\n[実績:じっせき]は[保存:ほぞん]されません。" },
+            { ELanguage::German,   "Die Erfolgsdaten konnten nicht geladen werden.\nDeine Erfolge werden nicht gespeichert." },
+            { ELanguage::French,   "Les données des succès ne\npeuvent être chargées.\nVos succès ne seront pas\nsauvegardés." },
+            { ELanguage::Spanish,  "Los datos de logros no pueden cargarse.\nTus logros no serán guardados." },
+            { ELanguage::Italian,  "I file degli obiettivi non possono essere caricati.\nI tuoi obiettivi non verranno salvati." }
         }
     },
     {
+        // Japanese Notes: This localization should include furigana.
         "Title_Message_UpdateAvailable",
         {
-            { ELanguage::English, "An update is available!\n\nWould you like to visit the\nreleases page to download it?" }
+            { ELanguage::English,  "An update is available!\n\nWould you like to visit the\nreleases page to download it?" },
+            { ELanguage::Japanese, "アップデートが[利用:りよう][可能:かのう]です\n\nリリースページにアクセスして\nダウンロードしますか？" },
+            { ELanguage::German,   "Ein Update ist verfügbar!\n\nMöchtest du die Release-Seite\nbesuchen um es herunterzuladen?" },
+            { ELanguage::French,   "Une mise à jour est disponible !\n\nVoulez-vous visiter la page\ndes mises à jour pour la\ntélécharger ?" },
+            { ELanguage::Spanish,  "¡Hay una actualización disponible!\n\n¿Quieres ir a la página\npara descargarla?" },
+            { ELanguage::Italian,  "È disponibile un aggiornamento!\n\nVuoi visitare la pagina releases\nper scaricarlo?" }
         }
     },
     {
         "Video_BackendError",
         {
-            { ELanguage::English, "Unable to create a D3D12 (Windows) or Vulkan backend.\n\nPlease make sure that:\n\n- Your system meets the minimum requirements.\n- Your GPU drivers are up to date.\n- Your operating system is on the latest version available." }
+            { ELanguage::English,  "Unable to create a D3D12 (Windows) or Vulkan backend.\n\nPlease make sure that:\n\n- Your system meets the minimum requirements.\n- Your GPU drivers are up to date.\n- Your operating system is on the latest version available." },
+            { ELanguage::Japanese, "D3D12 (Windows)または\nVulkanバックエンドを作成できません\n\n次の点を確認してください：\n\n※システムが最小要件を満たしている\n※GPUドライバーが最新である\n※オペレーティングシステムが最新バージョンである" },
+            { ELanguage::German,   "Es ist nicht möglich, ein D3D12 (Windows) oder Vulkan-Backend zu erstellen.\n\nBitte stelle sicher, dass:\n\n- Dein System die Mindestanforderungen erfüllt.\n- Deine GPU-Treiber auf dem neuesten Stand sind.\n- Dein Betriebssystem auf der neuesten verfügbaren Version ist." },
+            { ELanguage::French,   "Impossible de créer un backend D3D12 (Windows) ou Vulkan.\n\nVeuillez vous assurer que :\n\n- Votre système répond aux critères minimums requis.\n- Les pilotes de votre processeur graphique sont à jour.\n- Votre système d'exploitation est à jour." },
+            { ELanguage::Spanish,  "No se puede crear un entorno de D3D12 (Windows) o de Vulkan.\n\nPor favor, asegúrate de que:\n\n- Tu equipo cumple con los requisitos mínimos.\n- Los drivers de tu tarjeta gráfica están actualizados.\n- Tu sistema operativo está actualizado a la última versión.\n" },
+            { ELanguage::Italian,  "Impossibile creare un backend D3D12 (Windows) o Vulkan.\n\nAssicurati che:\n\n- Il tuo sistema soddisfi i requisiti minimi.\n- I driver della scheda grafica siano aggiornati.\n- Il tuo sistema operativo sia aggiornato." }
         }
     },
     {
@@ -434,82 +717,116 @@ std::unordered_map<std::string, std::unordered_map<ELanguage, std::string>> g_lo
     {
         "Common_Yes",
         {
-            { ELanguage::English, "Yes" },
-            { ELanguage::Italian, "Sì" }
+            { ELanguage::English,  "Yes" },
+            { ELanguage::Japanese, "はい" },
+            { ELanguage::German,   "Ja" },
+            { ELanguage::French,   "Oui" },
+            { ELanguage::Spanish, "Sí" },
+            { ELanguage::Italian,  "Sì" }
         }
     },
     {
         "Common_No",
         {
-            { ELanguage::English, "No" },
-            { ELanguage::Italian, "No" }
+            { ELanguage::English,  "No" },
+            { ELanguage::Japanese, "いいえ" },
+            { ELanguage::German,   "Nein" },
+            { ELanguage::French,   "Non" },
+            { ELanguage::Spanish,  "No" },
+            { ELanguage::Italian,  "No" }
         }
     },
     {
         "Common_Next",
         {
-            { ELanguage::English, "Next" },
-            { ELanguage::Italian, "Continua" }
+            { ELanguage::English,  "Next" },
+            { ELanguage::Japanese, "次へ" },
+            { ELanguage::German,   "Weiter" },
+            { ELanguage::French,   "Suivant" },
+            { ELanguage::Spanish, "Siguiente" },
+            { ELanguage::Italian,  "Avanti" }
         }
     },
     {
         "Common_Select",
         {
-            { ELanguage::English, "Select" },
-            { ELanguage::Italian, "Seleziona" }
+            { ELanguage::English,  "Select" },
+            { ELanguage::Japanese, "決定" },
+            { ELanguage::German,   "Auswählen" },
+            { ELanguage::French,   "Choisir" },
+            { ELanguage::Spanish,  "Seleccionar" },
+            { ELanguage::Italian,  "Seleziona" }
         }
     },
     {
         "Common_Back",
         {
-            { ELanguage::English, "Back" },
-            { ELanguage::Italian, "Indietro" }
+            { ELanguage::English,  "Back" },
+            { ELanguage::Japanese, "もどる" },
+            { ELanguage::German,   "Zurück" },
+            { ELanguage::French,   "Retour" },
+            { ELanguage::Spanish,  "Atrás" },
+            { ELanguage::Italian,  "Indietro" }
         }
     },
     {
         "Common_Quit",
         {
-            { ELanguage::English, "Quit" },
+            { ELanguage::English,  "Quit" },
+            { ELanguage::Japanese, "終了" },
+            { ELanguage::German,   "Verlassen" },
+            { ELanguage::French,   "Quitter" },
+            { ELanguage::Spanish,  "Salir" },
+            { ELanguage::Italian,  "Esci" }
         }
     },
     {
         "Common_Cancel",
         {
-            { ELanguage::English, "Cancel" }
+            { ELanguage::English,  "Cancel" },
+            { ELanguage::Japanese, "キャンセル" },
+            { ELanguage::German,   "Abbrechen" },
+            { ELanguage::French,   "Annuler" },
+            { ELanguage::Spanish,  "Cancelar" },
+            { ELanguage::Italian,  "Annulla" }
         }
     },
     {
         "Common_Reset",
         {
-            { ELanguage::English, "Reset" },
-            { ELanguage::Italian, "Ripristina" }
+            { ELanguage::English,  "Reset" },
+            { ELanguage::Japanese, "リセット" },
+            { ELanguage::German,   "Zurücksetzen" },
+            { ELanguage::French,   "Par défaut" },
+            { ELanguage::Spanish,  "Reiniciar" },
+            { ELanguage::Italian,  "Ripristina" }
         }
     },
     {
         "Common_Switch",
         {
-            { ELanguage::English, "Switch" },
-            { ELanguage::Italian, "Cambia" }
+            { ELanguage::English,  "Switch" },
+            { ELanguage::Japanese, "きりかえ" },
+            { ELanguage::German,   "Wechseln" },
+            { ELanguage::French,   "Changer" },
+            { ELanguage::Spanish,  "Cambiar" },
+            { ELanguage::Italian,  "Cambia" }
         }
     }
 };
 
-std::string& Localise(const char* key)
+std::string& Localise(const std::string_view& key)
 {
-    if (!g_locale.count(key))
-        return g_localeMissing;
-
-    if (!g_locale[key].count(Config::Language))
+    auto localeFindResult = g_locale.find(key);
+    if (localeFindResult != g_locale.end())
     {
-        if (g_locale[key].count(ELanguage::English))
-        {
-            return g_locale[key][ELanguage::English];
-        }
-        else
-        {
-            return g_localeMissing;
-        }
+        auto languageFindResult = localeFindResult->second.find(Config::Language);
+        if (languageFindResult == localeFindResult->second.end())
+            languageFindResult = localeFindResult->second.find(ELanguage::English);
+
+        if (languageFindResult != localeFindResult->second.end())
+            return languageFindResult->second;
     }
 
-    return g_locale[key][Config::Language];
+    return g_localeMissing;
 }

UnleashedRecomp/locale/locale.h

@@ -12,6 +12,6 @@ enum class ELanguage : uint32_t
 
 inline std::string g_localeMissing = "<missing string>";
 
-extern std::unordered_map<std::string, std::unordered_map<ELanguage, std::string>> g_locale;
+extern std::unordered_map<std::string_view, std::unordered_map<ELanguage, std::string>> g_locale;
 
-std::string& Localise(const char* key);
+std::string& Localise(const std::string_view& key);

UnleashedRecomp/main.cpp

@@ -106,33 +106,33 @@ uint32_t LdrLoadModule(const std::filesystem::path &path)
         return 0;
     }
 
-    auto* xex = reinterpret_cast<XEX_HEADER*>(loadResult.data());
-    auto security = reinterpret_cast<XEX2_SECURITY_INFO*>((char*)xex + xex->AddressOfSecurityInfo);
-
-    auto format = Xex2FindOptionalHeader<XEX_FILE_FORMAT_INFO>(xex, XEX_HEADER_FILE_FORMAT_INFO);
-    auto entry = *Xex2FindOptionalHeader<uint32_t>(xex, XEX_HEADER_ENTRY_POINT);
+    auto* header = reinterpret_cast<const Xex2Header*>(loadResult.data());
+    auto* security = reinterpret_cast<const Xex2SecurityInfo*>(loadResult.data() + header->securityOffset);
+    const auto* fileFormatInfo = reinterpret_cast<const Xex2OptFileFormatInfo*>(getOptHeaderPtr(loadResult.data(), XEX_HEADER_FILE_FORMAT_INFO));
+    auto entry = *reinterpret_cast<const uint32_t*>(getOptHeaderPtr(loadResult.data(), XEX_HEADER_ENTRY_POINT));
     ByteSwapInplace(entry);
 
-    auto srcData = (char *)xex + xex->SizeOfHeader;
-    auto destData = (char *)g_memory.Translate(security->ImageBase);
-    if (format->CompressionType == 0)
+    auto srcData = loadResult.data() + header->headerSize;
+    auto destData = reinterpret_cast<uint8_t*>(g_memory.Translate(security->loadAddress));
+
+    if (fileFormatInfo->compressionType == XEX_COMPRESSION_NONE)
     {
-        memcpy(destData, srcData, security->SizeOfImage);
+        memcpy(destData, srcData, security->imageSize);
     }
-    else if (format->CompressionType == 1)
+    else if (fileFormatInfo->compressionType == XEX_COMPRESSION_BASIC)
     {
-        auto numBlocks = (format->SizeOfHeader / sizeof(XEX_BASIC_FILE_COMPRESSION_INFO)) - 1;
-        auto blocks = reinterpret_cast<const XEX_BASIC_FILE_COMPRESSION_INFO*>(format + 1);
+        auto* blocks = reinterpret_cast<const Xex2FileBasicCompressionBlock*>(fileFormatInfo + 1);
+        const size_t numBlocks = (fileFormatInfo->infoSize / sizeof(Xex2FileBasicCompressionInfo)) - 1;
 
         for (size_t i = 0; i < numBlocks; i++)
         {
-            memcpy(destData, srcData, blocks[i].SizeOfData);
+            memcpy(destData, srcData, blocks[i].dataSize);
 
-            srcData += blocks[i].SizeOfData;
-            destData += blocks[i].SizeOfData;
-            memset(destData, 0, blocks[i].SizeOfPadding);
+            srcData += blocks[i].dataSize;
+            destData += blocks[i].dataSize;
 
-            destData += blocks[i].SizeOfPadding;
+            memset(destData, 0, blocks[i].zeroSize);
+            destData += blocks[i].zeroSize;
         }
     }
     else
@@ -140,9 +140,9 @@ uint32_t LdrLoadModule(const std::filesystem::path &path)
         assert(false && "Unknown compression type.");
     }
 
-    auto res = Xex2FindOptionalHeader<XEX_RESOURCE_INFO>(xex, XEX_HEADER_RESOURCE_INFO);
+    auto res = reinterpret_cast<const Xex2ResourceInfo*>(getOptHeaderPtr(loadResult.data(), XEX_HEADER_RESOURCE_INFO));
 
-    g_xdbfWrapper = XDBFWrapper((uint8_t*)g_memory.Translate(res->Offset.get()), res->SizeOfData);
+    g_xdbfWrapper = XDBFWrapper((uint8_t*)g_memory.Translate(res->offset.get()), res->sizeOfData);
 
     return entry;
 }

UnleashedRecomp/mod/mod_loader.cpp

@@ -5,7 +5,9 @@
 #include <cpu/guest_stack_var.h>
 #include <kernel/function.h>
 #include <kernel/heap.h>
+#include <user/config.h>
 #include <user/paths.h>
+#include <os/logger.h>
 #include <os/process.h>
 #include <xxHashMap.h>
 
@@ -117,7 +119,10 @@ void ModLoader::Init()
     }
 
     if (configIni.getString("CPKREDIR", "LogType", std::string()) == "console")
+    {
         os::process::ShowConsole();
+        s_isLogTypeConsole = true;
+    }
 
     std::string modsDbIniFilePathU8 = configIni.getString("CPKREDIR", "ModsDbIni", "");
     if (modsDbIniFilePathU8.empty())
@@ -208,6 +213,42 @@ void ModLoader::Init()
         if (!mod.includeDirs.empty())
             g_mods.emplace_back(std::move(mod));
     }
+
+    auto codeCount = modsDbIni.get<size_t>("Codes", "CodeCount", 0);
+
+    if (codeCount)
+    {
+        std::vector<std::string> codes{};
+
+        for (size_t i = 0; i < codeCount; i++)
+        {
+            auto name = modsDbIni.getString("Codes", fmt::format("Code{}", i), "");
+
+            if (name.empty())
+                continue;
+
+            codes.push_back(name);
+        }
+
+        for (auto& def : g_configDefinitions)
+        {
+            if (!def->IsHidden() || def->GetSection() != "Codes")
+                continue;
+
+            /* NOTE: this is inefficient, but it happens
+               once on boot for a handful of codes at release
+               and is temporary until we support real code mods. */
+            for (size_t i = 0; i < codes.size(); i++)
+            {
+                if (def->GetName() == codes[i])
+                {
+                    LOGF_IMPL(Utility, "Mod Loader", "Loading code: \"{}\"", codes[i]);
+                    *(bool*)def->GetValue() = true;
+                    break;
+                }
+            }
+        }
+    }
 }
 
 static constexpr uint32_t LZX_SIGNATURE = 0xFF512EE;
@@ -337,6 +378,9 @@ PPC_FUNC(sub_82E0D3E8)
         std::ifstream stream(filePath, std::ios::binary);
         if (stream.good())
         {
+            if (ModLoader::s_isLogTypeConsole)
+                LOGF_IMPL(Utility, "Mod Loader", "Loading file: \"{}\"", reinterpret_cast<const char*>(filePath.u8string().c_str()));
+
             be<uint32_t> signature{};
             stream.read(reinterpret_cast<char*>(&signature), sizeof(signature));
 
@@ -518,14 +562,68 @@ PPC_FUNC(sub_82E0D3E8)
     g_userHeap.Free(newArlFileData);
 }
 
+// Load elements have an unused "pretty name" field. We will use this field to store the archive file path,
+// prefixed with a magic string. When the first load detects this string, it will load append archives
+// and then clear the field to prevent remaining splits from loading the append archives again.
+// We cannot rely on .ar.00 being the first split to be loaded, so this approach is necessary.
+static thread_local uint32_t g_prefixedArFilePath = NULL;
+
+// Hedgehog::Database::CDatabaseLoader::LoadArchives
+PPC_FUNC_IMPL(__imp__sub_82E0CC38);
+PPC_FUNC(sub_82E0CC38)
+{
+    if (g_mods.empty())
+    {
+        __imp__sub_82E0CC38(ctx, base);
+        return;
+    }
+
+    auto r3 = ctx.r3;
+    auto r4 = ctx.r4;
+    auto r5 = ctx.r5;
+    auto r6 = ctx.r6;
+    auto r7 = ctx.r7;
+    auto r8 = ctx.r8;
+
+    const char* arFilePath = reinterpret_cast<const char*>(base + PPC_LOAD_U32(r5.u32));
+
+    // __HH_ALLOC
+    ctx.r3.u32 = 22 + strlen(arFilePath);
+    sub_822C0988(ctx, base);
+    char* prefixedArFilePath = reinterpret_cast<char*>(base + ctx.r3.u32);
+
+    *reinterpret_cast<be<uint32_t>*>(prefixedArFilePath) = 1;
+    strcpy(prefixedArFilePath + 0x4, "/UnleashedRecomp/");
+    strcpy(prefixedArFilePath + 0x15, arFilePath);
+
+    ctx.r1.u32 -= 0x10;
+    uint32_t stackSpace = ctx.r1.u32;
+    PPC_STORE_U32(stackSpace, static_cast<uint32_t>(reinterpret_cast<uint8_t*>(prefixedArFilePath) - base) + 0x4);
+    g_prefixedArFilePath = stackSpace;
+
+    ctx.r3 = r3;
+    ctx.r4 = r4;
+    ctx.r5 = r5;
+    ctx.r6 = r6;
+    ctx.r7 = r7;
+    ctx.r8 = r8;
+    __imp__sub_82E0CC38(ctx, base);
+
+    // Hedgehog::Base::CSharedString::~CSharedString
+    ctx.r3.u32 = stackSpace;
+    sub_82DFB148(ctx, base);
+
+    g_prefixedArFilePath = NULL;
+    ctx.r1.u32 += 0x10;
+}
+
 // Hedgehog::Database::SLoadElement::SLoadElement
 PPC_FUNC_IMPL(__imp__sub_82E140D8);
 PPC_FUNC(sub_82E140D8)
 {
-    // Store archive name as the pretty name to use it later for append archive loading.
-    // This is always set to an empty string for archives, so it should be safe to replace.
-    if (!g_mods.empty() && PPC_LOAD_U32(ctx.r5.u32) == 0x8200A621)
-        ctx.r5.u32 = ctx.r6.u32;
+    // Store the prefixed archive file path as the pretty name. It's unused for archives we want to append to.
+    if (!g_mods.empty() && PPC_LOAD_U32(ctx.r5.u32) == 0x8200A621 && g_prefixedArFilePath != NULL)
+        ctx.r5.u32 = g_prefixedArFilePath;
 
     __imp__sub_82E140D8(ctx, base);
 }
@@ -540,25 +638,17 @@ PPC_FUNC(sub_82E0B500)
         return;
     }
 
-    std::u8string_view arFilePathU8(reinterpret_cast<const char8_t*>(base + PPC_LOAD_U32(ctx.r5.u32)));
-    size_t index = arFilePathU8.find(u8".ar.00");
-    if (index == (arFilePathU8.size() - 6))
+    uint32_t prefixedArFilePath = PPC_LOAD_U32(ctx.r5.u32);
+    std::u8string_view arFilePathU8(reinterpret_cast<const char8_t*>(base + prefixedArFilePath));
+    if (!arFilePathU8.starts_with(u8"/UnleashedRecomp/"))
     {
-        arFilePathU8.remove_suffix(3);
+        __imp__sub_82E0B500(ctx, base);
+        return;
     }
-    else
-    {
-        index = arFilePathU8.find(u8".ar");
 
-        if (index != (arFilePathU8.size() - 3) ||
-            arFilePathU8.starts_with(u8"tg-") ||
-            arFilePathU8.starts_with(u8"gia-") ||
-            arFilePathU8.starts_with(u8"gi-texture-"))
-        {
-            __imp__sub_82E0B500(ctx, base);
-            return;
-        }
-    }
+    // Immediately clear the string, so the remaining splits don't load append archives again.
+    PPC_STORE_U8(prefixedArFilePath, 0x00);
+    arFilePathU8.remove_prefix(0x11);
 
     auto r3 = ctx.r3; // Callback
     auto r4 = ctx.r4; // Database
@@ -572,6 +662,9 @@ PPC_FUNC(sub_82E0B500)
             std::ifstream stream(arFilePath, std::ios::binary);
             if (stream.good())
             {
+                if (ModLoader::s_isLogTypeConsole)
+                    LOGF_IMPL(Utility, "Mod Loader", "Loading file: \"{}\"", reinterpret_cast<const char*>(arFilePath.u8string().c_str()));
+
                 stream.seekg(0, std::ios::end);
                 size_t arFileSize = stream.tellg();
 

UnleashedRecomp/mod/mod_loader.h

@@ -2,6 +2,8 @@
 
 struct ModLoader
 {
+    static inline bool s_isLogTypeConsole;
+
     static inline std::filesystem::path s_saveFilePath;
     
     static std::filesystem::path ResolvePath(std::string_view path);

UnleashedRecomp/os/win32/registry_win32.inl

@@ -1,5 +1,4 @@
 #include <os/registry.h>
-#include <unordered_map>
 
 inline const wchar_t* g_registryRoot = L"Software\\UnleashedRecomp";
 

UnleashedRecomp/patches/CHudPause_patches.cpp

@@ -24,6 +24,9 @@ void CHudPauseAddOptionsItemMidAsmHook(PPCRegister& pThis)
 
 bool InjectMenuBehaviour(uint32_t pThis, uint32_t count)
 {
+    if (App::s_isLoading)
+        return true;
+
     auto pHudPause = (SWA::CHudPause*)g_memory.Translate(pThis);
     auto cursorIndex = *(be<uint32_t>*)g_memory.Translate(4 * (*(be<uint32_t>*)g_memory.Translate(pThis + 0x19C) + 0x68) + pThis);
 
@@ -116,6 +119,12 @@ bool CHudPauseMiscInjectOptionsMidAsmHook(PPCRegister& pThis)
 PPC_FUNC_IMPL(__imp__sub_824B0930);
 PPC_FUNC(sub_824B0930)
 {
+    if (App::s_isLoading)
+    {
+        __imp__sub_824B0930(ctx, base);
+        return;
+    }
+
     auto pHudPause = (SWA::CHudPause*)g_memory.Translate(ctx.r3.u32);
     auto pInputState = SWA::CInputState::GetInstance();
 
@@ -163,7 +172,7 @@ PPC_FUNC(sub_824B0930)
 
         if (*SWA::SGlobals::ms_IsRenderHud && pHudPause->m_IsShown && !pHudPause->m_Submenu && pHudPause->m_Transition == SWA::eTransitionType_Undefined)
         {
-            ButtonGuide::Open(Button(Localise("Achievements_Name"), EButtonIcon::Back, EButtonAlignment::Left, EFontQuality::Low));
+            ButtonGuide::Open(Button("Achievements_Name", FLT_MAX, EButtonIcon::Back, EButtonAlignment::Left, EFontQuality::Low));
             g_isClosed = false;
         }
         else if (!g_isClosed)

UnleashedRecomp/patches/CTitleStateIntro_patches.cpp

@@ -148,9 +148,10 @@ void PressStartSaveLoadThreadMidAsmHook()
 PPC_FUNC_IMPL(__imp__sub_82587E50);
 PPC_FUNC(sub_82587E50)
 {
-    auto isAutoSaveWarningShown = *(bool*)g_memory.Translate(0x83367BC1);
+    auto pTitleStateIntro = (SWA::CTitleStateIntro*)g_memory.Translate(ctx.r3.u32);
+    auto pTime = (be<float>*)((uint8_t*)pTitleStateIntro->GetContextBase() + 0x10C);
 
-    if (isAutoSaveWarningShown)
+    if (*SWA::SGlobals::ms_IsAutoSaveWarningShown)
     {
         __imp__sub_82587E50(ctx, base);
     }
@@ -158,7 +159,7 @@ PPC_FUNC(sub_82587E50)
     {
         if (auto pInputState = SWA::CInputState::GetInstance())
         {
-            if (pInputState->GetPadState().IsTapped(SWA::eKeyState_B))
+            if (pInputState->GetPadState().IsTapped(SWA::eKeyState_B) && *pTime > 0.5f)
                 g_quitMessageOpen = true;
         }
 

UnleashedRecomp/patches/CTitleStateMenu_patches.cpp

@@ -52,14 +52,14 @@ static bool ProcessInstallMessage()
 PPC_FUNC_IMPL(__imp__sub_825882B8);
 PPC_FUNC(sub_825882B8)
 {
-    auto pTitleState = (SWA::CTitleStateBase*)g_memory.Translate(ctx.r3.u32);
+    auto pTitleStateMenu = (SWA::CTitleStateMenu*)g_memory.Translate(ctx.r3.u32);
     auto pGameDocument = SWA::CGameDocument::GetInstance();
 
     auto pInputState = SWA::CInputState::GetInstance();
     auto& pPadState = pInputState->GetPadState();
     auto isAccepted = pPadState.IsTapped(SWA::eKeyState_A) || pPadState.IsTapped(SWA::eKeyState_Start);
 
-    auto pContext = pTitleState->GetContextBase<SWA::CTitleStateBase::CTitleStateContext>();
+    auto pContext = pTitleStateMenu->GetContextBase<SWA::CTitleStateMenu::CTitleStateMenuContext>();
     auto isNewGameIndex = pContext->m_pTitleMenu->m_CursorIndex == 0;
     auto isOptionsIndex = pContext->m_pTitleMenu->m_CursorIndex == 2;
     auto isInstallIndex = pContext->m_pTitleMenu->m_CursorIndex == 3;

UnleashedRecomp/patches/aspect_ratio_patches.cpp

@@ -8,6 +8,7 @@
 
 #include "aspect_ratio_patches.h"
 #include "camera_patches.h"
+#include "inspire_patches.h"
 
 // These are here for now to not recompile basically all of the project.
 namespace Chao::CSD
@@ -344,6 +345,16 @@ enum
 
     LOADING_BLACK_BAR_MIN = 1 << 17,
     LOADING_BLACK_BAR_MAX = 1 << 18,
+
+    UNSTRETCH_HORIZONTAL = 1 << 19,
+
+    CORNER_EXTRACT = 1 << 20,
+
+    SKIP_INSPIRE = 1 << 21,
+
+    CONTROL_TUTORIAL = 1 << 22,
+
+    LOADING_ARROW = 1 << 23,
 };
 
 struct CsdModifier
@@ -360,10 +371,14 @@ static const xxHashMap<CsdModifier> g_modifiers =
     { HashStr("ui_balloon/window/footer"), { ALIGN_BOTTOM } },
 
     // ui_boss_gauge
-    { HashStr("ui_boss_gauge/gauge_bg"), { ALIGN_TOP_RIGHT | SCALE } },
-    { HashStr("ui_boss_gauge/gauge_2"), { ALIGN_TOP_RIGHT | SCALE } },
-    { HashStr("ui_boss_gauge/gauge_1"), { ALIGN_TOP_RIGHT | SCALE } },
-    { HashStr("ui_boss_gauge/gauge_breakpoint"), { ALIGN_TOP_RIGHT | SCALE } },
+    { HashStr("ui_boss_gauge/gauge_bg"), { ALIGN_TOP_RIGHT | SCALE | SKIP_INSPIRE} },
+    { HashStr("ui_boss_gauge/gauge_2"), { ALIGN_TOP_RIGHT | SCALE | SKIP_INSPIRE} },
+    { HashStr("ui_boss_gauge/gauge_1"), { ALIGN_TOP_RIGHT | SCALE | SKIP_INSPIRE} },
+    { HashStr("ui_boss_gauge/gauge_breakpoint"), { ALIGN_TOP_RIGHT | SCALE | SKIP_INSPIRE} },
+
+    // ui_boss_name
+    { HashStr("ui_boss_name/name_so/bg"), { UNSTRETCH_HORIZONTAL } },
+    { HashStr("ui_boss_name/name_so/pale"), { UNSTRETCH_HORIZONTAL } },
 
     // ui_exstage
     { HashStr("ui_exstage/shield/L_gauge"), { ALIGN_BOTTOM_LEFT | SCALE } },
@@ -372,10 +387,10 @@ static const xxHashMap<CsdModifier> g_modifiers =
     { HashStr("ui_exstage/energy/R_gauge"), { ALIGN_BOTTOM_RIGHT | SCALE } },
     { HashStr("ui_exstage/energy/R_gauge_effect"), { ALIGN_BOTTOM_RIGHT | SCALE } },
     { HashStr("ui_exstage/energy/R_gauge_effect_2"), { ALIGN_BOTTOM_RIGHT | SCALE } },
-    { HashStr("ui_exstage/hit/hit_counter_bg"), { ALIGN_RIGHT | SCALE } },
+    { HashStr("ui_exstage/hit/hit_counter_bg"), { ALIGN_RIGHT | SCALE | OFFSET_SCALE_RIGHT, 986.0f } },
     { HashStr("ui_exstage/hit/hit_counter_bg/C"), { ALIGN_RIGHT | SCALE | EXTEND_RIGHT } },
-    { HashStr("ui_exstage/hit/hit_counter_bg/C/L"), { ALIGN_RIGHT | SCALE } },
-    { HashStr("ui_exstage/hit/hit_counter_bg/C/R"), { SKIP } },
+    { HashStr("ui_exstage/hit/hit_counter_bg/C/L"), { SKIP } }, // L/R are mixed up
+    { HashStr("ui_exstage/hit/hit_counter_bg/C/R"), { ALIGN_RIGHT | SCALE | STORE_LEFT_CORNER } },
     { HashStr("ui_exstage/hit/hit_counter_num"), { ALIGN_RIGHT | SCALE } },
 
     // ui_gate
@@ -392,15 +407,19 @@ static const xxHashMap<CsdModifier> g_modifiers =
 
     // ui_itemresult
     { HashStr("ui_itemresult/footer/result_footer"), { ALIGN_BOTTOM } },
-    { HashStr("ui_itemresult/main/iresult_title"), { ALIGN_TOP } },
     { HashStr("ui_itemresult/main/iresult_title"), { ALIGN_TOP | OFFSET_SCALE_LEFT, 688.0f } },
     { HashStr("ui_itemresult/main/iresult_title/title_bg/center"), { ALIGN_TOP | EXTEND_LEFT } },
     { HashStr("ui_itemresult/main/iresult_title/title_bg/center/h_light"), { ALIGN_TOP | EXTEND_LEFT } },
     { HashStr("ui_itemresult/main/iresult_title/title_bg/right"), { ALIGN_TOP | STORE_RIGHT_CORNER } },
+    { HashStr("ui_itemresult/main/iresult_title/title_brilliance1"), { ALIGN_TOP | STORE_RIGHT_CORNER | OFFSET_SCALE_LEFT, 632.25775f, 1 } },
+    { HashStr("ui_itemresult/main/iresult_title/title_brilliance2"), { ALIGN_TOP | STORE_RIGHT_CORNER | OFFSET_SCALE_LEFT, 830.0f, 2 } },
+    { HashStr("ui_itemresult/main/iresult_title/title_brilliance3"), { ALIGN_TOP | STORE_RIGHT_CORNER | OFFSET_SCALE_LEFT, 640.0f, 3 } },
 
     // ui_loading
     { HashStr("ui_loading/bg_1"), { STRETCH } },
+    { HashStr("ui_loading/bg_1/arrow"), { STRETCH | LOADING_ARROW } },
     { HashStr("ui_loading/bg_2"), { STRETCH } },
+    { HashStr("ui_loading/bg_2/arrow"), { STRETCH | LOADING_ARROW } },
     { HashStr("ui_loading/n_2_d/bg/sky"), { STRETCH } },
     { HashStr("ui_loading/n_2_d/bg/under"), { STRETCH } },
     { HashStr("ui_loading/n_2_d/letterbox/letterbox_under"), { STRETCH } },
@@ -575,9 +594,11 @@ static const xxHashMap<CsdModifier> g_modifiers =
     { HashStr("ui_playscreen_ev_hit/chance_attack"), { ALIGN_RIGHT | SCALE } },
 
     // ui_playscreen_su
-    { HashStr("ui_playscreen_su/su_sonic_gauge"), { ALIGN_BOTTOM_LEFT | SCALE } },
-    { HashStr("ui_playscreen_su/gaia_gauge"), { ALIGN_BOTTOM_LEFT | SCALE } },
-    { HashStr("ui_playscreen_su/footer"), { ALIGN_BOTTOM_RIGHT | SCALE } },
+    { HashStr("ui_playscreen_su/su_sonic_gauge"), { ALIGN_BOTTOM_LEFT | SCALE | OFFSET_SCALE_LEFT, 632.0f } },
+    { HashStr("ui_playscreen_su/su_sonic_gauge/position/C/R"), { ALIGN_BOTTOM_LEFT | SCALE | STORE_RIGHT_CORNER } },
+    { HashStr("ui_playscreen_su/gaia_gauge"), { ALIGN_BOTTOM_LEFT | SCALE | OFFSET_SCALE_LEFT, 632.0f } },
+    { HashStr("ui_playscreen_su/gaia_gauge/position/C/R"), { ALIGN_BOTTOM_LEFT | SCALE | STORE_RIGHT_CORNER } },
+    { HashStr("ui_playscreen_su/footer"), { ALIGN_BOTTOM_RIGHT | SCALE | CONTROL_TUTORIAL } },
 
     // ui_prov_playscreen
     { HashStr("ui_prov_playscreen/so_speed_gauge"), { ALIGN_BOTTOM_LEFT | SCALE | TORNADO_DEFENSE } },
@@ -601,37 +622,43 @@ static const xxHashMap<CsdModifier> g_modifiers =
     { HashStr("ui_result/main/result_title/title_bg/center"), { ALIGN_TOP | EXTEND_LEFT } },
     { HashStr("ui_result/main/result_title/title_bg/center/h_light"), { ALIGN_TOP | EXTEND_LEFT} },
     { HashStr("ui_result/main/result_title/title_bg/right"), { ALIGN_TOP | STORE_RIGHT_CORNER } },
-    { HashStr("ui_result/main/result_num_1"), { OFFSET_SCALE_RIGHT, 669.0f } },
+    { HashStr("ui_result/main/result_num_1"), { CORNER_EXTRACT } },
+    { HashStr("ui_result/main/result_num_1/num_bg"), { OFFSET_SCALE_RIGHT, 669.0f } },
     { HashStr("ui_result/main/result_num_1/num_bg/position_1/center_1"), { EXTEND_RIGHT } },
     { HashStr("ui_result/main/result_num_1/num_bg/position_1/center_1/h_light"), { EXTEND_RIGHT } },
     { HashStr("ui_result/main/result_num_1/num_bg/position_1/center_1/left"), { STORE_LEFT_CORNER } },
     { HashStr("ui_result/main/result_num_1/num_bg/position_1/center_1/right"), { SKIP } },
     { HashStr("ui_result/main/result_num_1/num_bg/position_1/center_1/right/h_light"), { SKIP } },  
-    { HashStr("ui_result/main/result_num_2"), { OFFSET_SCALE_RIGHT, 669.0f } },
+    { HashStr("ui_result/main/result_num_2"), { CORNER_EXTRACT } },
+    { HashStr("ui_result/main/result_num_2/num_bg"), { OFFSET_SCALE_RIGHT, 669.0f } },
     { HashStr("ui_result/main/result_num_2/num_bg/position_2/center_1"), { EXTEND_RIGHT } },
     { HashStr("ui_result/main/result_num_2/num_bg/position_2/center_1/h_light"), { EXTEND_RIGHT } },
     { HashStr("ui_result/main/result_num_2/num_bg/position_2/center_1/left"), { STORE_LEFT_CORNER } },
     { HashStr("ui_result/main/result_num_2/num_bg/position_2/center_1/right"), { SKIP } },
     { HashStr("ui_result/main/result_num_2/num_bg/position_2/center_1/right/h_light"), { SKIP } },   
-    { HashStr("ui_result/main/result_num_3"), { OFFSET_SCALE_RIGHT, 669.0f } },
+    { HashStr("ui_result/main/result_num_3"), { CORNER_EXTRACT } },
+    { HashStr("ui_result/main/result_num_3/num_bg"), { OFFSET_SCALE_RIGHT, 669.0f } },
     { HashStr("ui_result/main/result_num_3/num_bg/position_3/center_1"), { EXTEND_RIGHT } },
     { HashStr("ui_result/main/result_num_3/num_bg/position_3/center_1/h_light"), { EXTEND_RIGHT } },
     { HashStr("ui_result/main/result_num_3/num_bg/position_3/center_1/left"), { STORE_LEFT_CORNER } },
     { HashStr("ui_result/main/result_num_3/num_bg/position_3/center_1/right"), { SKIP } },
     { HashStr("ui_result/main/result_num_3/num_bg/position_3/center_1/right/h_light"), { SKIP } },  
-    { HashStr("ui_result/main/result_num_4"), { OFFSET_SCALE_RIGHT, 669.0f } },
+    { HashStr("ui_result/main/result_num_4"), { CORNER_EXTRACT } },
+    { HashStr("ui_result/main/result_num_4/num_bg"), { OFFSET_SCALE_RIGHT, 669.0f } },
     { HashStr("ui_result/main/result_num_4/num_bg/position_4/center_1"), { EXTEND_RIGHT } },
     { HashStr("ui_result/main/result_num_4/num_bg/position_4/center_1/h_light"), { EXTEND_RIGHT } },
     { HashStr("ui_result/main/result_num_4/num_bg/position_4/center_1/left"), { STORE_LEFT_CORNER } },
     { HashStr("ui_result/main/result_num_4/num_bg/position_4/center_1/right"), { SKIP } },
     { HashStr("ui_result/main/result_num_4/num_bg/position_4/center_1/right/h_light"), { SKIP } },   
-    { HashStr("ui_result/main/result_num_5"), { OFFSET_SCALE_RIGHT, 669.0f } },
+    { HashStr("ui_result/main/result_num_5"), { CORNER_EXTRACT } },
+    { HashStr("ui_result/main/result_num_5/num_bg"), { OFFSET_SCALE_RIGHT, 669.0f } },
     { HashStr("ui_result/main/result_num_5/num_bg/position_5/center_1"), { EXTEND_RIGHT } },
     { HashStr("ui_result/main/result_num_5/num_bg/position_5/center_1/h_light"), { EXTEND_RIGHT } },
     { HashStr("ui_result/main/result_num_5/num_bg/position_5/center_1/left"), { STORE_LEFT_CORNER } },
     { HashStr("ui_result/main/result_num_5/num_bg/position_5/center_1/right"), { SKIP } },
     { HashStr("ui_result/main/result_num_5/num_bg/position_5/center_1/right/h_light"), { SKIP } }, 
-    { HashStr("ui_result/main/result_num_6"), { OFFSET_SCALE_LEFT, 1094.0f } },
+    { HashStr("ui_result/main/result_num_6"), { CORNER_EXTRACT } },
+    { HashStr("ui_result/main/result_num_6/num_bg"), { OFFSET_SCALE_LEFT, 1094.0f } },
     { HashStr("ui_result/main/result_num_6/num_bg/position_6/center"), { EXTEND_LEFT } },
     { HashStr("ui_result/main/result_num_6/num_bg/position_6/center/h_light"), { EXTEND_LEFT } },
     { HashStr("ui_result/main/result_num_6/num_bg/position_6/center/right"), { STORE_RIGHT_CORNER } },
@@ -728,7 +755,7 @@ static const xxHashMap<CsdModifier> g_modifiers =
     { HashStr("ui_townscreen/time_effect"), { ALIGN_TOP_RIGHT | SCALE } },
     { HashStr("ui_townscreen/info"), { ALIGN_TOP_LEFT | SCALE } },
     { HashStr("ui_townscreen/cam"), { ALIGN_TOP_RIGHT | SCALE } },
-    { HashStr("ui_townscreen/footer"), { ALIGN_BOTTOM } },
+    { HashStr("ui_townscreen/footer"), { ALIGN_BOTTOM_RIGHT | SCALE } },
 
     // ui_worldmap
     { HashStr("ui_worldmap/contents/choices/cts_choices_bg"), { STRETCH } },
@@ -828,6 +855,11 @@ PPC_FUNC(sub_830C6A00)
 
     if (g_sceneModifier.has_value())
     {
+        if (!Config::ControlTutorial && (g_sceneModifier->flags & CONTROL_TUTORIAL) != 0)
+        {
+            return;
+        }
+
         // Tornado Defense bugs out when applying gameplay UI scaling.
         // This seems consistent with base game behavior, because the UI
         // is normally squashed, which was probably done to work around this.
@@ -837,7 +869,7 @@ PPC_FUNC(sub_830C6A00)
             g_scenePositionY = 0.0f;
         }
 
-        if ((g_sceneModifier->flags & (OFFSET_SCALE_LEFT | OFFSET_SCALE_RIGHT)) != 0)
+        if (g_aspectRatio > WIDE_ASPECT_RATIO && (g_sceneModifier->flags & (OFFSET_SCALE_LEFT | OFFSET_SCALE_RIGHT | CORNER_EXTRACT)) != 0)
         {
             auto r3 = ctx.r3;
             auto r4 = ctx.r4;
@@ -906,6 +938,12 @@ static void Draw(PPCContext& ctx, uint8_t* base, PPCFunc* original, uint32_t str
         return;
     }
 
+    // That goddamn boss gauge doesn't disappear in the cutscene where Dark Gaia and Chip hug each other
+    if ((modifier.flags & SKIP_INSPIRE) != 0 && !InspirePatches::s_sceneName.empty() && *reinterpret_cast<be<float>*>(base + ctx.r4.u32) >= 1280.0f)
+    {
+        return;
+    }
+
     if (g_cornerExtract)
     {
         if ((modifier.flags & (STORE_LEFT_CORNER | STORE_RIGHT_CORNER)) != 0)
@@ -937,6 +975,22 @@ static void Draw(PPCContext& ctx, uint8_t* base, PPCFunc* original, uint32_t str
             return reinterpret_cast<be<float>*>(stack + index * stride);
         };
 
+    // Subtract half a pixel from loading arrows to prevent transparent pixels surrounding them from leaking into the texture filtering.
+    if (Video::s_viewportHeight > 720 && (modifier.flags & LOADING_ARROW) != 0 && stride == 0x14)
+    {
+        for (size_t i = 0; i < 4; i++)
+        {
+            auto texCoord = getPosition(i) + 4;
+
+            constexpr float OFFSET = 0.5f / 720.0f;
+
+            if (i == 0 || i == 2) // Top
+                *texCoord = (*texCoord + OFFSET);
+            else // Bottom
+                *texCoord = (*texCoord - OFFSET);
+        }
+    }
+
     float offsetX = 0.0f;
     float offsetY = 0.0f;
     float pivotX = 0.0f;
@@ -944,7 +998,9 @@ static void Draw(PPCContext& ctx, uint8_t* base, PPCFunc* original, uint32_t str
     float scaleX = 1.0f;
     float scaleY = 1.0f;
 
-    if (squash || ((modifier.flags & STRETCH_HORIZONTAL) != 0 && g_aspectRatio >= WIDE_ASPECT_RATIO))
+    bool needsStretch = g_aspectRatio >= WIDE_ASPECT_RATIO;
+
+    if (squash || (needsStretch && (modifier.flags & STRETCH_HORIZONTAL) != 0))
     {
         scaleX = Video::s_viewportWidth / 1280.0f;
     }
@@ -952,28 +1008,36 @@ static void Draw(PPCContext& ctx, uint8_t* base, PPCFunc* original, uint32_t str
     {
         scaleX = g_aspectRatioScale;
 
-        if ((modifier.flags & ALIGN_RIGHT) != 0)
-            offsetX = g_aspectRatioOffsetX * 2.0f;
-        else if ((modifier.flags & ALIGN_LEFT) == 0)
-            offsetX = g_aspectRatioOffsetX;
-
-        if ((modifier.flags & SCALE) != 0)
+        if (needsStretch && (modifier.flags & UNSTRETCH_HORIZONTAL) != 0)
         {
-            scaleX *= g_aspectRatioGameplayScale;
-            pivotX = g_scenePositionX;
-
-            if ((modifier.flags & ALIGN_RIGHT) != 0)
-                offsetX += 1280.0f * (1.0f - g_aspectRatioGameplayScale) * g_aspectRatioScale;
-            else if ((modifier.flags & ALIGN_LEFT) == 0)
-                offsetX += 640.0f * (1.0f - g_aspectRatioGameplayScale) * g_aspectRatioScale;
-
-            offsetX += pivotX * g_aspectRatioScale;
+            pivotX = *getPosition(0);
+            offsetX = pivotX * Video::s_viewportWidth / 1280.0f;
         }
-
-        if ((modifier.flags & WORLD_MAP) != 0)
+        else
         {
-            if ((modifier.flags & ALIGN_LEFT) != 0)
-                offsetX += (1.0f - g_aspectRatioNarrowScale) * g_aspectRatioScale * -20.0f;
+            if ((modifier.flags & ALIGN_RIGHT) != 0)
+                offsetX = g_aspectRatioOffsetX * 2.0f;
+            else if ((modifier.flags & ALIGN_LEFT) == 0)
+                offsetX = g_aspectRatioOffsetX;
+
+            if ((modifier.flags & SCALE) != 0)
+            {
+                scaleX *= g_aspectRatioGameplayScale;
+                pivotX = g_scenePositionX;
+
+                if ((modifier.flags & ALIGN_RIGHT) != 0)
+                    offsetX += 1280.0f * (1.0f - g_aspectRatioGameplayScale) * g_aspectRatioScale;
+                else if ((modifier.flags & ALIGN_LEFT) == 0)
+                    offsetX += 640.0f * (1.0f - g_aspectRatioGameplayScale) * g_aspectRatioScale;
+
+                offsetX += pivotX * g_aspectRatioScale;
+            }
+
+            if ((modifier.flags & WORLD_MAP) != 0)
+            {
+                if ((modifier.flags & ALIGN_LEFT) != 0)
+                    offsetX += (1.0f - g_aspectRatioNarrowScale) * g_aspectRatioScale * -20.0f;
+            }
         }
     }
 
@@ -1198,8 +1262,8 @@ PPC_FUNC(sub_830D1EF0)
             y = g_aspectRatioOffsetY + (y + 0.5f) * g_aspectRatioScale;
         }
 
-        vertex[i].x = ((round(x) - 0.5f) / Video::s_viewportWidth) * 2.0f - 1.0f;
-        vertex[i].y = ((round(y) - 0.5f) / Video::s_viewportHeight) * -2.0f + 1.0f;
+        vertex[i].x = ((x - 0.5f) / Video::s_viewportWidth) * 2.0f - 1.0f;
+        vertex[i].y = ((y - 0.5f) / Video::s_viewportHeight) * -2.0f + 1.0f;
     }
 
     bool letterboxTop = PPC_LOAD_U8(r3.u32 + PRIMITIVE_2D_PADDING_OFFSET + 0x1);
@@ -1553,3 +1617,38 @@ PPC_FUNC(sub_82449088)
         }
     }
 }
+
+// The shadow offseting is buggy for FCO text just like Werehog button guide,
+// making them appear thicker than they actually are.
+PPC_FUNC_IMPL(__imp__sub_82E54950);
+PPC_FUNC(sub_82E54950)
+{
+    if (Config::AspectRatio == EAspectRatio::OriginalNarrow)
+    {
+        // Luckily, they have shadow offset scale values that are only used in this function.
+        uint32_t x = PPC_LOAD_U32(0x8332B7B8);
+        uint32_t y = PPC_LOAD_U32(0x8332B7BC);
+
+        PPCRegister scaled;
+
+        // X
+        scaled.u32 = x;
+        scaled.f32 *= 1.5f;
+        PPC_STORE_U32(0x8332B7B8, scaled.u32);
+
+        // Y
+        scaled.u32 = y;
+        scaled.f32 *= 1.5f;
+        PPC_STORE_U32(0x8332B7BC, scaled.u32);
+
+        __imp__sub_82E54950(ctx, base);
+
+        // Restore old values.
+        PPC_STORE_U32(0x8332B7B8, x);
+        PPC_STORE_U32(0x8332B7BC, y);
+    }
+    else
+    {
+        __imp__sub_82E54950(ctx, base);
+    }
+}

UnleashedRecomp/patches/fps_patches.cpp

@@ -28,6 +28,17 @@ void HighFrameRateDeltaTimeFixMidAsmHook(PPCRegister& f1)
         f1.f64 = threshold;
 }
 
+// This hook expects the vector register to store delta time at the first index.
+void HighFrameRateDeltaTimeFixVectorMidAsmHook(PPCVRegister& v62)
+{
+    // Having 60 FPS threshold ensures we still retain
+    // the original game behavior when locked to 30/60 FPS.
+    constexpr double threshold = 1.0 / 60.0;
+
+    if (v62.f32[3] < threshold)
+        v62.f32[3] = threshold;
+}
+
 void CameraDeltaTimeFixMidAsmHook(PPCRegister& dest, PPCRegister& src)
 {
     dest.f64 = src.f64 / 30.0;
@@ -159,3 +170,28 @@ PPC_FUNC(sub_82B00D00)
 
     *pElapsedTime = std::max(*pElapsedTime, 0.0f);
 }
+
+// Fix for Egg Dragoon's drill missile attack rotating 90 degrees at HFR.
+void BossEggDragoonDrillMissileCMissileSetRotationMidAsmHook(PPCRegister& r4)
+{
+    auto pRotation = (Hedgehog::Math::CQuaternion*)g_memory.Translate(r4.u32);
+    auto magnitude = std::sqrt(pRotation->X * pRotation->X + pRotation->Y * pRotation->Y + pRotation->Z * pRotation->Z + pRotation->W * pRotation->W);
+
+    if (magnitude < 0.0f)
+        return;
+
+    auto magnitudeNrm = 1.0f / magnitude;
+
+    pRotation->X = pRotation->X * magnitudeNrm;
+    pRotation->Y = pRotation->Y * magnitudeNrm;
+    pRotation->Z = pRotation->Z * magnitudeNrm;
+    pRotation->W = pRotation->W * magnitudeNrm;
+}
+
+bool SparkleLocusMidAsmHook()
+{
+    // There is an epsilon check in sparkle locus particle code that seems to never pass at high frame rates, which causes vertex corruption.
+    // Checking for equality doesn't fix it either, so we can fix it by forcing it to always execute instead.
+    // This has the side effect of the locus particle eventually snapping to the rest position during pause, but it's better than vertices exploding.
+    return App::s_deltaTime < (1.0 / 60.0);
+}

UnleashedRecomp/patches/frontend_listener.cpp

@@ -11,7 +11,7 @@ static class FrontendListener : public SDLEventListener
 public:
     bool OnSDLEvent(SDL_Event* event) override
     {
-        if (!Config::HUDToggleHotkey || OptionsMenu::s_isVisible)
+        if (!Config::HUDToggleKey || OptionsMenu::s_isVisible)
             return false;
 
         switch (event->type)

UnleashedRecomp/patches/inspire_patches.cpp

@@ -5,8 +5,9 @@
 #include <app.h>
 #include <sdl_events.h>
 
+std::string InspirePatches::s_sceneName;
+
 static SWA::Inspire::CScene* g_pScene;
-static std::string g_sceneName;
 static bool g_isFirstFrameChecked;
 static uint32_t g_eventDispatchCount;
 
@@ -31,6 +32,11 @@ static std::unordered_map<std::string_view, std::pair<float, float>> g_evilSonic
     { "evrt_m8_04", { 0, 2314 } }             // Dark Gaia Appears
 };
 
+// Sonic's mouth EXPLODES for a single frame in Temple Entrance cutscene. 
+// Looks very nasty. Let's hide morph models inbetween certain frames to solve it.
+static bool g_loadedMouthExplosionAnimation;
+static bool g_hideMorphModels;
+
 // SWA::Inspire::CScene
 PPC_FUNC_IMPL(__imp__sub_82B98D80);
 PPC_FUNC(sub_82B98D80)
@@ -49,9 +55,12 @@ PPC_FUNC(sub_82B98D30)
     __imp__sub_82B98D30(ctx, base);
 
     g_pScene = nullptr;
-    g_sceneName.clear();
+    InspirePatches::s_sceneName.clear();
 
     SDL_User_EvilSonic(App::s_isWerehog);
+
+    g_loadedMouthExplosionAnimation = false;
+    g_hideMorphModels = false;
 }
 
 PPC_FUNC_IMPL(__imp__sub_82B9BA98);
@@ -59,11 +68,31 @@ PPC_FUNC(sub_82B9BA98)
 {
     auto sceneName = (Hedgehog::Base::CSharedString*)g_memory.Translate(ctx.r5.u32);
 
-    g_sceneName = sceneName->c_str();
+    InspirePatches::s_sceneName = sceneName->c_str();
 
     __imp__sub_82B9BA98(ctx, base);
 }
 
+void AnimationDataMakeMidAsmHook(PPCRegister& r31, PPCRegister& r29, PPCRegister& r28)
+{
+    uint8_t* base = g_memory.base;
+
+    if (r28.u32 == 0x222E0 &&
+        strcmp(reinterpret_cast<const char*>(base + PPC_LOAD_U32(r31.u32)), "t0_04_SN") == 0 &&
+        XXH3_64bits(base + r29.u32, r28.u32) == 0xEC634F0F379F478A)
+    {
+        g_loadedMouthExplosionAnimation = true;
+    }
+}
+
+// Hedgehog::Mirage::CSingleMorphElement::Render
+PPC_FUNC_IMPL(__imp__sub_82E32048);
+PPC_FUNC(sub_82E32048)
+{
+    if (!g_hideMorphModels)
+        __imp__sub_82E32048(ctx, base);
+}
+
 void InspirePatches::DrawDebug()
 {
     if (!g_pScene)
@@ -72,7 +101,7 @@ void InspirePatches::DrawDebug()
         return;
     }
 
-    ImGui::Text("Name: %s", g_sceneName.c_str());
+    ImGui::Text("Name: %s", InspirePatches::s_sceneName.c_str());
     ImGui::Text("Frame: %f", g_pScene->m_pData->Frame.get());
     ImGui::Text("Cut: %d", g_pScene->m_pData->Cut.get());
 
@@ -97,17 +126,20 @@ void InspirePatches::DrawDebug()
 
 void InspirePatches::Update()
 {
-    if (!g_pScene || !g_sceneName.size())
+    if (!g_pScene || !InspirePatches::s_sceneName.size())
         return;
 
-    if (!g_isFirstFrameChecked && std::find(g_alwaysEvilSonic.begin(), g_alwaysEvilSonic.end(), g_sceneName) != g_alwaysEvilSonic.end())
+    g_hideMorphModels = g_loadedMouthExplosionAnimation && g_pScene->m_pData->Frame >= 185.0f &&
+        g_pScene->m_pData->Frame < 195.0f && InspirePatches::s_sceneName == "evrt_t0_04";
+
+    if (!g_isFirstFrameChecked && std::find(g_alwaysEvilSonic.begin(), g_alwaysEvilSonic.end(), InspirePatches::s_sceneName) != g_alwaysEvilSonic.end())
     {
         SDL_User_EvilSonic(true);
         g_isFirstFrameChecked = true;
         return;
     }
 
-    auto findResult = g_evilSonicTimings.find(g_sceneName);
+    auto findResult = g_evilSonicTimings.find(InspirePatches::s_sceneName);
 
     if (findResult != g_evilSonicTimings.end())
     {

UnleashedRecomp/patches/inspire_patches.h

@@ -3,6 +3,8 @@
 class InspirePatches
 {
 public:
+    static std::string s_sceneName;
+
     static void DrawDebug();
     static void Update();
 };

UnleashedRecomp/patches/misc_patches.cpp

@@ -13,6 +13,17 @@ bool DisableHintsMidAsmHook()
     return !Config::Hints;
 }
 
+// Disable Perfect Dark Gaia hints.
+PPC_FUNC_IMPL(__imp__sub_82AC36E0);
+PPC_FUNC(sub_82AC36E0)
+{
+    auto pPerfectDarkGaiaChipHintName = (xpointer<char>*)g_memory.Translate(0x8338EF10);
+
+    strcpy(pPerfectDarkGaiaChipHintName->get(), Config::Hints ? "V_CHP_067\0" : "end\0");
+
+    __imp__sub_82AC36E0(ctx, base);
+}
+
 bool DisableControlTutorialMidAsmHook()
 {
     return !Config::ControlTutorial;
@@ -32,13 +43,6 @@ bool DisableDLCIconMidAsmHook()
     return Config::DisableDLCIcon;
 }
 
-void ToggleSubtitlesMidAsmHook(PPCRegister& r27)
-{
-    auto pApplicationDocument = (SWA::CApplicationDocument*)g_memory.Translate(r27.u32);
-
-    pApplicationDocument->m_InspireSubtitles = Config::Subtitles;
-}
-
 void WerehogBattleMusicMidAsmHook(PPCRegister& r11)
 {
     if (Config::BattleTheme)

UnleashedRecomp/patches/object_patches.cpp

@@ -1,8 +1,9 @@
+#include <api/SWA.h>
 #include <user/config.h>
-#include <SWA/CharacterUtility/CharacterProxy.h>
 #include <hid/hid.h>
+#include <app.h>
 
-// CObjFlame::CObjFlame
+// SWA::CObjFlame::CObjFlame
 // A field is not zero initialized,
 // causing collisions to constantly get created
 // and slow down the game.
@@ -28,7 +29,7 @@ void ObjBigBarrelAllocMidAsmHook(PPCRegister& r3)
     r3.u32 += sizeof(ObjBigBarrelEx);
 }
 
-// CObjBigBarrel::CObjBigBarrel
+// SWA::CObjBigBarrel::CObjBigBarrel
 PPC_FUNC_IMPL(__imp__sub_8271AC08);
 PPC_FUNC(sub_8271AC08)
 {
@@ -69,10 +70,9 @@ void ObjBigBarrelSetPositionMidAsmHook(PPCRegister& r3, PPCRegister& r4)
     }
 }
 
+// SWA::CExBullet::AddCallback
 // Tornado Defense bullet particles are colored by the button prompt, which differs on PlayStation 3.
 // Luckily, the PS3 particles are left in the files, and they get spawned by name when a bullet gets created.
-
-// SWA::CExBullet::AddCallback
 PPC_FUNC_IMPL(__imp__sub_82B14CC0);
 PPC_FUNC(sub_82B14CC0)
 {
@@ -98,3 +98,38 @@ PPC_FUNC(sub_82B14CC0)
 
     __imp__sub_82B14CC0(ctx, base);
 }
+
+// CObjGrindDashPanel is particularly egregious when it comes to overlapping sounds at HFR
+// due to the character proxy sending the hit message multiple times in a frame. This is a
+// quick workaround to limit the message process function to occur at a 30 FPS time step.
+static constexpr size_t OBJ_GRIND_DASH_PANEL_SIZE = 0x160;
+
+void ObjGrindDashPanelAllocMidAsmHook(PPCRegister& r3)
+{
+    r3.u32 += sizeof(double);
+}
+
+// SWA::CObjGrindDashPanel::CObjGrindDashPanel
+PPC_FUNC_IMPL(__imp__sub_82614228);
+PPC_FUNC(sub_82614228)
+{
+    *reinterpret_cast<double*>(base + ctx.r3.u32 + OBJ_GRIND_DASH_PANEL_SIZE) = 0.0;
+    __imp__sub_82614228(ctx, base);
+}
+
+// SWA::CObjGrindDashPanel::MsgHitEventCollision::Impl
+PPC_FUNC_IMPL(__imp__sub_826145D8);
+PPC_FUNC(sub_826145D8)
+{
+    constexpr double REFERENCE_DELTA_TIME = 1.0 / 30.0;
+    constexpr double DELTA_TIME_TOLERANCE = 0.0001;
+
+    auto lastHitTime = reinterpret_cast<double*>(base + ctx.r3.u32 + OBJ_GRIND_DASH_PANEL_SIZE);
+    auto deltaTime = App::s_time - *lastHitTime;
+
+    if ((deltaTime + DELTA_TIME_TOLERANCE) > REFERENCE_DELTA_TIME)
+    {
+        __imp__sub_826145D8(ctx, base);
+        *lastHitTime = App::s_time;
+    }
+}

UnleashedRecomp/patches/player_patches.cpp

@@ -97,7 +97,7 @@ void PostUnleashMidAsmHook(PPCRegister& r30)
 
 void SetXButtonHomingMidAsmHook(PPCRegister& r30)
 {
-    r30.u32 = Config::HomingAttackOnBoost;
+    r30.u32 = !Config::HomingAttackOnJump;
 }
 
 // SWA::Player::CEvilSonicContext

UnleashedRecomp/patches/resident_patches.cpp

@@ -15,25 +15,31 @@ PPC_FUNC(sub_824DCF38)
 
     App::s_isLoading = true;
 
-    if (Config::TimeOfDayTransition == ETimeOfDayTransition::PlayStation)
+    if (ctx.r4.u32 == SWA::eLoadingDisplayType_WerehogMovie)
     {
-        if (ctx.r4.u32 == SWA::eLoadingDisplayType_WerehogMovie)
+        if (Config::TimeOfDayTransition == ETimeOfDayTransition::PlayStation)
         {
             ctx.r4.u32 = SWA::eLoadingDisplayType_ChangeTimeOfDay;
             pLoading->m_IsNightToDay = App::s_isWerehog;
         }
+
+        if (Config::UseArrowsForTimeOfDayTransition)
+            ctx.r4.u32 = SWA::eLoadingDisplayType_Arrows;
     }
 
-    if (auto pGameDocument = SWA::CGameDocument::GetInstance())
+    if (Config::FixEggmanlandUsingEventGalleryTransition)
     {
-        auto stageName = pGameDocument->m_pMember->m_StageName.c_str();
-
-        if (stageName && strlen(stageName))
+        if (auto pGameDocument = SWA::CGameDocument::GetInstance())
         {
-            /* Fix restarting Eggmanland as the Werehog
-               erroneously using the Event Gallery transition. */
-            if (ctx.r4.u32 == SWA::eLoadingDisplayType_EventGallery && !strcmp(stageName, "Act_EggmanLand"))
-                ctx.r4.u32 = SWA::eLoadingDisplayType_NowLoading;
+            auto stageName = pGameDocument->m_pMember->m_StageName.c_str();
+
+            if (stageName && strlen(stageName))
+            {
+                /* Fix restarting Eggmanland as the Werehog
+                   erroneously using the Event Gallery transition. */
+                if (ctx.r4.u32 == SWA::eLoadingDisplayType_EventGallery && !strcmp(stageName, "Act_EggmanLand"))
+                    ctx.r4.u32 = SWA::eLoadingDisplayType_NowLoading;
+            }
         }
     }
 

UnleashedRecomp/patches/video_patches.cpp

@@ -76,8 +76,12 @@ PPC_FUNC(sub_830D25D8)
     auto device = reinterpret_cast<GuestDevice*>(base + PPC_LOAD_U32(ctx.r4.u32));
 
     // Set first sampler to use linear filtering.
-    device->samplerStates[0].data[3] = (device->samplerStates[0].data[3].get() & ~0x1f80000) | 0x1280000;
-    device->dirtyFlags[3] = device->dirtyFlags[3].get() | 0x80000000ull;
+    // NOTE: We only check for height here since all 2D primitives get centered.
+    if (Video::s_viewportHeight > 720)
+    {
+        device->samplerStates[0].data[3] = (device->samplerStates[0].data[3].get() & ~0x1f80000) | 0x1280000;
+        device->dirtyFlags[3] = device->dirtyFlags[3].get() | 0x80000000ull;
+    }
 
     __imp__sub_830D25D8(ctx, base);
 }
@@ -113,3 +117,27 @@ PPC_FUNC(sub_8260BBF8)
     SetDefaultMaterialParameters(reinterpret_cast<GuestDevice*>(base + PPC_LOAD_U32(PPC_LOAD_U32(ctx.r4.u32))));
     __imp__sub_8260BBF8(ctx, base);
 }
+
+// The pedestal in Gaia Temple is placed on an opaque mesh slot, despite using additive blending.
+// This somehow works. Except when the delta time is too stable, it flashes black for one frame.
+// We can fix it by detecting the asset runtime, and swapping the mesh slots to transparent by hand.
+
+// Hedgehog::Mirage::CModelData::Make
+PPC_FUNC_IMPL(__imp__sub_82E38650);
+PPC_FUNC(sub_82E38650)
+{
+    if (ctx.r5.u32 == 0xBB90 && XXH3_64bits(base + ctx.r4.u32, ctx.r5.u32) == 0xB524C8C3B80C3F54)
+    {
+        // Mesh Count
+        std::swap(
+            *reinterpret_cast<uint32_t*>(base + ctx.r4.u32 + 0x18),
+            *reinterpret_cast<uint32_t*>(base + ctx.r4.u32 + 0x20));
+
+        // Mesh Offset
+        std::swap(
+            *reinterpret_cast<uint32_t*>(base + ctx.r4.u32 + 0x1C),
+            *reinterpret_cast<uint32_t*>(base + ctx.r4.u32 + 0x24));
+    }
+
+    __imp__sub_82E38650(ctx, base);
+}

UnleashedRecomp/res/credits.h

@@ -1,6 +1,6 @@
 #pragma once
 
-inline std::array<const char*, 14> g_credits =
+inline std::array<const char*, 17> g_credits =
 {
     "Skyth",
     "Hyper",
@@ -15,5 +15,8 @@ inline std::array<const char*, 14> g_credits =
     "LadyLunanova",
     "LJSTAR",
     "Goalringmod27",
-    "M&M"
+    "M&M",
+    "DaGuAr",
+    "brianuuuSonic",
+    "Kitzuku"
 };

UnleashedRecomp/res/version.txt

@@ -1,4 +1,4 @@
-VERSION_MILESTONE="Beta 2"
+VERSION_MILESTONE="Release Candidate 1"
 VERSION_MAJOR=1
 VERSION_MINOR=0
 VERSION_REVISION=0

UnleashedRecomp/ui/achievement_menu.cpp

@@ -48,13 +48,11 @@ static std::unique_ptr<GuestTexture> g_upTrophyIcon;
 static int g_firstVisibleRowIndex;
 static int g_selectedRowIndex;
 static double g_rowSelectionTime;
+static double g_lastTappedTime;
+static double g_lastIncrementTime;
 
 static bool g_upWasHeld;
 static bool g_downWasHeld;
-static bool g_leftWasHeld;
-static bool g_rightWasHeld;
-static bool g_upRSWasHeld;
-static bool g_downRSWasHeld;
 
 static void ResetSelection()
 {
@@ -67,7 +65,7 @@ static void ResetSelection()
 
 static void DrawContainer(ImVec2 min, ImVec2 max, ImU32 gradientTop, ImU32 gradientBottom, float alpha = 1, float cornerRadius = 25)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     DrawPauseContainer(min, max, alpha);
 
@@ -76,8 +74,9 @@ static void DrawContainer(ImVec2 min, ImVec2 max, ImU32 gradientTop, ImU32 gradi
 
 static void DrawHeaderContainer(const char* text)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto fontSize = Scale(24);
+    auto minTextSize = Scale(294.575989);
     auto textSize = g_fntNewRodinUB->CalcTextSizeA(fontSize, FLT_MAX, 0, text);
     auto cornerRadius = 23;
     auto textMarginX = Scale(16) + (Scale(cornerRadius) / 2);
@@ -101,13 +100,12 @@ static void DrawHeaderContainer(const char* text)
         : Lerp(0, 1, colourMotion);
 
     ImVec2 min = { g_aspectRatioOffsetX + Scale(containerMarginX), g_aspectRatioOffsetY + Scale(136) };
-    ImVec2 max = { min.x + textMarginX * 2 + textSize.x + Scale(5), g_aspectRatioOffsetY + Scale(196) };
+    ImVec2 max = { std::max(min.x + minTextSize, min.x + textMarginX * 2 + textSize.x + Scale(5)), g_aspectRatioOffsetY + Scale(196) };
 
     DrawPauseHeaderContainer(min, max, alpha);
 
     SetTextSkew((min.y + max.y) / 2.0f, Scale(3.0f));
 
-    // TODO: Apply bevel.
     DrawTextWithOutline
     (
         g_fntNewRodinUB,
@@ -124,7 +122,7 @@ static void DrawHeaderContainer(const char* text)
 
 static void DrawAchievement(int rowIndex, float yOffset, Achievement& achievement, bool isUnlocked)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     auto clipRectMin = drawList->GetClipRectMin();
     auto clipRectMax = drawList->GetClipRectMax();
@@ -339,7 +337,7 @@ static void DrawAchievement(int rowIndex, float yOffset, Achievement& achievemen
 
 static void DrawTrophySparkles(ImVec2 min, ImVec2 max, int recordCount, int trophyFrameIndex)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     constexpr auto recordsHalfTotal = ACH_RECORDS / 2;
 
@@ -427,7 +425,7 @@ static void DrawTrophySparkles(ImVec2 min, ImVec2 max, int recordCount, int trop
 
 static void DrawAchievementTotal(ImVec2 min, ImVec2 max)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     // Transparency fade animation.
     auto alpha = Cubic(0, 1, ComputeMotion(g_appearTime, COUNTER_INTRO_FADE_START, COUNTER_INTRO_FADE_END));
@@ -511,7 +509,7 @@ static void DrawAchievementTotal(ImVec2 min, ImVec2 max)
 
 static void DrawContentContainer()
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     // Expand/retract animation.
     auto motion = g_isClosing
@@ -566,15 +564,12 @@ static void DrawContentContainer()
     // Draw separators.
     for (int i = 1; i <= 3; i++)
     {
-        auto lineMarginLeft = Scale(35);
-        auto lineMarginRight = Scale(55);
-        auto lineMarginY = Scale(2);
+        ImVec2 lineMin = { clipRectMin.x + Scale(35), clipRectMin.y + itemHeight * i + Scale(2) };
+        ImVec2 lineMax = { clipRectMax.x - Scale(55), lineMin.y + Scale(1.3f) };
 
-        ImVec2 lineMin = { clipRectMin.x + lineMarginLeft, clipRectMin.y + itemHeight * i + lineMarginY };
-        ImVec2 lineMax = { clipRectMax.x - lineMarginRight, clipRectMin.y + itemHeight * i + lineMarginY };
-
-        drawList->AddLine(lineMin, lineMax, IM_COL32(163, 163, 163, 255));
-        drawList->AddLine({ lineMin.x, lineMin.y + Scale(1) }, { lineMax.x, lineMax.y + Scale(1) }, IM_COL32(143, 148, 143, 255));
+        SetAdditive(true);
+        drawList->AddRectFilled(lineMin, lineMax, IM_COL32(160, 160, 160, 60));
+        SetAdditive(false);
     }
 
     for (auto& tpl : g_achievements)
@@ -601,26 +596,41 @@ static void DrawContentContainer()
     bool downIsHeld = inputState->GetPadState().IsDown(SWA::eKeyState_DpadDown) ||
         inputState->GetPadState().LeftStickVertical < -0.5f;
 
-    bool leftIsHeld = inputState->GetPadState().IsDown(SWA::eKeyState_DpadLeft) ||
-        inputState->GetPadState().LeftStickHorizontal < -0.5f;
-
-    bool rightIsHeld = inputState->GetPadState().IsDown(SWA::eKeyState_DpadRight) ||
-        inputState->GetPadState().LeftStickHorizontal > 0.5f;
-
-    bool upRSIsHeld = inputState->GetPadState().RightStickVertical > 0.5f;
-    bool downRSIsHeld = inputState->GetPadState().RightStickVertical < -0.5f;
-
     bool isReachedTop = g_selectedRowIndex == 0;
     bool isReachedBottom = g_selectedRowIndex == rowCount - 1;
 
     bool scrollUp = !g_upWasHeld && upIsHeld;
     bool scrollDown = !g_downWasHeld && downIsHeld;
-    bool scrollPageUp = !g_leftWasHeld && leftIsHeld && !isReachedTop;
-    bool scrollPageDown = !g_rightWasHeld && rightIsHeld && !isReachedBottom;
-    bool jumpToTop = !g_upRSWasHeld && upRSIsHeld && !isReachedTop;
-    bool jumpToBottom = !g_downRSWasHeld && downRSIsHeld && !isReachedBottom;
 
-    int prevSelectedRowIndex = g_selectedRowIndex;
+    auto time = ImGui::GetTime();
+    auto fastScroll = (time - g_lastTappedTime) > 0.6;
+    auto fastScrollSpeed = 1.0 / 3.5;
+    static auto fastScrollSpeedUp = false;
+
+    if (scrollUp || scrollDown)
+        g_lastTappedTime = time;
+
+    if (!upIsHeld && !downIsHeld)
+        fastScrollSpeedUp = false;
+
+    if (fastScrollSpeedUp)
+        fastScrollSpeed /= 2;
+
+    if (fastScroll)
+    {
+        if ((time - g_lastIncrementTime) < fastScrollSpeed)
+        {
+            fastScroll = false;
+        }
+        else
+        {
+            g_lastIncrementTime = time;
+
+            scrollUp = upIsHeld;
+            scrollDown = downIsHeld;
+            fastScrollSpeedUp = true;
+        }
+    }
 
     if (scrollUp)
     {
@@ -634,40 +644,15 @@ static void DrawContentContainer()
         if (g_selectedRowIndex >= rowCount)
             g_selectedRowIndex = 0;
     }
-    else if (scrollPageUp)
-    {
-        g_selectedRowIndex -= 3;
-        if (g_selectedRowIndex < 0)
-            g_selectedRowIndex = 0;
-    }
-    else if (scrollPageDown)
-    {
-        g_selectedRowIndex += 3;
-        if (g_selectedRowIndex >= rowCount)
-            g_selectedRowIndex = rowCount - 1;
-    }
-    else if (jumpToTop)
-    {
-        g_selectedRowIndex = 0;
-    }
-    else if (jumpToBottom)
-    {
-        g_selectedRowIndex = rowCount - 1;
-    }
 
-    // lol
-    if (scrollUp || scrollDown || scrollPageUp || scrollPageDown || jumpToTop || jumpToBottom)
+    if (scrollUp || scrollDown)
     {
-        g_rowSelectionTime = ImGui::GetTime();
+        g_rowSelectionTime = time;
         Game_PlaySound("sys_actstg_pausecursor");
     }
 
     g_upWasHeld = upIsHeld;
     g_downWasHeld = downIsHeld;
-    g_leftWasHeld = leftIsHeld;
-    g_rightWasHeld = rightIsHeld;
-    g_upRSWasHeld = upRSIsHeld;
-    g_downRSWasHeld = downRSIsHeld;
 
     int visibleRowCount = int(floor((clipRectMax.y - clipRectMin.y) / itemHeight));
 
@@ -778,12 +763,12 @@ void AchievementMenu::Open()
         return std::get<1>(a) > std::get<1>(b);
     });
 
-    ButtonGuide::Open(Button(Localise("Common_Back"), EButtonIcon::B));
+    ButtonGuide::Open(Button("Common_Back", FLT_MAX, EButtonIcon::B, EFontQuality::Low));
 
     ResetSelection();
     Game_PlaySound("sys_actstg_pausewinopen");
 
-    hid::SetProhibitedButtons(XAMINPUT_GAMEPAD_START);
+    hid::SetProhibitedInputs(XAMINPUT_GAMEPAD_START);
 }
 
 void AchievementMenu::Close()
@@ -793,7 +778,7 @@ void AchievementMenu::Close()
         g_appearTime = ImGui::GetTime();
         g_isClosing = true;
 
-        hid::SetProhibitedButtons(0);
+        hid::SetProhibitedInputs();
     }
 
     ButtonGuide::Close();

UnleashedRecomp/ui/achievement_overlay.cpp

@@ -10,6 +10,7 @@
 #include <app.h>
 #include <exports.h>
 #include <decompressor.h>
+#include <patches/inspire_patches.h>
 
 constexpr double OVERLAY_CONTAINER_COMMON_MOTION_START = 0;
 constexpr double OVERLAY_CONTAINER_COMMON_MOTION_END = 11;
@@ -30,7 +31,7 @@ static ImFont* g_fntSeurat;
 
 static bool DrawContainer(ImVec2 min, ImVec2 max, float cornerRadius = 25)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     // Expand/retract animation.
     auto containerMotion = ComputeMotion(g_appearTime, OVERLAY_CONTAINER_COMMON_MOTION_START, OVERLAY_CONTAINER_COMMON_MOTION_END);
@@ -80,15 +81,68 @@ void AchievementOverlay::Init()
     g_fntSeurat = ImFontAtlasSnapshot::GetFont("FOT-SeuratPro-M.otf");
 }
 
+// Dequeue achievements only when we can actually play sounds.
+// Loading thread does not update this object.
+static bool g_soundAdministratorUpdated;
+
+PPC_FUNC_IMPL(__imp__sub_82B43480);
+PPC_FUNC(sub_82B43480)
+{
+    g_soundAdministratorUpdated = true;
+    __imp__sub_82B43480(ctx, base);
+}
+
+// Dequeue achievements only in the main thread. This is also extra thread safety.
+static std::thread::id g_mainThreadId = std::this_thread::get_id();
+
+static bool CanDequeueAchievement()
+{
+    if (g_soundAdministratorUpdated && std::this_thread::get_id() == g_mainThreadId && !AchievementOverlay::s_queue.empty())
+    {
+        // Check if we can actually play any audio right now. If not, we'll wait until we can.
+        uint32_t audioCenter = *reinterpret_cast<be<uint32_t>*>(g_memory.Translate(0x83362FFC));
+        if (audioCenter != NULL)
+        {
+            uint32_t member = *reinterpret_cast<be<uint32_t>*>(g_memory.Translate(audioCenter + 0x4));
+            uint32_t category = !InspirePatches::s_sceneName.empty() ? 10 : 7; // EVENT category is used during Inspire cutscenes.
+
+            // Check if the volume is non zero.
+            return *reinterpret_cast<uint32_t*>(g_memory.Translate(member + 0x7C + category * 0x10 + 0x8)) != 0;
+        }
+    }
+
+    return false;
+}
+
 void AchievementOverlay::Draw()
 {
+    if (!AchievementOverlay::s_isVisible && CanDequeueAchievement())
+    {
+        s_isVisible = true;
+        g_isClosing = false;
+        g_appearTime = ImGui::GetTime();
+        g_achievement = g_xdbfWrapper.GetAchievement((EXDBFLanguage)Config::Language.Value, s_queue.front());
+        s_queue.pop();
+        
+        if (Config::Language == ELanguage::English)
+            g_achievement.Name = xdbf::FixInvalidSequences(g_achievement.Name);
+        
+        Game_PlaySound("obj_navi_appear");
+    }
+
     if (!s_isVisible)
+    {
+        g_soundAdministratorUpdated = false;
         return;
+    }
     
     if (ImGui::GetTime() - g_appearTime >= OVERLAY_DURATION)
         AchievementOverlay::Close();
 
-    auto drawList = ImGui::GetForegroundDrawList();
+    // Close function can use this bool so reset it after.
+    g_soundAdministratorUpdated = false;
+
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto& res = ImGui::GetIO().DisplaySize;
 
     auto strAchievementUnlocked = Localise("Achievements_Unlock").c_str();
@@ -129,6 +183,9 @@ void AchievementOverlay::Draw()
                 IM_COL32(255, 255, 255, 255)                                                            // col
             );
 
+            // Use low quality text.
+            SetShaderModifier(IMGUI_SHADER_MODIFIER_LOW_QUALITY_TEXT);
+
             // Draw header text.
             DrawTextWithShadow
             (
@@ -154,6 +211,9 @@ void AchievementOverlay::Draw()
                 1.0f,                                                                                                              // radius
                 IM_COL32(0, 0, 0, 255)                                                                                             // shadowColour
             );
+
+            // Reset low quality text shader modifier.
+            SetShaderModifier(IMGUI_SHADER_MODIFIER_NONE);
         }
         else
         {
@@ -167,21 +227,7 @@ void AchievementOverlay::Draw()
 
 void AchievementOverlay::Open(int id)
 {
-    if (s_isVisible && !g_isClosing)
-    {
-        s_queue.emplace(id);
-        return;
-    }
-
-    s_isVisible = true;
-    g_isClosing = false;
-    g_appearTime = ImGui::GetTime();
-    g_achievement = g_xdbfWrapper.GetAchievement((EXDBFLanguage)Config::Language.Value, id);
-
-    if (Config::Language == ELanguage::English)
-        g_achievement.Name = xdbf::FixInvalidSequences(g_achievement.Name);
-
-    Game_PlaySound("obj_navi_appear");
+    s_queue.push(id);
 }
 
 void AchievementOverlay::Close()
@@ -192,10 +238,6 @@ void AchievementOverlay::Close()
         g_isClosing = true;
     }
 
-    if (s_queue.size())
-    {
+    if (CanDequeueAchievement())
         s_isVisible = false;
-        AchievementOverlay::Open(s_queue.front());
-        s_queue.pop();
-    }
 }

UnleashedRecomp/ui/button_guide.cpp

@@ -14,7 +14,6 @@
 constexpr float DEFAULT_SIDE_MARGINS = 379;
 
 ImFont* g_fntNewRodin;
-ImFont* g_fntNewRodinLQ;
 
 std::unique_ptr<GuestTexture> g_upControllerIcons;
 std::unique_ptr<GuestTexture> g_upKBMIcons;
@@ -144,79 +143,74 @@ std::tuple<std::tuple<ImVec2, ImVec2>, GuestTexture*> GetButtonIcon(EButtonIcon
     return std::make_tuple(btn, texture);
 }
 
-ImFont* GetFont(EFontQuality fontQuality)
-{
-    return fontQuality == EFontQuality::Low
-        ? g_fntNewRodinLQ
-        : g_fntNewRodin;
-}
-
 static void DrawGuide(float* offset, ImVec2 regionMin, ImVec2 regionMax, EButtonIcon icon,
     EButtonAlignment alignment, ImVec2 iconMin, ImVec2 iconMax, EFontQuality fontQuality,
-    ImVec2 textSize, float fontSize, const char* text)
+    float textWidth, float maxTextWidth, float textScale, float fontSize, const char* text)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
-    auto _icon = icon;
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto iconWidth = Scale(g_iconWidths[icon]);
-    auto dualIconMarginX = Scale(25);
+    auto textMarginY = regionMin.y + Scale(9.0f);
 
-    if (icon == EButtonIcon::LBRB)
-    {
-        _icon = EButtonIcon::LB;
-    }
-    else if (icon == EButtonIcon::LTRT)
-    {
-        _icon = EButtonIcon::LT;
-    }
-    else
-    {
-        dualIconMarginX = 0;
-    }
+    ImVec2 textPos;
 
     if (icon == EButtonIcon::LBRB || icon == EButtonIcon::LTRT)
     {
-        iconMin = alignment == EButtonAlignment::Left
-            ? ImVec2(/* X */ regionMin.x + *offset - dualIconMarginX * 3, /* Y */ iconMin.y)
-            : ImVec2(/* X */ regionMax.x - *offset - textSize.x - iconWidth, /* Y */ iconMin.y);
+        auto iconMarginX = Scale(16);
 
-        iconMax = alignment == EButtonAlignment::Left
-            ? ImVec2(iconMin.x + iconWidth, iconMax.y)
-            : ImVec2(iconMin.x, iconMax.y);
-    }
+        iconMin.x = alignment == EButtonAlignment::Left
+            ? regionMin.x + *offset - maxTextWidth + (iconWidth / 2)
+            : regionMax.x - *offset - maxTextWidth - (iconWidth / 2) - iconMarginX;
 
-    auto btnIcon = GetButtonIcon(_icon);
-    drawList->AddImage(std::get<1>(btnIcon), iconMin, iconMax, GET_UV_COORDS(std::get<0>(btnIcon)));
+        iconMax.x = iconMin.x + iconWidth;
 
-    auto font = GetFont(fontQuality);
-
-    auto textMarginX = alignment == EButtonAlignment::Left
-        ? regionMin.x + *offset + dualIconMarginX
-        : regionMax.x - *offset - dualIconMarginX * 2;
-
-    auto textMarginY = regionMin.y + Scale(8);
-
-    ImVec2 textPosition = { textMarginX, textMarginY };
-
-    DrawTextWithOutline(font, fontSize, textPosition, IM_COL32_WHITE, text, 4, IM_COL32_BLACK);
-
-    // Add extra luminance to low quality text.
-    if (fontQuality == EFontQuality::Low)
-        drawList->AddText(font, fontSize, textPosition, IM_COL32(255, 255, 255, 127), text);
-
-    if (icon == EButtonIcon::LBRB || icon == EButtonIcon::LTRT)
-    {
-        auto btnIcon = GetButtonIcon(icon == EButtonIcon::LBRB ? EButtonIcon::RB : EButtonIcon::RT);
+        // Left button.
+        auto btnIcon = GetButtonIcon(icon == EButtonIcon::LBRB ? EButtonIcon::LB : EButtonIcon::LT);
+        drawList->AddImage(std::get<1>(btnIcon), iconMin, iconMax, GET_UV_COORDS(std::get<0>(btnIcon)));
 
         auto dualIconMin = alignment == EButtonAlignment::Left
-            ? ImVec2(/* X */ regionMin.x + *offset + textSize.x + dualIconMarginX * 2, /* Y */ iconMin.y)
-            : ImVec2(/* X */ regionMax.x - *offset + textSize.x - dualIconMarginX, /* Y */ iconMin.y);
+            ? ImVec2(iconMax.x + maxTextWidth + iconMarginX, iconMin.y)
+            : ImVec2(regionMax.x - *offset + maxTextWidth - iconWidth, iconMin.y);
 
         auto dualIconMax = ImVec2(dualIconMin.x + iconWidth, iconMax.y);
 
+        // Right button.
+        btnIcon = GetButtonIcon(icon == EButtonIcon::LBRB ? EButtonIcon::RB : EButtonIcon::RT);
         drawList->AddImage(std::get<1>(btnIcon), dualIconMin, dualIconMax, GET_UV_COORDS(std::get<0>(btnIcon)));
 
-        *offset += dualIconMarginX + iconWidth;
+        textPos = { (iconMax.x + ((dualIconMin.x - iconMax.x) - maxTextWidth + std::max(0.0f, maxTextWidth - textWidth)) / 2) + Scale(2), textMarginY};
+
+        *offset += iconWidth;
     }
+    else
+    {
+        auto btnIcon = GetButtonIcon(icon);
+
+        drawList->AddImage(std::get<1>(btnIcon), iconMin, iconMax, GET_UV_COORDS(std::get<0>(btnIcon)));
+
+        auto textMarginX = alignment == EButtonAlignment::Left
+            ? regionMin.x + *offset
+            : regionMax.x - *offset;
+
+        textPos = { textMarginX, textMarginY };
+    }
+
+    SetScale({ textScale, 1.0f });
+    SetOrigin(textPos);
+
+    if (fontQuality == EFontQuality::Low)
+        SetShaderModifier(IMGUI_SHADER_MODIFIER_LOW_QUALITY_TEXT);
+
+    DrawTextWithOutline(g_fntNewRodin, fontSize, textPos, IM_COL32_WHITE, text, 4, IM_COL32_BLACK);
+
+    if (fontQuality == EFontQuality::Low)
+    {
+        // Add extra luminance to low quality text.
+        drawList->AddText(g_fntNewRodin, fontSize, textPos, IM_COL32(255, 255, 255, 127), text);
+        SetShaderModifier(IMGUI_SHADER_MODIFIER_NONE);
+    }
+
+    SetScale({ 1.0f, 1.0f });
+    SetOrigin({ 0.0f, 0.0f });
 }
 
 void ButtonGuide::Init()
@@ -224,8 +218,6 @@ void ButtonGuide::Init()
     auto& io = ImGui::GetIO();
 
     g_fntNewRodin = ImFontAtlasSnapshot::GetFont("FOT-NewRodinPro-M.otf");
-    g_fntNewRodinLQ = ImFontAtlasSnapshot::GetFont("FOT-NewRodinPro-M.otf");
-
     g_upControllerIcons = LOAD_ZSTD_TEXTURE(g_controller);
     g_upKBMIcons = LOAD_ZSTD_TEXTURE(g_kbm);
 }
@@ -235,16 +227,15 @@ void ButtonGuide::Draw()
     if (!s_isVisible)
         return;
 
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto& res = ImGui::GetIO().DisplaySize;
 
     ImVec2 regionMin = { g_aspectRatioOffsetX + Scale(g_sideMargins), g_aspectRatioOffsetY * 2.0f + Scale(720.0f - 102.0f) };
     ImVec2 regionMax = { g_aspectRatioOffsetX + Scale(1280.0f - g_sideMargins), g_aspectRatioOffsetY * 2.0f + Scale(720.0f) };
 
-    auto textMarginX = Scale(57);
-    auto textMarginY = Scale(8);
+    auto textMarginX = Scale(21.25f);
     auto iconMarginX = Scale(4);
-    auto fontSize = Scale(22.5f);
+    auto fontSize = Scale(21.8f);
 
     auto offsetLeft = 0.0f;
     auto offsetRight = 0.0f;
@@ -260,17 +251,20 @@ void ButtonGuide::Draw()
         if (btn.Visibility && !*btn.Visibility)
             continue;
 
+        auto str = Localise(btn.Name).c_str();
         auto iconWidth = Scale(g_iconWidths[btn.Icon]);
         auto iconHeight = Scale(g_iconHeights[btn.Icon]);
-        auto textSize = g_fntNewRodin->CalcTextSizeA(fontSize, FLT_MAX, 0, btn.Name.c_str());
+        auto textWidth = g_fntNewRodin->CalcTextSizeA(fontSize, FLT_MAX, 0, str).x;
+        auto maxWidth = btn.MaxWidth == FLT_MAX ? textWidth : Scale(btn.MaxWidth);
+        auto textScale = std::min(1.0f, maxWidth / textWidth);
 
         if (i > 0)
-            offsetLeft += textSize.x + iconWidth + textMarginX;
+            offsetLeft += maxWidth + iconWidth + textMarginX;
 
         ImVec2 iconMin = { regionMin.x + offsetLeft - iconWidth - iconMarginX, regionMin.y };
         ImVec2 iconMax = { regionMin.x + offsetLeft - iconMarginX, regionMin.y + iconHeight };
 
-        DrawGuide(&offsetLeft, regionMin, regionMax, btn.Icon, btn.Alignment, iconMin, iconMax, btn.FontQuality, textSize, fontSize, btn.Name.c_str());
+        DrawGuide(&offsetLeft, regionMin, regionMax, btn.Icon, btn.Alignment, iconMin, iconMax, btn.FontQuality, textWidth, maxWidth, textScale, fontSize, str);
     }
 
     // Draw right aligned icons.
@@ -284,17 +278,20 @@ void ButtonGuide::Draw()
         if (btn.Visibility && !*btn.Visibility)
             continue;
 
+        auto str = Localise(btn.Name).c_str();
         auto iconWidth = Scale(g_iconWidths[btn.Icon]);
         auto iconHeight = Scale(g_iconHeights[btn.Icon]);
-        auto textSize = g_fntNewRodin->CalcTextSizeA(fontSize, FLT_MAX, 0, btn.Name.c_str());
+        auto textWidth = g_fntNewRodin->CalcTextSizeA(fontSize, FLT_MAX, 0, str).x;
+        auto maxWidth = btn.MaxWidth == FLT_MAX ? textWidth : Scale(btn.MaxWidth);
+        auto textScale = std::min(1.0f, maxWidth / textWidth);
 
         if (i < g_buttons.size() - 1)
-            offsetRight += textSize.x + iconWidth + textMarginX;
+            offsetRight += maxWidth + iconWidth + textMarginX;
 
         ImVec2 iconMin = { regionMax.x - offsetRight - iconWidth - iconMarginX, regionMin.y };
         ImVec2 iconMax = { regionMax.x - offsetRight - iconMarginX, regionMin.y + iconHeight };
 
-        DrawGuide(&offsetRight, regionMin, regionMax, btn.Icon, btn.Alignment, iconMin, iconMax, btn.FontQuality, textSize, fontSize, btn.Name.c_str());
+        DrawGuide(&offsetRight, regionMin, regionMax, btn.Icon, btn.Alignment, iconMin, iconMax, btn.FontQuality, textWidth, maxWidth, textScale, fontSize, str);
     }
 }
 

UnleashedRecomp/ui/button_guide.h

@@ -40,19 +40,23 @@ class Button
 {
 public:
     std::string Name{};
+    float MaxWidth{ FLT_MAX };
     EButtonIcon Icon{};
     EButtonAlignment Alignment{ EButtonAlignment::Right };
     EFontQuality FontQuality{ EFontQuality::High };
     bool* Visibility{ nullptr };
 
-    Button(std::string name, EButtonIcon icon, EButtonAlignment alignment, EFontQuality fontQuality = EFontQuality::High, bool* visibility = nullptr)
-        : Name(name), Icon(icon), Alignment(alignment), FontQuality(fontQuality), Visibility(visibility) {}
+    Button(std::string name, float maxWidth, EButtonIcon icon, EButtonAlignment alignment, EFontQuality fontQuality = EFontQuality::High, bool* visibility = nullptr)
+        : Name(name), MaxWidth(maxWidth), Icon(icon), Alignment(alignment), FontQuality(fontQuality), Visibility(visibility) {}
 
-    Button(std::string name, EButtonIcon icon, EButtonAlignment alignment, bool* visibility) : Name(name), Icon(icon), Alignment(alignment), Visibility(visibility) {}
+    Button(std::string name, float maxWidth, EButtonIcon icon, EButtonAlignment alignment, bool* visibility)
+        : Name(name), MaxWidth(maxWidth), Icon(icon), Alignment(alignment), Visibility(visibility) {}
 
-    Button(std::string name, EButtonIcon icon, bool* visibility) : Name(name), Icon(icon), Visibility(visibility) {}
+    Button(std::string name, float maxWidth, EButtonIcon icon, bool* visibility)
+        : Name(name), MaxWidth(maxWidth), Icon(icon), Visibility(visibility) {}
 
-    Button(std::string name, EButtonIcon icon) : Name(name), Icon(icon) {}
+    Button(std::string name, float maxWidth, EButtonIcon icon, EFontQuality fontQuality = EFontQuality::High)
+        : Name(name), MaxWidth(maxWidth), Icon(icon), FontQuality(fontQuality) {}
 };
 
 class ButtonGuide

UnleashedRecomp/ui/fader.cpp

@@ -45,7 +45,7 @@ void Fader::Draw()
 
     auto colour = IM_COL32(g_colour & 0xFF, (g_colour >> 8) & 0xFF, (g_colour >> 16) & 0xFF, 255 * alpha);
 
-    ImGui::GetForegroundDrawList()->AddRectFilled({ 0, 0 }, ImGui::GetIO().DisplaySize, colour);
+    ImGui::GetBackgroundDrawList()->AddRectFilled({ 0, 0 }, ImGui::GetIO().DisplaySize, colour);
 }
 
 static void DoFade(bool isFadeIn, float duration, std::function<void()> endCallback, float endCallbackDelay)

UnleashedRecomp/ui/game_window.cpp

@@ -173,27 +173,6 @@ void GameWindow::Init(const char* sdlVideoDriver)
     SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);
 #endif
 
-    Config::WindowSize.LockCallback = [](ConfigDef<int32_t>* def)
-    {
-        // Try matching the current window size with a known configuration.
-        if (def->Value < 0)
-            def->Value = FindNearestDisplayMode();
-    };
-
-    Config::WindowSize.ApplyCallback = [](ConfigDef<int32_t>* def)
-    {
-        auto displayModes = GetDisplayModes();
-
-        // Use largest supported resolution if overflowed.
-        if (def->Value >= displayModes.size())
-            def->Value = displayModes.size() - 1;
-
-        auto& mode = displayModes[def->Value];
-        auto centre = SDL_WINDOWPOS_CENTERED_DISPLAY(GetDisplay());
-
-        SetDimensions(mode.w, mode.h, centre, centre);
-    };
-
     s_x = Config::WindowX;
     s_y = Config::WindowY;
     s_width = Config::WindowWidth;

UnleashedRecomp/ui/imgui_utils.cpp

@@ -45,6 +45,9 @@ void ResetGradient()
 
 void SetShaderModifier(uint32_t shaderModifier)
 {
+    if (shaderModifier == IMGUI_SHADER_MODIFIER_LOW_QUALITY_TEXT && Config::DisableLowResolutionFontOnCustomUI)
+        shaderModifier = IMGUI_SHADER_MODIFIER_NONE;
+
     auto callbackData = AddImGuiCallback(ImGuiCallback::SetShaderModifier);
     callbackData->setShaderModifier.shaderModifier = shaderModifier;
 }
@@ -169,7 +172,7 @@ double ComputeMotion(double duration, double offset, double total)
 
 void DrawPauseContainer(ImVec2 min, ImVec2 max, float alpha)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     auto commonWidth = Scale(35);
     auto commonHeight = Scale(35);
@@ -200,7 +203,7 @@ void DrawPauseContainer(ImVec2 min, ImVec2 max, float alpha)
 
 void DrawPauseHeaderContainer(ImVec2 min, ImVec2 max, float alpha)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     auto commonWidth = Scale(35);
 
@@ -217,14 +220,14 @@ void DrawPauseHeaderContainer(ImVec2 min, ImVec2 max, float alpha)
 
 void DrawTextBasic(const ImFont* font, float fontSize, const ImVec2& pos, ImU32 colour, const char* text)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     drawList->AddText(font, fontSize, pos, colour, text, nullptr);
 }
 
 void DrawTextWithMarquee(const ImFont* font, float fontSize, const ImVec2& position, const ImVec2& min, const ImVec2& max, ImU32 color, const char* text, double time, double delay, double speed)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto rectWidth = max.x - min.x;
     auto textSize = font->CalcTextSizeA(fontSize, FLT_MAX, 0, text);
     auto textX = position.x - fmodf(std::max(0.0, ImGui::GetTime() - (time + delay)) * speed, textSize.x + rectWidth);
@@ -278,7 +281,7 @@ void DrawTextWithMarquee(const ImFont* font, float fontSize, const ImVec2& posit
 
 void DrawTextWithMarqueeShadow(const ImFont* font, float fontSize, const ImVec2& pos, const ImVec2& min, const ImVec2& max, ImU32 colour, const char* text, double time, double delay, double speed, float offset, float radius, ImU32 shadowColour)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto rectWidth = max.x - min.x;
     auto textSize = font->CalcTextSizeA(fontSize, FLT_MAX, 0, text);
     auto textX = pos.x - fmodf(std::max(0.0, ImGui::GetTime() - (time + delay)) * speed, textSize.x + rectWidth);
@@ -296,7 +299,7 @@ void DrawTextWithMarqueeShadow(const ImFont* font, float fontSize, const ImVec2&
 
 void DrawTextWithOutline(const ImFont* font, float fontSize, const ImVec2& pos, ImU32 color, const char* text, float outlineSize, ImU32 outlineColor, uint32_t shaderModifier)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     SetOutline(outlineSize);
     drawList->AddText(font, fontSize, pos, outlineColor, text);
@@ -313,10 +316,16 @@ void DrawTextWithOutline(const ImFont* font, float fontSize, const ImVec2& pos,
 
 void DrawTextWithShadow(const ImFont* font, float fontSize, const ImVec2& pos, ImU32 colour, const char* text, float offset, float radius, ImU32 shadowColour)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     offset = Scale(offset);
 
+    // Original 4:3 has thicker text shadows.
+    if (Config::AspectRatio == EAspectRatio::OriginalNarrow)
+    {
+        radius *= 1.5f;
+    }
+
     SetOutline(radius);
     drawList->AddText(font, fontSize, { pos.x + offset, pos.y + offset }, shadowColour, text);
     ResetOutline();
@@ -455,17 +464,39 @@ std::vector<std::string> Split(const char* strStart, const ImFont* font, float f
     const bool wordWrapEnabled = (maxWidth > 0.0f);
     const char *wordWrapEOL = nullptr;
 
+    auto IsKanji = [](const char* str, const char* strEnd)
+    {
+        const char* tempStr = str;
+        unsigned int c = (unsigned int)*tempStr;
+        if (c < 0x80)
+            tempStr += 1;
+        else
+            tempStr += ImTextCharFromUtf8(&c, tempStr, strEnd);
+
+        // Basic CJK and CJK Extension A
+        return (c >= 0x4E00 && c <= 0x9FBF) || (c >= 0x3400 && c <= 0x4DBF);
+    };
+
     while (*str != 0) 
     {
         if (wordWrapEnabled)
         {
             if (wordWrapEOL == nullptr)
             {
-                wordWrapEOL = font->CalcWordWrapPositionA(scale, str, strEnd, maxWidth - lineWidth);
+                wordWrapEOL = CalcWordWrapPositionA(font, scale, str, strEnd, maxWidth - lineWidth);
             }
 
             if (str >= wordWrapEOL)
             {
+                if (IsKanji(str, strEnd))
+                {
+                    // If the current character is Kanji, move back to prevent splitting Kanji
+                    while (str > lineStart && IsKanji(str - 3, strEnd))
+                    {
+                        str -= 3;
+                    }
+                }
+
                 if (textWidth < lineWidth)
                     textWidth = lineWidth;
 
@@ -639,7 +670,7 @@ ImVec2 MeasureCentredParagraph(const ImFont* font, float fontSize, float maxWidt
     return MeasureCentredParagraph(font, fontSize, lineMargin, lines);
 }
 
-void DrawRubyAnnotatedText(const ImFont* font, float fontSize, float maxWidth, const ImVec2& pos, float lineMargin, const char* text, std::function<void(const char*, ImVec2)> drawMethod, std::function<void(const char*, float, ImVec2)> annotationDrawMethod, bool isCentred)
+void DrawRubyAnnotatedText(const ImFont* font, float fontSize, float maxWidth, const ImVec2& pos, float lineMargin, const char* text, std::function<void(const char*, ImVec2)> drawMethod, std::function<void(const char*, float, ImVec2)> annotationDrawMethod, bool isCentred, bool leadingSpace)
 {
     auto annotationFontSize = fontSize * ANNOTATION_FONT_SIZE_MODIFIER;
 
@@ -647,8 +678,14 @@ void DrawRubyAnnotatedText(const ImFont* font, float fontSize, float maxWidth, c
     auto lines = Split(input.first.c_str(), font, fontSize, maxWidth);
 
     for (auto& line : lines)
+    {
         line = ReAddRubyAnnotations(line, input.second);
-    
+        if (!line.empty() && line.substr(0, 3) != "「" && leadingSpace)
+        {
+            line.insert(0, " ");
+        }
+    }
+
     auto paragraphSize = MeasureCentredParagraph(font, fontSize, lineMargin, lines);
     auto offsetY = 0.0f;
 
@@ -732,7 +769,7 @@ ImU32 ColourLerp(ImU32 c0, ImU32 c1, float t)
 
 void DrawVersionString(const ImFont* font, const ImU32 col)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto& res = ImGui::GetIO().DisplaySize;
     auto fontSize = Scale(12);
     auto textMargin = Scale(2);
@@ -743,7 +780,7 @@ void DrawVersionString(const ImFont* font, const ImU32 col)
 
 void DrawSelectionContainer(ImVec2 min, ImVec2 max, bool fadeTop)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     static auto breatheStart = ImGui::GetTime();
     auto alpha = BREATHE_MOTION(1.0f, 0.55f, breatheStart, 0.92f);
@@ -787,7 +824,7 @@ void DrawSelectionContainer(ImVec2 min, ImVec2 max, bool fadeTop)
 
 void DrawToggleLight(ImVec2 pos, bool isEnabled, float alpha)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto lightSize = Scale(14);
     auto lightCol = IM_COL32(255, 255, 255, 255 * alpha);
 
@@ -817,3 +854,105 @@ void DrawToggleLight(ImVec2 pos, bool isEnabled, float alpha)
         drawList->AddImage(g_texLight.get(), min, max, GET_UV_COORDS(lightOffUVs), lightCol);
     }
 }
+
+// Taken from ImGui because we need to modify to break for '\u200B\ too
+// Simple word-wrapping for English, not full-featured. Please submit failing cases!
+// This will return the next location to wrap from. If no wrapping if necessary, this will fast-forward to e.g. text_end.
+// FIXME: Much possible improvements (don't cut things like "word !", "word!!!" but cut within "word,,,,", more sensible support for punctuations, support for Unicode punctuations, etc.)
+const char* CalcWordWrapPositionA(const ImFont* font, float scale, const char* text, const char* text_end, float wrap_width)
+{
+    // For references, possible wrap point marked with ^
+    //  "aaa bbb, ccc,ddd. eee   fff. ggg!"
+    //      ^    ^    ^   ^   ^__    ^    ^
+
+    // List of hardcoded separators: .,;!?'"
+
+    // Skip extra blanks after a line returns (that includes not counting them in width computation)
+    // e.g. "Hello    world" --> "Hello" "World"
+
+    // Cut words that cannot possibly fit within one line.
+    // e.g.: "The tropical fish" with ~5 characters worth of width --> "The tr" "opical" "fish"
+    float line_width = 0.0f;
+    float word_width = 0.0f;
+    float blank_width = 0.0f;
+    wrap_width /= scale; // We work with unscaled widths to avoid scaling every characters
+
+    const char* word_end = text;
+    const char* prev_word_end = NULL;
+    bool inside_word = true;
+
+    const char* s = text;
+    IM_ASSERT(text_end != NULL);
+    while (s < text_end)
+    {
+        unsigned int c = (unsigned int)*s;
+        const char* next_s;
+        if (c < 0x80)
+            next_s = s + 1;
+        else
+            next_s = s + ImTextCharFromUtf8(&c, s, text_end);
+
+        if (c < 32)
+        {
+            if (c == '\n')
+            {
+                line_width = word_width = blank_width = 0.0f;
+                inside_word = true;
+                s = next_s;
+                continue;
+            }
+            if (c == '\r')
+            {
+                s = next_s;
+                continue;
+            }
+        }
+
+        const float char_width = ((int)c < font->IndexAdvanceX.Size ? font->IndexAdvanceX.Data[c] : font->FallbackAdvanceX);
+        if (ImCharIsBlankW(c) || c == 0x200B)
+        {
+            if (inside_word)
+            {
+                line_width += blank_width;
+                blank_width = 0.0f;
+                word_end = s;
+            }
+            blank_width += char_width;
+            inside_word = false;
+        }
+        else
+        {
+            word_width += char_width;
+            if (inside_word)
+            {
+                word_end = next_s;
+            }
+            else
+            {
+                prev_word_end = word_end;
+                line_width += word_width + blank_width;
+                word_width = blank_width = 0.0f;
+            }
+
+            // Allow wrapping after punctuation.
+            inside_word = (c != '.' && c != ',' && c != ';' && c != '!' && c != '?' && c != '\"');
+        }
+
+        // We ignore blank width at the end of the line (they can be skipped)
+        if (line_width + word_width > wrap_width)
+        {
+            // Words that cannot possibly fit within an entire line will be cut anywhere.
+            if (word_width < wrap_width)
+                s = prev_word_end ? prev_word_end : word_end;
+            break;
+        }
+
+        s = next_s;
+    }
+
+    // Wrap_width is too small to fit anything. Force displaying 1 character to minimize the height discontinuity.
+    // +1 may not be a character start point in UTF-8 but it's ok because caller loops use (text >= word_wrap_eol).
+    if (s == text && text < text_end)
+        return s + 1;
+    return s;
+}

UnleashedRecomp/ui/imgui_utils.h

@@ -72,7 +72,7 @@ std::vector<std::string> RemoveAnnotationFromParagraph(const std::vector<std::st
 std::string RemoveAnnotationFromParagraphLine(const std::vector<TextSegment>& annotatedLine);
 ImVec2 MeasureCentredParagraph(const ImFont* font, float fontSize, float lineMargin, const std::vector<std::string>& lines);
 ImVec2 MeasureCentredParagraph(const ImFont* font, float fontSize, float maxWidth, float lineMargin, const char* text);
-void DrawRubyAnnotatedText(const ImFont* font, float fontSize, float maxWidth, const ImVec2& pos, float lineMargin, const char* text, std::function<void(const char*, ImVec2)> drawMethod, std::function<void(const char*, float, ImVec2)> annotationDrawMethod, bool isCentred = false);
+void DrawRubyAnnotatedText(const ImFont* font, float fontSize, float maxWidth, const ImVec2& pos, float lineMargin, const char* text, std::function<void(const char*, ImVec2)> drawMethod, std::function<void(const char*, float, ImVec2)> annotationDrawMethod, bool isCentred = false, bool leadingSpace = false);
 float Lerp(float a, float b, float t);
 float Cubic(float a, float b, float t);
 float Hermite(float a, float b, float t);
@@ -81,3 +81,4 @@ ImU32 ColourLerp(ImU32 c0, ImU32 c1, float t);
 void DrawVersionString(const ImFont* font, const ImU32 col = IM_COL32(255, 255, 255, 70));
 void DrawSelectionContainer(ImVec2 min, ImVec2 max, bool fadeTop = false);
 void DrawToggleLight(ImVec2 pos, bool isEnabled, float alpha = 1.0f);
+const char* CalcWordWrapPositionA(const ImFont* font, float scale, const char* text, const char* text_end, float wrap_width);

UnleashedRecomp/ui/installer_wizard.cpp

@@ -464,7 +464,7 @@ static void ResetCursorRects()
 static void DrawBackground()
 {
     auto &res = ImGui::GetIO().DisplaySize;
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     drawList->AddRectFilled({ 0.0, 0.0 }, res, IM_COL32_BLACK);
 }
 
@@ -483,7 +483,7 @@ static void DrawLeftImage()
     int a = std::lround(255.0 * imageAlpha);
     GuestTexture *guestTexture = g_installTextures[installTextureIndex % g_installTextures.size()].get();
     auto &res = ImGui::GetIO().DisplaySize;
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     ImVec2 min = { g_aspectRatioOffsetX + Scale(IMAGE_X), g_aspectRatioOffsetY + Scale(IMAGE_Y) };
     ImVec2 max = { min.x + Scale(IMAGE_WIDTH), min.y + Scale(IMAGE_HEIGHT) };
     drawList->AddImage(guestTexture, min, max, ImVec2(0, 0), ImVec2(1, 1), IM_COL32(255, 255, 255, a));
@@ -491,7 +491,7 @@ static void DrawLeftImage()
 
 static void DrawHeaderIconsForInstallPhase(double iconsPosX, double iconsPosY, double iconsScale)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     // Arrow Circle Icon
     ImVec2 arrowCircleMin = { g_aspectRatioOffsetX + Scale(iconsPosX - iconsScale / 2), Scale(iconsPosY - iconsScale / 2) };
@@ -546,7 +546,7 @@ static void DrawHeaderIconsForInstallPhase(double iconsPosX, double iconsPosY, d
 
 static void DrawHeaderIcons()
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     float iconsPosX = 256.0f;
     float iconsPosY = 80.0f;
@@ -582,7 +582,7 @@ static void DrawScanlineBars()
     }
 
     auto &res = ImGui::GetIO().DisplaySize;
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     SetShaderModifier(IMGUI_SHADER_MODIFIER_SCANLINE);
 
@@ -680,7 +680,7 @@ static void DrawScanlineBars()
 static void DrawContainer(ImVec2 min, ImVec2 max, bool isTextArea)
 {   
     auto &res = ImGui::GetIO().DisplaySize;
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     double gridAlpha = ComputeMotionInstaller(g_appearTime, g_disappearTime, 
         isTextArea ? CONTAINER_INNER_TIME : CONTAINER_OUTER_TIME,
@@ -711,7 +711,7 @@ static void DrawContainer(ImVec2 min, ImVec2 max, bool isTextArea)
 static void DrawDescriptionContainer()
 {
     auto &res = ImGui::GetIO().DisplaySize;
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto fontSize = Scale(28.0f);
     auto annotationFontSize = fontSize * ANNOTATION_FONT_SIZE_MODIFIER;
 
@@ -736,6 +736,14 @@ static void DrawDescriptionContainer()
     }
     else if (g_currentPage == WizardPage::InstallFailed)
     {
+        // Japanese needs text to be brought in by a normal width space
+        // as it allows for text to begin further than others for
+        // special characters.
+        if (Config::Language == ELanguage::Japanese)
+        {
+            strncat(descriptionText, " ", 1);
+        }
+
         strncat(descriptionText, g_installerErrorMessage.c_str(), sizeof(descriptionText) - 1);
     }
 
@@ -769,6 +777,8 @@ static void DrawDescriptionContainer()
 
         textX += annotationFontSize;
         textY += annotationFontSize;
+
+        lineWidth += annotationFontSize;
     }
 
     drawList->PushClipRect(clipRectMin, clipRectMax, false);
@@ -788,28 +798,47 @@ static void DrawDescriptionContainer()
         [=](const char* str, float size, ImVec2 pos)
         {
             DrawTextBasic(g_seuratFont, size, pos, IM_COL32(255, 255, 255, 255 * textAlpha), str);
-        }
+        },
+        false,
+        Config::Language == ELanguage::Japanese
     );
 
     drawList->PopClipRect();
-
     drawList->PopClipRect();
 
     if (g_currentPage == WizardPage::InstallSucceeded)
     {
+        auto descTextSize = MeasureCentredParagraph(g_seuratFont, fontSize, lineWidth, lineMargin, descriptionText);
+
         auto hedgeDevStr = "hedge-dev";
         auto hedgeDevTextSize = g_seuratFont->CalcTextSizeA(fontSize, FLT_MAX, 0, hedgeDevStr);
         auto hedgeDevTextMarginX = Scale(15);
 
-        auto imageScale = hedgeDevTextSize.x / 3;
-        auto imageMarginY = Scale(15);
-
         auto colWhite = IM_COL32(255, 255, 255, 255 * textAlpha);
 
+        auto containerLeft = g_aspectRatioOffsetX + Scale(CONTAINER_X);
+        auto containerTop = g_aspectRatioOffsetY + Scale(CONTAINER_Y);
+        auto containerRight = containerLeft + Scale(CONTAINER_WIDTH);
+        auto containerBottom = containerTop + Scale(CONTAINER_HEIGHT);
+
+        auto marqueeTextSize = g_seuratFont->CalcTextSizeA(fontSize, FLT_MAX, 0, g_creditsStr.c_str());
+        auto marqueeTextMarginX = Scale(5);
+        auto marqueeTextMarginY = Scale(15);
+
+        ImVec2 marqueeTextPos = { descriptionMax.x, containerBottom - marqueeTextSize.y - marqueeTextMarginY };
+        ImVec2 marqueeTextMin = { containerLeft, marqueeTextPos.y };
+        ImVec2 marqueeTextMax = { containerRight, containerBottom };
+
+        auto imageScale = hedgeDevTextSize.x / 3;
+        auto imageMarginY = Scale(2);
+
+        ImVec2 imageRegionMin = { containerLeft, textY + descTextSize.y };
+        ImVec2 imageRegionMax = { containerRight, containerBottom - (marqueeTextMax.y - marqueeTextMin.y) };
+
         ImVec2 imageMin = 
         {
-            /* X */ g_aspectRatioOffsetX + Scale(CONTAINER_X) + (Scale(CONTAINER_WIDTH) / 2) - (imageScale / 2) - (hedgeDevTextSize.x / 2) - hedgeDevTextMarginX,
-            /* Y */ g_aspectRatioOffsetY + Scale(CONTAINER_Y) + (Scale(CONTAINER_HEIGHT) / 2) - (imageScale / 2) + imageMarginY
+            /* X */ imageRegionMin.x + ((imageRegionMax.x - imageRegionMin.x) / 2) - (imageScale / 2) - (hedgeDevTextSize.x / 2) - hedgeDevTextMarginX,
+            /* Y */ imageRegionMin.y + ((imageRegionMax.y - imageRegionMin.y) / 2) - (imageScale / 2) - imageMarginY
         };
 
         ImVec2 imageMax = { imageMin.x + imageScale, imageMin.y + imageScale };
@@ -825,16 +854,8 @@ static void DrawDescriptionContainer()
             hedgeDevStr
         );
 
-        auto marqueeTextSize = g_seuratFont->CalcTextSizeA(fontSize, FLT_MAX, 0, g_creditsStr.c_str());
-        auto marqueeTextMarginX = Scale(5);
-        auto marqueeTextMarginY = Scale(15);
-
-        ImVec2 textPos = { descriptionMax.x, g_aspectRatioOffsetY + Scale(CONTAINER_Y) + Scale(CONTAINER_HEIGHT) - marqueeTextSize.y - marqueeTextMarginY };
-        ImVec2 textMin = { g_aspectRatioOffsetX + Scale(CONTAINER_X), textPos.y };
-        ImVec2 textMax = { g_aspectRatioOffsetX + Scale(CONTAINER_X) + Scale(CONTAINER_WIDTH), g_aspectRatioOffsetY + Scale(CONTAINER_Y) + Scale(CONTAINER_HEIGHT) };
-
-        SetHorizontalMarqueeFade(textMin, textMax, Scale(32));
-        DrawTextWithMarquee(g_seuratFont, fontSize, textPos, textMin, textMax, colWhite, g_creditsStr.c_str(), g_installerEndTime, 0.9, Scale(200));
+        SetHorizontalMarqueeFade(marqueeTextMin, marqueeTextMax, Scale(32));
+        DrawTextWithMarquee(g_seuratFont, fontSize, marqueeTextPos, marqueeTextMin, marqueeTextMax, colWhite, g_creditsStr.c_str(), g_installerEndTime, 0.9, Scale(200));
         ResetMarqueeFade();
     }
 
@@ -863,7 +884,7 @@ static void DrawDescriptionContainer()
 
     if (g_currentPage == WizardPage::InstallSucceeded && textAlpha >= 1.0)
     {
-        ButtonGuide::Open(Button(Localise("Common_Select"), selectIcon));
+        ButtonGuide::Open(Button("Common_Select", 115.0f, selectIcon));
     }
     else if (g_currentPage != WizardPage::Installing && textAlpha >= 1.0)
     {
@@ -875,15 +896,15 @@ static void DrawDescriptionContainer()
 
         std::array<Button, 2> buttons =
         {
-            Button(Localise("Common_Select"), selectIcon),
-            Button(Localise(backKey), backIcon)
+            Button("Common_Select", 115.0f, selectIcon),
+            Button(backKey, FLT_MAX, backIcon)
         };
 
         ButtonGuide::Open(buttons);
     }
     else if (g_currentPage == WizardPage::Installing)
     {
-        ButtonGuide::Open(Button(Localise("Common_Cancel"), backIcon));
+        ButtonGuide::Open(Button("Common_Cancel", FLT_MAX, backIcon));
     }
     else
     {
@@ -896,7 +917,7 @@ static void DrawDescriptionContainer()
 static void DrawButtonContainer(ImVec2 min, ImVec2 max, int baser, int baseg, float alpha)
 {
     auto &res = ImGui::GetIO().DisplaySize;
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     SetShaderModifier(IMGUI_SHADER_MODIFIER_SCANLINE_BUTTON);
     drawList->AddRectFilledMultiColor(min, max, IM_COL32(baser, baseg + 130, 0, 223 * alpha), IM_COL32(baser, baseg + 130, 0, 178 * alpha), IM_COL32(baser, baseg + 130, 0, 223 * alpha), IM_COL32(baser, baseg + 130, 0, 178 * alpha));
     drawList->AddRectFilledMultiColor(min, max, IM_COL32(baser, baseg, 0, 13 * alpha), IM_COL32(baser, baseg, 0, 0), IM_COL32(baser, baseg, 0, 55 * alpha), IM_COL32(baser, baseg, 0, 6 * alpha));
@@ -924,7 +945,7 @@ static void DrawButton(ImVec2 min, ImVec2 max, const char *buttonText, bool sour
     buttonPressed = false;
 
     auto &res = ImGui::GetIO().DisplaySize;
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     float alpha = ComputeMotionInstaller(g_appearTime, g_disappearTime, CONTAINER_INNER_TIME, CONTAINER_INNER_DURATION);
     if (!buttonEnabled)
     {
@@ -1030,7 +1051,7 @@ static void DrawSourceButton(ButtonColumn buttonColumn, float yRatio, const char
 static void DrawProgressBar(float progressRatio)
 {
     auto &res = ImGui::GetIO().DisplaySize;
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     float alpha = 1.0;
     const uint32_t innerColor0 = IM_COL32(0, 65, 0, 255 * alpha);
     const uint32_t innerColor1 = IM_COL32(0, 32, 0, 255 * alpha);
@@ -1390,7 +1411,7 @@ static void DrawNavigationButton()
 
     float squashRatio;
     constexpr float NAV_BUTTON_MAX_TEXT_WIDTH = 90.0f;
-    const char *nextButtonKey = "Installer_Button_Next";
+    std::string_view nextButtonKey = "Installer_Button_Next";
     if (skipButton)
     {
         nextButtonKey = "Installer_Button_Skip";
@@ -1532,7 +1553,7 @@ static void DrawHorizontalBorder(bool bottomBorder)
     const uint32_t FADE_COLOR_LEFT = IM_COL32(155, 155, 155, 0);
     const uint32_t SOLID_COLOR = IM_COL32(155, 200, 155, 255);
     const uint32_t FADE_COLOR_RIGHT = IM_COL32(155, 225, 155, 0);
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     double borderScale = 1.0 - ComputeMotionInstaller(g_appearTime, g_disappearTime, CONTAINER_LINE_ANIMATION_TIME, CONTAINER_LINE_ANIMATION_DURATION);
     float midX = g_aspectRatioOffsetX + Scale(CONTAINER_X + CONTAINER_WIDTH / 5);
     float minX = std::lerp(g_aspectRatioOffsetX + Scale(CONTAINER_X - BORDER_SIZE - BORDER_OVERSHOOT), midX, borderScale);
@@ -1564,7 +1585,7 @@ static void DrawVerticalBorder(bool rightBorder)
 {
     const uint32_t SOLID_COLOR = IM_COL32(155, rightBorder ? 225 : 155, 155, 255);
     const uint32_t FADE_COLOR = IM_COL32(155, rightBorder ? 225 : 155, 155, 0);
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     double borderScale = 1.0 - ComputeMotionInstaller(g_appearTime, g_disappearTime, CONTAINER_LINE_ANIMATION_TIME, CONTAINER_LINE_ANIMATION_DURATION);
     float minX = g_aspectRatioOffsetX + (rightBorder ? Scale(CONTAINER_X + CONTAINER_WIDTH) : Scale(CONTAINER_X - BORDER_SIZE));
     float maxX = minX + Scale(BORDER_SIZE);
@@ -1661,7 +1682,7 @@ static void PickerDrawForeground()
 {
     if (g_currentPickerVisible)
     {
-        auto drawList = ImGui::GetForegroundDrawList();
+        auto drawList = ImGui::GetBackgroundDrawList();
         drawList->AddRectFilled({ 0.0f, 0.0f }, ImGui::GetIO().DisplaySize, IM_COL32(0, 0, 0, 190));
     }
 }

UnleashedRecomp/ui/message_window.cpp

@@ -150,7 +150,7 @@ g_sdlEventListenerForMessageWindow;
 
 bool DrawContainer(float appearTime, ImVec2 centre, ImVec2 max, bool isForeground = true)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     ImVec2 _min = { centre.x - max.x, centre.y - max.y };
     ImVec2 _max = { centre.x + max.x, centre.y + max.y };
@@ -201,7 +201,7 @@ bool DrawContainer(float appearTime, ImVec2 centre, ImVec2 max, bool isForegroun
 
 void DrawButton(int rowIndex, float yOffset, float width, float height, std::string& text)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     auto clipRectMin = drawList->GetClipRectMin();
     auto clipRectMax = drawList->GetClipRectMax();
@@ -223,6 +223,10 @@ void DrawButton(int rowIndex, float yOffset, float width, float height, std::str
     auto fontSize = Scale(28);
     auto textSize = g_fntSeurat->CalcTextSizeA(fontSize, FLT_MAX, 0, text.c_str());
 
+    // Show low quality text in-game.
+    if (App::s_isInit)
+        SetShaderModifier(IMGUI_SHADER_MODIFIER_LOW_QUALITY_TEXT);
+
     DrawTextWithShadow
     (
         g_fntSeurat,
@@ -231,6 +235,10 @@ void DrawButton(int rowIndex, float yOffset, float width, float height, std::str
         isSelected ? IM_COL32(255, 128, 0, 255) : IM_COL32(255, 255, 255, 255),
         text.c_str()
     );
+
+    // Reset the shader modifier.
+    if (App::s_isInit)
+        SetShaderModifier(IMGUI_SHADER_MODIFIER_NONE);
 }
 
 void DrawNextButtonGuide(bool isController, bool isKeyboard)
@@ -241,11 +249,16 @@ void DrawNextButtonGuide(bool isController, bool isKeyboard)
             ? EButtonIcon::Enter
             : EButtonIcon::LMB;
 
-    // Always show controller prompt in-game.
-    if (App::s_isInit)
-        icon = EButtonIcon::A;
+    auto fontQuality = EFontQuality::High;
 
-    ButtonGuide::Open(Button(Localise("Common_Next"), icon));
+    // Always show controller prompt and low quality text in-game.
+    if (App::s_isInit)
+    {
+        icon = EButtonIcon::A;
+        fontQuality = EFontQuality::Low;
+    }
+
+    ButtonGuide::Open(Button("Common_Next", FLT_MAX, icon, fontQuality));
 }
 
 static void ResetSelection()
@@ -275,7 +288,7 @@ void MessageWindow::Draw()
     if (!s_isVisible)
         return;
 
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto& res = ImGui::GetIO().DisplaySize;
 
     ImVec2 centre = { res.x / 2, res.y / 2 };
@@ -338,6 +351,10 @@ void MessageWindow::Draw()
 
     if (DrawContainer(g_appearTime, centre, { textSize.x / 2 + textMarginX, textSize.y / 2 + textMarginY }, !g_isControlsVisible))
     {
+        // Use low quality text when the game is booted to not clash with existing UI.
+        if (App::s_isInit)
+            SetShaderModifier(IMGUI_SHADER_MODIFIER_LOW_QUALITY_TEXT);
+
         DrawRubyAnnotatedText
         (
             g_fntSeurat,
@@ -353,12 +370,16 @@ void MessageWindow::Draw()
             },
             [=](const char* str, float size, ImVec2 pos)
             {
-                DrawTextWithShadow(g_fntSeurat, size, pos, IM_COL32(255, 255, 255, 255), str, 1.0f);
+                DrawTextWithShadow(g_fntSeurat, size, pos, IM_COL32(255, 255, 255, 255), str, 1.5f, 1.5f);
             },
 
             true
         );
 
+        // Reset the shader modifier.
+        if (App::s_isInit)
+            SetShaderModifier(IMGUI_SHADER_MODIFIER_LOW_QUALITY_TEXT);
+
         drawList->PopClipRect();
 
         if (g_buttons.size())
@@ -423,10 +444,17 @@ void MessageWindow::Draw()
                             backIcon = EButtonIcon::Escape;
                         }
 
+                        auto fontQuality = EFontQuality::High;
+                        if (App::s_isInit)
+                        {
+                            // Show low quality text in-game.
+                            fontQuality = EFontQuality::Low;
+                        }
+
                         std::array<Button, 2> buttons =
                         {
-                            Button(Localise("Common_Select"), selectIcon),
-                            Button(Localise("Common_Back"), backIcon),
+                            Button("Common_Select", 115.0f, selectIcon, fontQuality),
+                            Button("Common_Back", FLT_MAX, backIcon, fontQuality),
                         };
 
                         ButtonGuide::Open(buttons);
@@ -470,8 +498,8 @@ void MessageWindow::Draw()
 
                     std::array<Button, 2> buttons =
                     {
-                        Button(Localise("Common_Select"), EButtonIcon::LMB),
-                        Button(Localise("Common_Back"), EButtonIcon::Escape),
+                        Button("Common_Select", 115.0f, EButtonIcon::LMB),
+                        Button("Common_Back", FLT_MAX, EButtonIcon::Escape),
                     };
 
                     ButtonGuide::Open(buttons);

UnleashedRecomp/ui/options_menu.cpp

@@ -1,5 +1,6 @@
 #include "options_menu.h"
 #include "options_menu_thumbnails.h"
+#include "tv_static.h"
 
 #include <api/SWA.h>
 #include <apu/audio.h>
@@ -18,6 +19,7 @@
 #include <app.h>
 #include <decompressor.h>
 #include <exports.h>
+#include <sdl_listener.h>
 
 #include <res/images/options_menu/miles_electric.dds.h>
 
@@ -101,6 +103,24 @@ static double g_appearTime = 0.0;
 
 static std::unique_ptr<GuestTexture> g_upMilesElectric;
 
+static float g_rightStickY;
+
+class SDLEventListenerForOptionsMenu : public SDLEventListener
+{
+public:
+    bool OnSDLEvent(SDL_Event* event) override
+    {
+        if (!OptionsMenu::s_isVisible || !hid::IsInputAllowed())
+            return false;
+
+        if (event->type == SDL_CONTROLLERAXISMOTION && event->caxis.axis == SDL_CONTROLLER_AXIS_RIGHTY)
+            g_rightStickY = event->caxis.value / 32767.0f;
+
+        return false;
+    }
+}
+g_sdlEventListenerForOptionsMenu;
+
 static void DrawTitle()
 {
     static constexpr double fadeOffset = 3.0;
@@ -127,7 +147,7 @@ static void DrawTitle()
         g_titleAnimBegin = false;
     }
 
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto x = Scale(122);
     auto y = Scale(56);
 
@@ -238,7 +258,7 @@ static void DrawScanlineBars()
     float height = Scale(105.0f);
 
     auto& res = ImGui::GetIO().DisplaySize;
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     if (OptionsMenu::s_pauseMenuType != SWA::eMenuType_WorldMap)
     {
@@ -350,7 +370,7 @@ static void DrawContainer(ImVec2 min, ImVec2 max, bool drawRightOutline)
     max.y = Lerp(center, max.y, containerHeight);
 
     auto& res = ImGui::GetIO().DisplaySize;
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     double outerAlpha = g_isStage ? 1.0 : ComputeMotion(g_appearTime, CONTAINER_OUTER_TIME, CONTAINER_OUTER_DURATION);
     double innerAlpha = g_isStage ? 1.0 : ComputeMotion(g_appearTime, CONTAINER_INNER_TIME, CONTAINER_INNER_DURATION);
@@ -429,11 +449,8 @@ static bool DrawCategories()
 
     auto inputState = SWA::CInputState::GetInstance();
 
-    bool moveLeft = !g_lockedOnOption && (inputState->GetPadState().IsTapped(SWA::eKeyState_LeftBumper) ||
-        inputState->GetPadState().IsTapped(SWA::eKeyState_LeftTrigger));
-
-    bool moveRight = !g_lockedOnOption && (inputState->GetPadState().IsTapped(SWA::eKeyState_RightBumper) ||
-        inputState->GetPadState().IsTapped(SWA::eKeyState_RightTrigger));
+    bool moveLeft = !g_lockedOnOption && inputState->GetPadState().IsTapped(SWA::eKeyState_LeftBumper);
+    bool moveRight = !g_lockedOnOption && inputState->GetPadState().IsTapped(SWA::eKeyState_RightBumper);
 
     if (moveLeft)
     {
@@ -454,40 +471,47 @@ static bool DrawCategories()
         Game_PlaySound("sys_actstg_score");
     }
 
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto clipRectMin = drawList->GetClipRectMin();
     auto clipRectMax = drawList->GetClipRectMax();
 
-    constexpr float NARROW_PADDING_GRID_COUNT = 1.5f;
-    constexpr float WIDE_PADDING_GRID_COUNT = 3.0f;
-
     float gridSize = Scale(GRID_SIZE);
-    float textPadding = gridSize * Lerp(NARROW_PADDING_GRID_COUNT, WIDE_PADDING_GRID_COUNT, g_aspectRatioNarrowScale);
-    float tabPadding = gridSize;
 
     float size = Scale(32.0f);
     ImVec2 textSizes[g_categoryCount];
-    float tabWidthSum = 0.0f;
+    float clipRectWidth = clipRectMax.x - clipRectMin.x;
+
+    float textWidthSum = 0.0f;
     for (size_t i = 0; i < g_categoryCount; i++)
     {
         textSizes[i] = g_dfsogeistdFont->CalcTextSizeA(size, FLT_MAX, 0.0f, GetCategory(i).c_str());
-        tabWidthSum += textSizes[i].x + textPadding * 2.0f;
+        textWidthSum += textSizes[i].x;
+    }
+
+    float textSquashRatio = 1.0f;
+    float maxTextWidthSum = clipRectWidth - (gridSize * 4.0f * (g_categoryCount - 1));
+    if (textWidthSum > maxTextWidthSum)
+    {
+        textSquashRatio = maxTextWidthSum / textWidthSum;
+        for (auto& textSize : textSizes)
+            textSize.x *= textSquashRatio;
+
+        textWidthSum = maxTextWidthSum;
     }
-    tabWidthSum += (g_categoryCount - 1) * tabPadding;
 
     float tabHeight = gridSize * 4.0f;
-    float xOffset = ((clipRectMax.x - clipRectMin.x) - tabWidthSum) / 2.0f;
+    float textPadding = (clipRectWidth - textWidthSum) / (g_categoryCount + 1.0f);
+    float xOffset = textPadding;
     xOffset -= (1.0 - motion) * gridSize * 4.0;
 
-    ImVec2 minVec[g_categoryCount];
+    ImVec2 textPositions[g_categoryCount];
 
     for (size_t i = 0; i < g_categoryCount; i++)
     {
-        ImVec2 min = { clipRectMin.x + xOffset, clipRectMin.y };
+        float tabPadding = std::min(textPadding / 2.0f, gridSize * 3.0f);
 
-        xOffset += textSizes[i].x + textPadding * 2.0f;
-        ImVec2 max = { clipRectMin.x + xOffset, clipRectMin.y + tabHeight };
-        xOffset += tabPadding;
+        ImVec2 min = { clipRectMin.x + xOffset - tabPadding, clipRectMin.y };
+        ImVec2 max = { min.x + textSizes[i].x + tabPadding * 2.0f, min.y + tabHeight};
 
         if (g_categoryIndex == i)
         {
@@ -551,21 +575,23 @@ static bool DrawCategories()
             SetShaderModifier(IMGUI_SHADER_MODIFIER_NONE);
         }
 
-        min.x += textPadding;
-
         // Store to draw again later, otherwise the tab background gets drawn on top of text during the animation.
-        minVec[i] = min; 
+        textPositions[i] = { clipRectMin.x + xOffset, clipRectMin.y };
+        xOffset += textSizes[i].x + textPadding;
     }
 
+    SetScale({ textSquashRatio, 1.0f });
+
     for (size_t i = 0; i < g_categoryCount; i++)
     {
-        auto& min = minVec[i];
+        auto& pos = textPositions[i];
         uint8_t alpha = (i == g_categoryIndex ? 235 : 128) * motion;
-
+        
+        SetOrigin({ pos.x, pos.y });
         SetGradient
         (
-            min,
-            { min.x + textSizes[i].x, min.y + textSizes[i].y },
+            pos,
+            { pos.x + textSizes[i].x, pos.y + textSizes[i].y },
             IM_COL32(128, 255, 0, alpha),
             IM_COL32(255, 192, 0, alpha)
         );
@@ -574,17 +600,19 @@ static bool DrawCategories()
         (
             g_dfsogeistdFont,
             size,
-            min,
+            pos,
             IM_COL32_WHITE,
             GetCategory(i).c_str(),
             4,
             IM_COL32_BLACK,
             IMGUI_SHADER_MODIFIER_CATEGORY_BEVEL
         );
-
-        ResetGradient();
     }
 
+    SetScale({ 1.0f, 1.0f });
+    SetOrigin({ 0.0f, 0.0f });
+    ResetGradient();
+
     if (g_isStage || (ImGui::GetTime() - g_appearTime) >= (CONTAINER_FULL_DURATION / 60.0))
     {
         drawList->PushClipRect({ clipRectMin.x, clipRectMin.y + gridSize * 6.0f }, { clipRectMax.x - gridSize, clipRectMax.y - gridSize });
@@ -601,7 +629,7 @@ static void DrawSelectionArrows(ImVec2 min, ImVec2 max, bool isLeftTapped, bool
     static bool isLeftArrowMotion = false;
     static bool isRightArrowMotion = false;
 
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto gridSize = Scale(GRID_SIZE);
     auto width = gridSize * 2.5f;
     auto padding = gridSize;
@@ -725,7 +753,7 @@ static void DrawConfigOption(int32_t rowIndex, float yOffset, ConfigDef<T>* conf
     bool isAccessible, std::string* inaccessibleReason = nullptr,
     T valueMin = T(0), T valueCenter = T(0.5), T valueMax = T(1), bool isSlider = true)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto clipRectMin = drawList->GetClipRectMin();
     auto clipRectMax = drawList->GetClipRectMax();
     auto& padState = SWA::CInputState::GetInstance()->GetPadState();
@@ -1153,10 +1181,12 @@ static void DrawConfigOption(int32_t rowIndex, float yOffset, ConfigDef<T>* conf
 
 static void DrawConfigOptions()
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto clipRectMin = drawList->GetClipRectMin();
     auto clipRectMax = drawList->GetClipRectMax();
 
+    drawList->PushClipRect({ clipRectMin.x, clipRectMin.y }, { clipRectMax.x, clipRectMax.y - Scale(5.0f) });
+
     g_selectedItem = nullptr;
 
     float gridSize = Scale(GRID_SIZE);
@@ -1178,7 +1208,7 @@ static void DrawConfigOptions()
             DrawConfigOption(rowCount++, yOffset, &Config::Hints, !isStage, cmnReason);
             DrawConfigOption(rowCount++, yOffset, &Config::ControlTutorial, !isStage, cmnReason);
             DrawConfigOption(rowCount++, yOffset, &Config::AchievementNotifications, true);
-            DrawConfigOption(rowCount++, yOffset, &Config::TimeOfDayTransition, true);
+            DrawConfigOption(rowCount++, yOffset, &Config::TimeOfDayTransition, !Config::UseArrowsForTimeOfDayTransition);
             break;
 
         case 1: // INPUT
@@ -1333,13 +1363,15 @@ static void DrawConfigOptions()
     if (disableMoveAnimation)
         g_prevSelectedRowIndex = g_selectedRowIndex;
 
+    drawList->PopClipRect();
+
     // Pop clip rect from DrawCategories
     drawList->PopClipRect();
 
     // Draw scroll bar
     if (rowCount > visibleRowCount)
     {
-        float totalHeight = (clipRectMax.y - clipRectMin.y);
+        float totalHeight = (clipRectMax.y - clipRectMin.y) - Scale(2.0f);
         float heightRatio = float(visibleRowCount) / float(rowCount);
 
         float offsetRatio = float(g_firstVisibleRowIndex) / float(rowCount);
@@ -1351,7 +1383,7 @@ static void DrawConfigOptions()
         drawList->AddRectFilled
         (
             { clipRectMax.x, minY },
-            { clipRectMax.x + gridSize, minY + totalHeight * heightRatio },
+            { clipRectMax.x + gridSize - Scale(1.0f), minY + totalHeight * heightRatio},
             IM_COL32(0, 128, 0, 255)
         );
     }
@@ -1359,7 +1391,7 @@ static void DrawConfigOptions()
 
 static void DrawSettingsPanel(ImVec2 settingsMin, ImVec2 settingsMax)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     SetProceduralOrigin(settingsMin);
     DrawContainer(settingsMin, settingsMax, true);
@@ -1383,7 +1415,7 @@ static void DrawSettingsPanel(ImVec2 settingsMin, ImVec2 settingsMax)
 
 static void DrawInfoPanel(ImVec2 infoMin, ImVec2 infoMax)
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
 
     SetProceduralOrigin(infoMin);
     DrawContainer(infoMin, infoMax, false);
@@ -1402,7 +1434,27 @@ static void DrawInfoPanel(ImVec2 infoMin, ImVec2 infoMax)
         ImVec2 thumbnailMin = { clipRectMin.x, clipRectMin.y + Scale(GRID_SIZE / 2.0f) };
         ImVec2 thumbnailMax = { clipRectMax.x, thumbnailMin.y + thumbnailHeight };
 
-        drawList->AddImage(thumbnail, thumbnailMin, thumbnailMax);
+        if (g_isStage)
+        {
+            drawList->AddImage(thumbnail, thumbnailMin, thumbnailMax);
+        }
+        else
+        {
+            float time = g_appearTime + CONTAINER_FULL_DURATION / 60.0;
+
+            drawList->AddImage(
+                thumbnail,
+                thumbnailMin,
+                thumbnailMax,
+                { 0.0f, 0.0f },
+                { 1.0f, 1.0f },
+                IM_COL32(255, 255, 255, 255 * TVStatic::ComputeThumbnailAlpha(time)));
+
+            TVStatic::Draw(
+                { (thumbnailMin.x + thumbnailMax.x) / 2.0f, (thumbnailMin.y + thumbnailMax.y) / 2.0f },
+                { (thumbnailMax.x - thumbnailMin.x), (thumbnailMax.y - thumbnailMin.y) },
+                time);
+        }
 
         if (g_inaccessibleReason)
         {
@@ -1442,6 +1494,7 @@ static void DrawInfoPanel(ImVec2 infoMin, ImVec2 infoMax)
 
         auto textX = clipRectMin.x - Scale(0.5f);
         auto textY = thumbnailMax.y + offsetY;
+        float lineWidth = clipRectMax.x - clipRectMin.x;
 
         if (Config::Language == ELanguage::Japanese)
         {
@@ -1456,9 +1509,13 @@ static void DrawInfoPanel(ImVec2 infoMin, ImVec2 infoMax)
             clipRectMax.x += annotationFontSize;
 
             textY += annotationFontSize;
+            
+            // Dirty hack to disallow clipping on Japanese text
+            // whilst allowing annotations to go over the border
+            lineWidth -= annotationFontSize;
         }
 
-        auto textSize = MeasureCentredParagraph(g_seuratFont, fontSize, clipRectMax.x - clipRectMin.x, 5.0f, desc.c_str());
+        auto textSize = MeasureCentredParagraph(g_seuratFont, fontSize, lineWidth, 5.0f, desc.c_str());
 
         drawList->PushClipRect(clipRectMin, clipRectMax, false);
 
@@ -1472,23 +1529,19 @@ static void DrawInfoPanel(ImVec2 infoMin, ImVec2 infoMax)
 
         if (scrollMax > 0.0f)
         {
-            if (auto pInputState = SWA::CInputState::GetInstance())
-            {
-                auto& rPadState = pInputState->GetPadState();
-                auto& vert = rPadState.RightStickVertical;
+            auto vert = -g_rightStickY;
         
-                if (fabs(vert) > 0.25f)
-                {
-                    isManualScrolling = true;
-                    scrollOffset += vert * scrollSpeed * App::s_deltaTime;
-                }
-                else if (isManualScrolling && fabs(vert) <= 0.25f)
-                {
-                    isScrolling = false;
-                    isManualScrolling = false;
-                    scrollTimer = 0.0f;
-                    scrollDirection = vert > 0.0f ? 1.0f : -1.0f;
-                }
+            if (fabs(vert) > 0.25f)
+            {
+                isManualScrolling = true;
+                scrollOffset += vert * scrollSpeed * App::s_deltaTime;
+            }
+            else if (isManualScrolling && fabs(vert) <= 0.25f)
+            {
+                isScrolling = false;
+                isManualScrolling = false;
+                scrollTimer = 0.0f;
+                scrollDirection = vert > 0.0f ? 1.0f : -1.0f;
             }
         
             if (!isManualScrolling)
@@ -1532,13 +1585,13 @@ static void DrawInfoPanel(ImVec2 infoMin, ImVec2 infoMax)
             scrollDirection = 1.0f;
         }
 
-        SetVerticalMarqueeFade(clipRectMin, clipRectMax, Scale(24), Lerp(Scale(24), 0.0f, scrollOffset / scrollMax));
+        SetVerticalMarqueeFade({ clipRectMin.x, clipRectMin.y + Scale(5.5f) }, clipRectMax, Scale(10), Scale(10));
 
         DrawRubyAnnotatedText
         (
             g_seuratFont,
             fontSize,
-            clipRectMax.x - clipRectMin.x,
+            lineWidth,
             { textX, textY - scrollOffset },
             5.0f,
             desc.c_str(),
@@ -1580,7 +1633,7 @@ static void SetOptionsMenuVisible(bool isVisible)
 
 static bool DrawMilesElectric()
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto& res = ImGui::GetIO().DisplaySize;
 
     // Compensate for the lack of CSD UI dimming the background.
@@ -1633,7 +1686,7 @@ static bool DrawMilesElectric()
 
 static bool DrawFadeTransition()
 {
-    auto drawList = ImGui::GetForegroundDrawList();
+    auto drawList = ImGui::GetBackgroundDrawList();
     auto& res = ImGui::GetIO().DisplaySize;
 
     auto scaleMotion = ComputeMotion(g_appearTime, 0, MILES_ELECTRIC_SCALE_DURATION);
@@ -1658,6 +1711,8 @@ void OptionsMenu::Init()
     LoadThumbnails();
 
     g_upMilesElectric = LOAD_ZSTD_TEXTURE(g_miles_electric);
+
+    TVStatic::Init();
 }
 
 void OptionsMenu::Draw()
@@ -1678,7 +1733,7 @@ void OptionsMenu::Draw()
 
     if (!g_isClosing)
     {
-        auto drawList = ImGui::GetForegroundDrawList();
+        auto drawList = ImGui::GetBackgroundDrawList();
         auto& res = ImGui::GetIO().DisplaySize;
 
         if (g_isStage)
@@ -1737,16 +1792,16 @@ void OptionsMenu::Open(bool isPause, SWA::EMenuType pauseMenuType)
 
     std::array<Button, 4> buttons =
     {
-        Button(Localise("Common_Switch"), EButtonIcon::LBRB, EButtonAlignment::Left, &g_isControlsVisible),
-        Button(Localise("Common_Reset"), EButtonIcon::X, &g_canReset),
-        Button(Localise("Common_Select"), EButtonIcon::A, &g_isControlsVisible),
-        Button(Localise("Common_Back"), EButtonIcon::B, &g_isControlsVisible)
+        Button("Common_Switch", 115.0f, EButtonIcon::LBRB, EButtonAlignment::Left, &g_isControlsVisible),
+        Button("Common_Reset", 110.0f, EButtonIcon::X, &g_canReset),
+        Button("Common_Select", 115.0f, EButtonIcon::A, &g_isControlsVisible),
+        Button("Common_Back", 65.0f, EButtonIcon::B, &g_isControlsVisible)
     };
     
     ButtonGuide::Open(buttons);
     ButtonGuide::SetSideMargins(250);
 
-    hid::SetProhibitedButtons(XAMINPUT_GAMEPAD_START);
+    hid::SetProhibitedInputs(XAMINPUT_GAMEPAD_START, false, true);
 }
 
 void OptionsMenu::Close()
@@ -1760,7 +1815,7 @@ void OptionsMenu::Close()
         ButtonGuide::Close();
         Config::Save();
 
-        hid::SetProhibitedButtons(0);
+        hid::SetProhibitedInputs();
     }
 
     // Skip Miles Electric animation at main menu.

UnleashedRecomp/ui/options_menu_thumbnails.cpp

@@ -1,14 +1,21 @@
 #include <ui/options_menu_thumbnails.h>
 #include <decompressor.h>
+#include <hid/hid.h>
 
-// TODO (Hyper): lower the resolution of these textures once final.
 #include <res/images/options_menu/thumbnails/achievement_notifications.dds.h>
-#include <res/images/options_menu/thumbnails/allow_background_input.dds.h>
-#include <res/images/options_menu/thumbnails/antialiasing.dds.h>
+#include <res/images/options_menu/thumbnails/allow_background_input_xb.dds.h>
+#include <res/images/options_menu/thumbnails/allow_background_input_ps.dds.h>
+#include <res/images/options_menu/thumbnails/antialiasing_none.dds.h>
+#include <res/images/options_menu/thumbnails/antialiasing_2x.dds.h>
+#include <res/images/options_menu/thumbnails/antialiasing_4x.dds.h>
+#include <res/images/options_menu/thumbnails/antialiasing_8x.dds.h>
 #include <res/images/options_menu/thumbnails/aspect_ratio.dds.h>
 #include <res/images/options_menu/thumbnails/battle_theme.dds.h>
 #include <res/images/options_menu/thumbnails/brightness.dds.h>
-#include <res/images/options_menu/thumbnails/control_tutorial.dds.h>
+#include <res/images/options_menu/thumbnails/channel_stereo.dds.h>
+#include <res/images/options_menu/thumbnails/channel_surround.dds.h>
+#include <res/images/options_menu/thumbnails/control_tutorial_ps.dds.h>
+#include <res/images/options_menu/thumbnails/control_tutorial_xb.dds.h>
 #include <res/images/options_menu/thumbnails/controller_icons.dds.h>
 #include <res/images/options_menu/thumbnails/default.dds.h>
 #include <res/images/options_menu/thumbnails/effects_volume.dds.h>
@@ -24,51 +31,69 @@
 #include <res/images/options_menu/thumbnails/motion_blur_off.dds.h>
 #include <res/images/options_menu/thumbnails/motion_blur_original.dds.h>
 #include <res/images/options_menu/thumbnails/motion_blur_enhanced.dds.h>
-#include <res/images/options_menu/thumbnails/movie_scale_mode.dds.h>
+#include <res/images/options_menu/thumbnails/movie_scale_fit.dds.h>
+#include <res/images/options_menu/thumbnails/movie_scale_fill.dds.h>
 #include <res/images/options_menu/thumbnails/music_attenuation.dds.h>
 #include <res/images/options_menu/thumbnails/music_volume.dds.h>
-#include <res/images/options_menu/thumbnails/resolution_scale.dds.h>
-#include <res/images/options_menu/thumbnails/shadow_resolution_original.dds.h>
 #include <res/images/options_menu/thumbnails/shadow_resolution_x512.dds.h>
 #include <res/images/options_menu/thumbnails/shadow_resolution_x1024.dds.h>
 #include <res/images/options_menu/thumbnails/shadow_resolution_x2048.dds.h>
 #include <res/images/options_menu/thumbnails/shadow_resolution_x4096.dds.h>
 #include <res/images/options_menu/thumbnails/shadow_resolution_x8192.dds.h>
-#include <res/images/options_menu/thumbnails/subtitles.dds.h>
-#include <res/images/options_menu/thumbnails/time_of_day_transition_xbox.dds.h>
-#include <res/images/options_menu/thumbnails/time_of_day_transition_playstation.dds.h>
+#include <res/images/options_menu/thumbnails/time_transition_ps.dds.h>
+#include <res/images/options_menu/thumbnails/time_transition_xb.dds.h>
 #include <res/images/options_menu/thumbnails/transparency_antialiasing_false.dds.h>
 #include <res/images/options_menu/thumbnails/transparency_antialiasing_true.dds.h>
-#include <res/images/options_menu/thumbnails/ui_alignment_mode.dds.h>
+#include <res/images/options_menu/thumbnails/ui_alignment_centre.dds.h>
+#include <res/images/options_menu/thumbnails/ui_alignment_edge.dds.h>
 #include <res/images/options_menu/thumbnails/vertical_camera.dds.h>
 #include <res/images/options_menu/thumbnails/voice_language.dds.h>
-#include <res/images/options_menu/thumbnails/vibration.dds.h>
-#include <res/images/options_menu/thumbnails/vsync.dds.h>
+#include <res/images/options_menu/thumbnails/vibration_ps.dds.h>
+#include <res/images/options_menu/thumbnails/vibration_xb.dds.h>
+#include <res/images/options_menu/thumbnails/vsync_on.dds.h>
+#include <res/images/options_menu/thumbnails/vsync_off.dds.h>
 #include <res/images/options_menu/thumbnails/window_size.dds.h>
 #include <res/images/options_menu/thumbnails/xbox_color_correction.dds.h>
 
 #define VALUE_THUMBNAIL_MAP(type) std::unordered_map<type, std::unique_ptr<GuestTexture>>
 
-static std::unordered_map<std::string_view, std::unique_ptr<GuestTexture>> g_namedThumbnails;
+static std::unique_ptr<GuestTexture> g_defaultThumbnail;
+
+static std::unique_ptr<GuestTexture> g_controlTutorialXBThumbnail;
+static std::unique_ptr<GuestTexture> g_controlTutorialPSThumbnail;
+static std::unique_ptr<GuestTexture> g_vibrationXBThumbnail;
+static std::unique_ptr<GuestTexture> g_vibrationPSThumbnail;
+static std::unique_ptr<GuestTexture> g_backgroundInputXBThumbnail;
+static std::unique_ptr<GuestTexture> g_backgroundInputPSThumbnail;
+
 static std::unordered_map<const IConfigDef*, std::unique_ptr<GuestTexture>> g_configThumbnails;
 
 static VALUE_THUMBNAIL_MAP(ETimeOfDayTransition) g_timeOfDayTransitionThumbnails;
+static VALUE_THUMBNAIL_MAP(EChannelConfiguration) g_channelConfigurationThumbnails;
+static VALUE_THUMBNAIL_MAP(EAntiAliasing) g_msaaAntiAliasingThumbnails;
+static VALUE_THUMBNAIL_MAP(bool) g_vsyncThumbnails;
 static VALUE_THUMBNAIL_MAP(bool) g_transparencyAntiAliasingThumbnails;
 static VALUE_THUMBNAIL_MAP(EShadowResolution) g_shadowResolutionThumbnails;
 static VALUE_THUMBNAIL_MAP(EGITextureFiltering) g_giTextureFilteringThumbnails;
 static VALUE_THUMBNAIL_MAP(EMotionBlur) g_motionBlurThumbnails;
 static VALUE_THUMBNAIL_MAP(bool) g_xboxColorCorrectionThumbnails;
+static VALUE_THUMBNAIL_MAP(ECutsceneAspectRatio) g_cutsceneAspectRatioThumbnails;
+static VALUE_THUMBNAIL_MAP(EUIAlignmentMode) g_uiAlignmentThumbnails;
 
 void LoadThumbnails()
 {
-    g_namedThumbnails["Default"] = LOAD_ZSTD_TEXTURE(g_default);
-    g_namedThumbnails["WindowSize"] = LOAD_ZSTD_TEXTURE(g_window_size);
+    g_defaultThumbnail = LOAD_ZSTD_TEXTURE(g_default);
+
+    g_controlTutorialXBThumbnail = LOAD_ZSTD_TEXTURE(g_control_tutorial_xb);
+    g_controlTutorialPSThumbnail = LOAD_ZSTD_TEXTURE(g_control_tutorial_ps);
+    g_vibrationXBThumbnail = LOAD_ZSTD_TEXTURE(g_vibration_xb);
+    g_vibrationPSThumbnail = LOAD_ZSTD_TEXTURE(g_vibration_ps);
+    g_backgroundInputXBThumbnail = LOAD_ZSTD_TEXTURE(g_allow_background_input_xb);
+    g_backgroundInputPSThumbnail = LOAD_ZSTD_TEXTURE(g_allow_background_input_ps);
 
     g_configThumbnails[&Config::Language] = LOAD_ZSTD_TEXTURE(g_language);
     g_configThumbnails[&Config::VoiceLanguage] = LOAD_ZSTD_TEXTURE(g_voice_language);
-    g_configThumbnails[&Config::Subtitles] = LOAD_ZSTD_TEXTURE(g_subtitles);
     g_configThumbnails[&Config::Hints] = LOAD_ZSTD_TEXTURE(g_hints);
-    g_configThumbnails[&Config::ControlTutorial] = LOAD_ZSTD_TEXTURE(g_control_tutorial);
     g_configThumbnails[&Config::AchievementNotifications] = LOAD_ZSTD_TEXTURE(g_achievement_notifications);
 
     g_timeOfDayTransitionThumbnails[ETimeOfDayTransition::Xbox] = LOAD_ZSTD_TEXTURE(g_time_of_day_transition_xbox);
@@ -76,28 +101,36 @@ void LoadThumbnails()
 
     g_configThumbnails[&Config::HorizontalCamera] = LOAD_ZSTD_TEXTURE(g_horizontal_camera);
     g_configThumbnails[&Config::VerticalCamera] = LOAD_ZSTD_TEXTURE(g_vertical_camera);
-    g_configThumbnails[&Config::Vibration] = LOAD_ZSTD_TEXTURE(g_vibration);
-    g_configThumbnails[&Config::AllowBackgroundInput] = LOAD_ZSTD_TEXTURE(g_allow_background_input);
     g_configThumbnails[&Config::ControllerIcons] = LOAD_ZSTD_TEXTURE(g_controller_icons);
     g_configThumbnails[&Config::MasterVolume] = LOAD_ZSTD_TEXTURE(g_master_volume);
     g_configThumbnails[&Config::MusicVolume] = LOAD_ZSTD_TEXTURE(g_music_volume);
     g_configThumbnails[&Config::EffectsVolume] = LOAD_ZSTD_TEXTURE(g_effects_volume);
+
+    g_channelConfigurationThumbnails[EChannelConfiguration::Stereo] = LOAD_ZSTD_TEXTURE(g_channel_stereo);
+    g_channelConfigurationThumbnails[EChannelConfiguration::Surround] = LOAD_ZSTD_TEXTURE(g_channel_surround);
+
     g_configThumbnails[&Config::MusicAttenuation] = LOAD_ZSTD_TEXTURE(g_music_attenuation);
     g_configThumbnails[&Config::BattleTheme] = LOAD_ZSTD_TEXTURE(g_battle_theme);
     g_configThumbnails[&Config::WindowSize] = LOAD_ZSTD_TEXTURE(g_window_size);
     g_configThumbnails[&Config::Monitor] = LOAD_ZSTD_TEXTURE(g_monitor);
     g_configThumbnails[&Config::AspectRatio] = LOAD_ZSTD_TEXTURE(g_aspect_ratio);
-    g_configThumbnails[&Config::ResolutionScale] = LOAD_ZSTD_TEXTURE(g_resolution_scale);
     g_configThumbnails[&Config::Fullscreen] = LOAD_ZSTD_TEXTURE(g_fullscreen);
-    g_configThumbnails[&Config::VSync] = LOAD_ZSTD_TEXTURE(g_vsync);
+    g_configThumbnails[&Config::XboxColorCorrection] = LOAD_ZSTD_TEXTURE(g_xbox_color_correction);
+
+    g_vsyncThumbnails[false] = LOAD_ZSTD_TEXTURE(g_vsync_off);
+    g_vsyncThumbnails[true] = LOAD_ZSTD_TEXTURE(g_vsync_on);
+
     g_configThumbnails[&Config::FPS] = LOAD_ZSTD_TEXTURE(g_fps);
     g_configThumbnails[&Config::Brightness] = LOAD_ZSTD_TEXTURE(g_brightness);
-    g_configThumbnails[&Config::AntiAliasing] = LOAD_ZSTD_TEXTURE(g_antialiasing);
+
+    g_msaaAntiAliasingThumbnails[EAntiAliasing::None] = LOAD_ZSTD_TEXTURE(g_antialiasing_none);
+    g_msaaAntiAliasingThumbnails[EAntiAliasing::MSAA2x] = LOAD_ZSTD_TEXTURE(g_antialiasing_2x);
+    g_msaaAntiAliasingThumbnails[EAntiAliasing::MSAA4x] = LOAD_ZSTD_TEXTURE(g_antialiasing_4x);
+    g_msaaAntiAliasingThumbnails[EAntiAliasing::MSAA8x] = LOAD_ZSTD_TEXTURE(g_antialiasing_8x);
 
     g_transparencyAntiAliasingThumbnails[false] = LOAD_ZSTD_TEXTURE(g_transparency_antialiasing_false);
     g_transparencyAntiAliasingThumbnails[true] = LOAD_ZSTD_TEXTURE(g_transparency_antialiasing_true);
 
-    g_shadowResolutionThumbnails[EShadowResolution::Original] = LOAD_ZSTD_TEXTURE(g_shadow_resolution_original);
     g_shadowResolutionThumbnails[EShadowResolution::x512] = LOAD_ZSTD_TEXTURE(g_shadow_resolution_x512);
     g_shadowResolutionThumbnails[EShadowResolution::x1024] = LOAD_ZSTD_TEXTURE(g_shadow_resolution_x1024);
     g_shadowResolutionThumbnails[EShadowResolution::x2048] = LOAD_ZSTD_TEXTURE(g_shadow_resolution_x2048);
@@ -111,8 +144,11 @@ void LoadThumbnails()
     g_motionBlurThumbnails[EMotionBlur::Original] = LOAD_ZSTD_TEXTURE(g_motion_blur_original);
     g_motionBlurThumbnails[EMotionBlur::Enhanced] = LOAD_ZSTD_TEXTURE(g_motion_blur_enhanced);
 
-    g_configThumbnails[&Config::XboxColorCorrection] = LOAD_ZSTD_TEXTURE(g_xbox_color_correction);
-    g_configThumbnails[&Config::UIAlignmentMode] = LOAD_ZSTD_TEXTURE(g_ui_alignment_mode);
+    g_cutsceneAspectRatioThumbnails[ECutsceneAspectRatio::Original] = LOAD_ZSTD_TEXTURE(g_movie_scale_fit);
+    g_cutsceneAspectRatioThumbnails[ECutsceneAspectRatio::Unlocked] = LOAD_ZSTD_TEXTURE(g_movie_scale_fill);
+
+    g_uiAlignmentThumbnails[EUIAlignmentMode::Centre] = LOAD_ZSTD_TEXTURE(g_ui_alignment_centre);
+    g_uiAlignmentThumbnails[EUIAlignmentMode::Edge] = LOAD_ZSTD_TEXTURE(g_ui_alignment_edge);
 }
 
 template<typename T>
@@ -124,34 +160,57 @@ bool TryGetValueThumbnail(const IConfigDef* cfg, VALUE_THUMBNAIL_MAP(T)* thumbna
     if (!cfg->GetValue())
         return false;
 
-    auto result = thumbnails->at(*(T*)cfg->GetValue()).get();
+    T value = *(T*)cfg->GetValue();
 
-    if (!result)
-        return false;
+    if constexpr (std::is_same_v<T, EShadowResolution>)
+    {
+        if (value == EShadowResolution::Original)
+            value = EShadowResolution::x1024;
+    }
 
-    *texture = result;
+    auto findResult = thumbnails->find(value);
 
-    return true;
-}
+    if (findResult != thumbnails->end())
+    {
+        *texture = findResult->second.get();
+        return true;
+    }
 
-GuestTexture* GetThumbnail(const std::string_view name)
-{
-    if (!g_namedThumbnails.count(name))
-        return g_namedThumbnails["Default"].get();
-
-    return g_namedThumbnails[name].get();
+    return false;
 }
 
 GuestTexture* GetThumbnail(const IConfigDef* cfg)
 {
-    if (!g_configThumbnails.count(cfg))
+    auto findResult = g_configThumbnails.find(cfg);
+    if (findResult == g_configThumbnails.end())
     {
-        auto texture = g_namedThumbnails["Default"].get();
+        auto texture = g_defaultThumbnail.get();
 
-        if (cfg == &Config::TimeOfDayTransition)
+        bool isPlayStation = Config::ControllerIcons == EControllerIcons::PlayStation;
+
+        if (Config::ControllerIcons == EControllerIcons::Auto)
+            isPlayStation = hid::g_inputDeviceController == hid::EInputDevice::PlayStation;
+
+        if (cfg == &Config::ControlTutorial)
+        {
+            texture = isPlayStation ? g_controlTutorialPSThumbnail.get() : g_controlTutorialXBThumbnail.get();
+        }
+        else if (cfg == &Config::Vibration)
+        {
+            texture = isPlayStation ? g_vibrationPSThumbnail.get() : g_vibrationXBThumbnail.get();
+        }
+        else if (cfg == &Config::AllowBackgroundInput)
+        {
+            texture = isPlayStation ? g_backgroundInputPSThumbnail.get() : g_backgroundInputXBThumbnail.get();
+        }
+        else if (cfg == &Config::TimeOfDayTransition)
         {
             TryGetValueThumbnail<ETimeOfDayTransition>(cfg, &g_timeOfDayTransitionThumbnails, &texture);
         }
+        else if (cfg == &Config::AntiAliasing)
+        {
+            TryGetValueThumbnail<EAntiAliasing>(cfg, &g_msaaAntiAliasingThumbnails, &texture);
+        }
         else if (cfg == &Config::TransparencyAntiAliasing)
         {
             TryGetValueThumbnail<bool>(cfg, &g_transparencyAntiAliasingThumbnails, &texture);
@@ -168,9 +227,29 @@ GuestTexture* GetThumbnail(const IConfigDef* cfg)
         {
             TryGetValueThumbnail<EMotionBlur>(cfg, &g_motionBlurThumbnails, &texture);
         }
+        else if (cfg == &Config::XboxColorCorrection)
+        {
+            TryGetValueThumbnail<bool>(cfg, &g_xboxColorCorrectionThumbnails, &texture);
+        }
+        else if (cfg == &Config::CutsceneAspectRatio)
+        {
+            TryGetValueThumbnail<ECutsceneAspectRatio>(cfg, &g_cutsceneAspectRatioThumbnails, &texture);
+        }
+        else if (cfg == &Config::VSync)
+        {
+            TryGetValueThumbnail<bool>(cfg, &g_vsyncThumbnails, &texture);
+        }
+        else if (cfg == &Config::ChannelConfiguration)
+        {
+            TryGetValueThumbnail<EChannelConfiguration>(cfg, &g_channelConfigurationThumbnails, &texture);
+        }
+        else if (cfg == &Config::UIAlignmentMode)
+        {
+            TryGetValueThumbnail<EUIAlignmentMode>(cfg, &g_uiAlignmentThumbnails, &texture);
+        }
 
         return texture;
     }
 
-    return g_configThumbnails[cfg].get();
+    return findResult->second.get();
 }

UnleashedRecomp/ui/options_menu_thumbnails.h

@@ -5,5 +5,4 @@
 
 void LoadThumbnails();
 
-GuestTexture* GetThumbnail(const std::string_view name);
 GuestTexture* GetThumbnail(const IConfigDef* cfg);

UnleashedRecomp/ui/tv_static.cpp

@@ -0,0 +1,392 @@
+#include "tv_static.h"
+#include "imgui_utils.h"
+
+#include <decompressor.h>
+#include <gpu/video.h>
+#include <patches/aspect_ratio_patches.h>
+#include <res/images/options_menu/options_static.dds.h>
+#include <res/images/options_menu/options_static_flash.dds.h>
+
+namespace
+{
+    struct FloatLinear
+    {
+        float value;
+        float time;
+
+        static float Sample(const FloatLinear& a, const FloatLinear& b, float time)
+        {
+            const float t = std::clamp((time - a.time) / (b.time - a.time), 0.0f, 1.0f);
+            return (b.value - a.value) * t + a.value;
+        }
+    };
+
+    struct FloatHermite
+    {
+        float value;
+        float time;
+        float inTangent;
+        float outTangent;
+
+        static float Sample(const FloatHermite& a, const FloatHermite& b, float time)
+        {
+            const float t = std::clamp((time - a.time) / (b.time - a.time), 0.0f, 1.0f);
+
+            float valueDelta = b.value - a.value;
+            float frameDelta = b.time - a.time;
+
+            float biasSquaric = t * t;
+            float biasCubic = biasSquaric * t;
+
+            float valueCubic = (a.outTangent + a.inTangent) * frameDelta - valueDelta * 2.0f;
+            float valueSquaric = valueDelta * 3.0f - (a.inTangent * 2.0f + a.outTangent) * frameDelta;
+            float valueLinear = frameDelta * a.inTangent;
+
+            return valueCubic * biasCubic + valueSquaric * biasSquaric + valueLinear * t + a.value;
+        }
+    };
+}
+
+template<typename T, size_t N>
+static auto Sample(const std::array<T, N>& keys, float time)
+{
+    T firstKey = keys[0];
+    T lastKey = keys[N - 1];
+
+    if (time < firstKey.time)
+        return firstKey.value;
+
+    if (time > lastKey.time)
+        return lastKey.value;
+
+    size_t keyIndex = 0;
+    for (auto key : keys)
+    {
+        if (key.time >= time)
+            break;
+
+        keyIndex++;
+    }
+
+    if (keyIndex >= N)
+        return keys[N - 1].value;
+
+    return T::Sample(keys[keyIndex - 1], keys[keyIndex], time);
+}
+
+static std::unique_ptr<GuestTexture> g_flashTexture;
+static std::unique_ptr<GuestTexture> g_noiseTexture;
+
+static constexpr float FRAME_OFFSET = 65.0f;
+static constexpr float FRAME_SCALE = 1.0f / 60.0f;
+static constexpr float FRAME_DURATION = 32.0f;
+
+static std::array g_flashScaleX =
+{
+    FloatHermite{ 0,             67 * FRAME_SCALE, 0, 0.673736f },
+    FloatHermite{ 2,             70 * FRAME_SCALE, -0.003465f, -0.682543f },
+    FloatHermite{ 0,             73 * FRAME_SCALE, 0, 0 },
+};
+static std::array g_flashScaleY =
+{
+    FloatHermite{ 0,             67 * FRAME_SCALE, 0, 0.67238f },
+    FloatHermite{ 2,             70 * FRAME_SCALE, -0.001741f, -0.664096f },
+    FloatHermite{ 0,             73 * FRAME_SCALE, 0, 0 },
+};
+static std::array g_flashColor =
+{
+    FloatLinear{  255.0f,        67 * FRAME_SCALE },
+    FloatLinear{  160.0f,        70 * FRAME_SCALE },
+    FloatLinear{  255.0f,        73 * FRAME_SCALE },
+};
+static std::array g_flashAlpha =
+{
+    FloatLinear{  255.0f,        70 * FRAME_SCALE },
+    FloatLinear{  0.0f,          73 * FRAME_SCALE },
+};
+static std::array g_noiseScale =
+{
+    FloatLinear{  0.0f,          70 * FRAME_SCALE },
+    FloatLinear{  1.0f,          75 * FRAME_SCALE },
+};
+static std::array g_noiseTL_gradTL =
+{
+    FloatLinear{  0.0f,          77 * FRAME_SCALE },
+    FloatLinear{ (192 / 255.0f), 85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          90 * FRAME_SCALE },
+};
+static std::array g_noiseTL_gradBL =
+{
+    FloatLinear{  0.0f,          73 * FRAME_SCALE },
+    FloatLinear{ (223 / 255.0f), 85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          94 * FRAME_SCALE },
+};
+static std::array g_noiseTL_gradTR =
+{
+    FloatLinear{  0.0f,          74 * FRAME_SCALE },
+    FloatLinear{ (223 / 255.0f), 85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          93 * FRAME_SCALE },
+};
+static std::array g_noiseTL_gradBR =
+{
+    FloatLinear{  0.0f,          70 * FRAME_SCALE },
+    FloatLinear{  1.0f,          85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          97 * FRAME_SCALE },
+};
+static std::array g_noiseTR_gradTL =
+{
+    FloatLinear{  0.0f,          74 * FRAME_SCALE },
+    FloatLinear{ (223 / 255.0f), 85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          93 * FRAME_SCALE },
+};
+static std::array g_noiseTR_gradBL =
+{
+    FloatLinear{  0.0f,          70 * FRAME_SCALE },
+    FloatLinear{  1.0f,          85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          97 * FRAME_SCALE },
+};
+static std::array g_noiseTR_gradTR =
+{
+    FloatLinear{  0.0f,          77 * FRAME_SCALE },
+    FloatLinear{ (192 / 255.0f), 85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          90 * FRAME_SCALE },
+};
+static std::array g_noiseTR_gradBR =
+{
+    FloatLinear{  0.0f,          73 * FRAME_SCALE },
+    FloatLinear{ (223 / 255.0f), 85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          94 * FRAME_SCALE },
+};
+static std::array g_noiseBL_gradTL =
+{
+    FloatLinear{  0.0f,          73 * FRAME_SCALE },
+    FloatLinear{ (223 / 255.0f), 85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          94 * FRAME_SCALE },
+};
+static std::array g_noiseBL_gradBL =
+{
+    FloatLinear{  0.0f,          77 * FRAME_SCALE },
+    FloatLinear{ (192 / 255.0f), 85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          90 * FRAME_SCALE },
+};
+static std::array g_noiseBL_gradTR =
+{
+    FloatLinear{  0.0f,          70 * FRAME_SCALE },
+    FloatLinear{  1.0f,          85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          97 * FRAME_SCALE },
+};
+static std::array g_noiseBL_gradBR =
+{
+    FloatLinear{  0.0f,          74 * FRAME_SCALE },
+    FloatLinear{ (223 / 255.0f), 85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          93 * FRAME_SCALE },
+};
+static std::array g_noiseBR_gradTL =
+{
+    FloatLinear{  0.0f,          70 * FRAME_SCALE },
+    FloatLinear{  1.0f,          85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          97 * FRAME_SCALE },
+};
+static std::array g_noiseBR_gradBL =
+{
+    FloatLinear{  0.0f,          74 * FRAME_SCALE },
+    FloatLinear{ (223 / 255.0f), 85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          93 * FRAME_SCALE },
+};
+static std::array g_noiseBR_gradTR =
+{
+    FloatLinear{  0.0f,          73 * FRAME_SCALE },
+    FloatLinear{ (223 / 255.0f), 85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          94 * FRAME_SCALE },
+};
+static std::array g_noiseBR_gradBR =
+{
+    FloatLinear{  0.0f,          77 * FRAME_SCALE },
+    FloatLinear{ (192 / 255.0f), 85 * FRAME_SCALE },
+    FloatLinear{  0.0f,          90 * FRAME_SCALE },
+};
+static std::array g_thumbnailAlpha =
+{
+    FloatLinear{  0.0f,          85 * FRAME_SCALE },
+    FloatLinear{  1.0f,          90 * FRAME_SCALE },
+};
+
+static std::pair<ImVec2, ImVec2> ComputeRect(const ImVec2& center, const ImVec2& scale)
+{
+    ImVec2 min = { center.x - scale.x / 2.0f, center.y - scale.y / 2.0f };
+    ImVec2 max = { center.x + scale.x / 2.0f, center.y + scale.y / 2.0f };
+
+    return std::make_pair(min, max);
+}
+
+static void DrawFlash(const ImVec2& center, const ImVec2& resolution, float time)
+{
+    auto drawList = ImGui::GetBackgroundDrawList();
+
+    float baseScale = resolution.y / 135.0f * 100.0f;
+    auto [min, max] = ComputeRect(center, { Sample(g_flashScaleX, time) * baseScale, Sample(g_flashScaleY, time) * baseScale});
+
+    float color = Sample(g_flashColor, time);
+    float alpha = Sample(g_flashAlpha, time);
+
+    drawList->AddImage(g_flashTexture.get(), min, max, { 0.0f, 0.0f }, { 1.0f, 1.0f }, IM_COL32(color, 255, color, alpha));
+}
+
+static void PrimRectUVColorCorners(ImDrawList* This, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min, const ImVec2& uv_max,
+    ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left, bool reverse_order = false)
+{
+    ImVec2 a(p_min), c(p_max), uv_a(uv_min), uv_c(uv_max);
+    ImVec2 b(c.x, a.y), d(a.x, c.y), uv_b(uv_c.x, uv_a.y), uv_d(uv_a.x, uv_c.y);
+
+    if (reverse_order)
+    {
+        ImVec2 _a = a; a = b; b = _a;
+        ImVec2 _c = c; c = d; d = _c;
+
+        ImVec2 _uv_a = uv_a; uv_a = uv_b; uv_b = _uv_a;
+        ImVec2 _uv_c = uv_c; uv_c = uv_d; uv_d = _uv_c;
+    }
+
+    ImDrawIdx idx = (ImDrawIdx)This->_VtxCurrentIdx;
+    This->_IdxWritePtr[0] = idx; This->_IdxWritePtr[1] = (ImDrawIdx)(idx + 1); This->_IdxWritePtr[2] = (ImDrawIdx)(idx + 2);
+    This->_IdxWritePtr[3] = idx; This->_IdxWritePtr[4] = (ImDrawIdx)(idx + 2); This->_IdxWritePtr[5] = (ImDrawIdx)(idx + 3);
+    This->_VtxWritePtr[0].pos = a; This->_VtxWritePtr[0].uv = uv_a; This->_VtxWritePtr[0].col = reverse_order ? col_upr_right : col_upr_left;
+    This->_VtxWritePtr[1].pos = b; This->_VtxWritePtr[1].uv = uv_b; This->_VtxWritePtr[1].col = reverse_order ? col_upr_left : col_upr_right;
+    This->_VtxWritePtr[2].pos = c; This->_VtxWritePtr[2].uv = uv_c; This->_VtxWritePtr[2].col = reverse_order ? col_bot_left : col_bot_right;
+    This->_VtxWritePtr[3].pos = d; This->_VtxWritePtr[3].uv = uv_d; This->_VtxWritePtr[3].col = reverse_order ? col_bot_right : col_bot_left;
+    This->_VtxWritePtr += 4;
+    This->_VtxCurrentIdx += 4;
+    This->_IdxWritePtr += 6;
+}
+
+static void AddImageGradient(ImDrawList* DrawList, ImTextureID user_texture_id, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min, const ImVec2& uv_max,
+    ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left, bool reverse_order = false)
+{
+    if (((col_upr_left | col_upr_right | col_bot_right | col_bot_left) & IM_COL32_A_MASK) == 0)
+        return;
+
+    const bool push_texture_id = user_texture_id && (user_texture_id != DrawList->_CmdHeader.TextureId);
+    if (push_texture_id)
+        DrawList->PushTextureID(user_texture_id);
+
+    DrawList->PrimReserve(6, 4);
+
+    const ImVec2 uv = DrawList->_Data->TexUvWhitePixel;
+
+    PrimRectUVColorCorners(DrawList, p_min, p_max,
+        user_texture_id ? uv_min : uv,
+        user_texture_id ? uv_max : uv,
+        col_upr_left, col_upr_right, col_bot_right, col_bot_left,
+        reverse_order);
+
+    if (push_texture_id)
+        DrawList->PopTextureID();
+}
+
+static void DrawStatic(const ImVec2& center, const ImVec2& resolution, float time)
+{
+    auto drawList = ImGui::GetBackgroundDrawList();
+
+    const float scaleFactor = Sample(g_noiseScale, time);
+
+    const ImVec2 scale2D = { 1, scaleFactor };
+
+    auto [min, max] = ComputeRect(center, {scale2D.x * resolution.x, scale2D.y * resolution.y});
+
+    // Texture pixel size divided by image resolution (which must be divisible by 4) to get proper UV clipping.
+    ImVec2 UV_MAX = { 270.0f / 272.0f,
+                      135.0f / 136.0f };
+
+    // Corner points
+
+    ImVec2 topCenter = { center.x, min.y };
+    ImVec2 bottomCenter = { center.x, max.y };
+
+    ImVec2 centerLeft = { min.x, center.y };
+    ImVec2 centerRight = { max.x, center.y };
+
+    bool flipUV = time >= (73 * FRAME_SCALE);
+
+    const float UV_1 = flipUV ? 0.0f : 1.0f;
+    const float UV_0 = flipUV ? 1.0f : 0.0f;
+
+    // Top Left
+    AddImageGradient(
+        drawList, 
+        g_noiseTexture.get(),
+        min, 
+        center,
+        ImVec2(UV_0 * UV_MAX.x, 0.0f * UV_MAX.y),
+        ImVec2(0.5f * UV_MAX.x, 0.5f * UV_MAX.y),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseTL_gradTL, time)),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseTL_gradTR, time)),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseTL_gradBR, time)),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseTL_gradBL, time)),
+        true);
+
+    // Top Right
+    AddImageGradient(
+        drawList, 
+        g_noiseTexture.get(),
+        topCenter, 
+        centerRight,
+        ImVec2(0.5f * UV_MAX.x, 0.0f * UV_MAX.y),
+        ImVec2(UV_1 * UV_MAX.x, 0.5f * UV_MAX.y),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseTR_gradTL, time)),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseTR_gradTR, time)),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseTR_gradBR, time)),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseTR_gradBL, time)),
+        true);
+
+    // Bottom Right
+    AddImageGradient(
+        drawList, 
+        g_noiseTexture.get(),
+        center,
+        max,
+        ImVec2(0.5f * UV_MAX.x, 0.5f * UV_MAX.y),
+        ImVec2(UV_1 * UV_MAX.x, 1.0f * UV_MAX.y),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseBR_gradTL, time)),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseBR_gradTR, time)),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseBR_gradBR, time)),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseBR_gradBL, time)),
+        true);
+
+    // Bottom Left
+    AddImageGradient(
+        drawList,
+        g_noiseTexture.get(),
+        centerLeft, 
+        bottomCenter,
+        ImVec2(UV_0 * UV_MAX.x, 0.5f * UV_MAX.y),
+        ImVec2(0.5f * UV_MAX.x, 1.0f * UV_MAX.y),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseBL_gradTL, time)),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseBL_gradTR, time)),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseBL_gradBR, time)),
+        IM_COL32(255, 255, 255, 255 * Sample(g_noiseBL_gradBL, time)),
+        true);
+}
+
+void TVStatic::Init()
+{
+    g_flashTexture = LOAD_ZSTD_TEXTURE(g_options_static_flash);
+    g_noiseTexture = LOAD_ZSTD_TEXTURE(g_options_static);
+}
+
+static float ComputeTime(double appearTime)
+{
+    return (ImGui::GetTime() - appearTime) + FRAME_OFFSET * FRAME_SCALE;
+}
+
+float TVStatic::ComputeThumbnailAlpha(double appearTime)
+{
+    return Sample(g_thumbnailAlpha, ComputeTime(appearTime));
+}
+
+void TVStatic::Draw(const ImVec2& center, const ImVec2& resolution, double appearTime)
+{
+    float time = ComputeTime(appearTime);
+
+    DrawStatic(center, resolution, time);
+    DrawFlash(center, resolution, time);
+}

UnleashedRecomp/ui/tv_static.h

@@ -0,0 +1,8 @@
+#pragma once
+
+struct TVStatic
+{
+    static void Init();
+    static float ComputeThumbnailAlpha(double appearTime);
+    static void Draw(const ImVec2& center, const ImVec2& resolution, double appearTime);
+};

UnleashedRecomp/user/config.cpp

@@ -1,7 +1,7 @@
 #include "config.h"
 #include <os/logger.h>
+#include <ui/game_window.h>
 #include <user/paths.h>
-#include <exports.h>
 
 std::vector<IConfigDef*> g_configDefinitions;
 
@@ -302,6 +302,7 @@ CONFIG_DEFINE_ENUM_TEMPLATE(EVoiceLanguage)
 
 CONFIG_DEFINE_ENUM_TEMPLATE(EGraphicsAPI)
 {
+    { "Auto", EGraphicsAPI::Auto },
 #ifdef UNLEASHED_RECOMP_D3D12
     { "D3D12",  EGraphicsAPI::D3D12 },
 #endif
@@ -406,11 +407,6 @@ CONFIG_DEFINE_ENUM_TEMPLATE(EUIAlignmentMode)
     extern CONFIG_ENUM_LOCALE(type) g_##type##_locale; \
     ConfigDef<type> Config::name{section, #name, &g_##name##_locale, defaultValue, &g_##type##_template, &g_##type##_locale};
 
-#undef  CONFIG_DEFINE_CALLBACK
-#define CONFIG_DEFINE_CALLBACK(section, type, name, defaultValue, readCallback) \
-    extern CONFIG_LOCALE g_##name##_locale; \
-    ConfigDef<type> Config::name{section, #name, defaultValue, [](ConfigDef<type>* def) readCallback};
-
 #include "config_def.h"
 
 // CONFIG_DEFINE
@@ -447,13 +443,6 @@ ConfigDef<T, isHidden>::ConfigDef(std::string section, std::string name, CONFIG_
     g_configDefinitions.emplace_back(this);
 }
 
-// CONFIG_DEFINE_CALLBACK
-template<typename T, bool isHidden>
-ConfigDef<T, isHidden>::ConfigDef(std::string section, std::string name, T defaultValue, std::function<void(ConfigDef<T, isHidden>*)> callback) : Section(section), Name(name), DefaultValue(defaultValue), Callback(callback)
-{
-    g_configDefinitions.emplace_back(this);
-}
-
 template<typename T, bool isHidden>
 ConfigDef<T, isHidden>::~ConfigDef() = default;
 
@@ -472,7 +461,7 @@ void ConfigDef<T, isHidden>::ReadValue(toml::v3::ex::parse_result& toml)
 
         if constexpr (std::is_same<T, std::string>::value)
         {
-            Value = section[Name].value_or<std::string>(DefaultValue);
+            Value = section[Name].value_or(DefaultValue);
         }
         else if constexpr (std::is_enum_v<T>)
         {
@@ -522,43 +511,33 @@ std::string_view ConfigDef<T, isHidden>::GetName() const
 template<typename T, bool isHidden>
 std::string ConfigDef<T, isHidden>::GetNameLocalised(ELanguage language) const
 {
-    if (!Locale)
-        return Name;
-
-    if (!Locale->count(language))
+    if (Locale != nullptr)
     {
-        if (Locale->count(ELanguage::English))
-        {
-            return std::get<0>(Locale->at(ELanguage::English));
-        }
-        else
-        {
-            return Name;
-        }
+        auto languageFindResult = Locale->find(language);
+        if (languageFindResult == Locale->end())
+            languageFindResult = Locale->find(ELanguage::English);
+
+        if (languageFindResult != Locale->end())
+            return std::get<0>(languageFindResult->second);
     }
 
-    return std::get<0>(Locale->at(language));
+    return Name;
 }
 
 template<typename T, bool isHidden>
 std::string ConfigDef<T, isHidden>::GetDescription(ELanguage language) const
 {
-    if (!Locale)
-        return "";
-
-    if (!Locale->count(language))
+    if (Locale != nullptr)
     {
-        if (Locale->count(ELanguage::English))
-        {
-            return std::get<1>(Locale->at(ELanguage::English));
-        }
-        else
-        {
-            return "";
-        }
+        auto languageFindResult = Locale->find(language);
+        if (languageFindResult == Locale->end())
+            languageFindResult = Locale->find(ELanguage::English);
+
+        if (languageFindResult != Locale->end())
+            return std::get<1>(languageFindResult->second);
     }
 
-    return std::get<1>(Locale->at(language));
+    return "";
 }
 
 template<typename T, bool isHidden>
@@ -589,27 +568,27 @@ std::string ConfigDef<T, isHidden>::GetValueLocalised(ELanguage language) const
             : Localise("Common_Off");
     }
 
-    if (!locale)
-        return ToString(false);
-
-    if (!locale->count(language))
+    if (locale != nullptr)
     {
-        if (locale->count(ELanguage::English))
+        ELanguage languages[] = { language, ELanguage::English };
+
+        for (auto languageToFind : languages)
         {
-            language = ELanguage::English;
-        }
-        else
-        {
-            return ToString(false);
+            auto languageFindResult = locale->find(languageToFind);
+
+            if (languageFindResult != locale->end())
+            {
+                auto valueFindResult = languageFindResult->second.find(Value);
+                if (valueFindResult != languageFindResult->second.end())
+                    return std::get<0>(valueFindResult->second);
+            }
+
+            if (languageToFind == ELanguage::English)
+                break;
         }
     }
 
-    auto strings = locale->at(language);
-
-    if (!strings.count(Value))
-        return ToString(false);
-
-    return std::get<0>(strings.at(Value));
+    return ToString(false);
 }
 
 template<typename T, bool isHidden>
@@ -626,27 +605,27 @@ std::string ConfigDef<T, isHidden>::GetValueDescription(ELanguage language) cons
         return "";
     }
 
-    if (!locale)
-        return "";
-
-    if (!locale->count(language))
+    if (locale != nullptr)
     {
-        if (locale->count(ELanguage::English))
+        ELanguage languages[] = { language, ELanguage::English };
+
+        for (auto languageToFind : languages)
         {
-            language = ELanguage::English;
-        }
-        else
-        {
-            return "";
+            auto languageFindResult = locale->find(languageToFind);
+
+            if (languageFindResult != locale->end())
+            {
+                auto valueFindResult = languageFindResult->second.find(Value);
+                if (valueFindResult != languageFindResult->second.end())
+                    return std::get<1>(valueFindResult->second);
+            }
+
+            if (languageToFind == ELanguage::English)
+                break;
         }
     }
 
-    auto strings = locale->at(language);
-
-    if (!strings.count(Value))
-        return "";
-
-    return std::get<1>(strings.at(Value));
+    return "";
 }
 
 template<typename T, bool isHidden>
@@ -722,8 +701,54 @@ std::filesystem::path Config::GetConfigPath()
     return GetUserPath() / "config.toml";
 }
 
+void Config::CreateCallbacks()
+{
+    Config::WindowSize.LockCallback = [](ConfigDef<int32_t>* def)
+    {
+        // Try matching the current window size with a known configuration.
+        if (def->Value < 0)
+            def->Value = GameWindow::FindNearestDisplayMode();
+    };
+
+    Config::WindowSize.ApplyCallback = [](ConfigDef<int32_t>* def)
+    {
+        auto displayModes = GameWindow::GetDisplayModes();
+
+        // Use largest supported resolution if overflowed.
+        if (def->Value >= displayModes.size())
+            def->Value = displayModes.size() - 1;
+
+        auto& mode = displayModes[def->Value];
+        auto centre = SDL_WINDOWPOS_CENTERED_DISPLAY(GameWindow::GetDisplay());
+
+        GameWindow::SetDimensions(mode.w, mode.h, centre, centre);
+    };
+
+    Config::Monitor.Callback = [](ConfigDef<int32_t>* def)
+    {
+        GameWindow::SetDisplay(def->Value);
+    };
+
+    Config::Fullscreen.Callback = [](ConfigDef<bool>* def)
+    {
+        GameWindow::SetFullscreen(def->Value);
+        GameWindow::SetDisplay(Config::Monitor);
+    };
+
+    Config::ResolutionScale.Callback = [](ConfigDef<float>* def)
+    {
+        def->Value = std::clamp(def->Value, 0.25f, 2.0f);
+    };
+}
+
 void Config::Load()
 {
+    if (!s_isCallbacksCreated)
+    {
+        CreateCallbacks();
+        s_isCallbacksCreated = true;
+    }
+
     auto configPath = GetConfigPath();
 
     if (!std::filesystem::exists(configPath))
@@ -757,6 +782,8 @@ void Config::Load()
 
 void Config::Save()
 {
+    LOGN("Saving configuration...");
+
     auto userPath = GetUserPath();
 
     if (!std::filesystem::exists(userPath))

UnleashedRecomp/user/config.h

@@ -25,6 +25,10 @@ public:
 #define CONFIG_LOCALE            std::unordered_map<ELanguage, std::tuple<std::string, std::string>>
 #define CONFIG_ENUM_LOCALE(type) std::unordered_map<ELanguage, std::unordered_map<type, std::tuple<std::string, std::string>>>
 
+#define CONFIG_CALLBACK(name)       if (name.Callback) name.Callback(&name)
+#define CONFIG_LOCK_CALLBACK(name)  if (name.LockCallback) name.LockCallback(&name)
+#define CONFIG_APPLY_CALLBACK(name) if (name.ApplyCallback) name.ApplyCallback(&name)
+
 #define WINDOWPOS_CENTRED        0x2FFF0000
 
 extern std::vector<IConfigDef*> g_configDefinitions;
@@ -62,6 +66,7 @@ enum class EChannelConfiguration : uint32_t
 
 enum class EGraphicsAPI : uint32_t
 {
+    Auto,
 #ifdef UNLEASHED_RECOMP_D3D12
     D3D12,
 #endif
@@ -173,9 +178,6 @@ public:
     // CONFIG_DEFINE_ENUM_LOCALISED
     ConfigDef(std::string section, std::string name, CONFIG_LOCALE* nameLocale, T defaultValue, std::unordered_map<std::string, T>* enumTemplate, CONFIG_ENUM_LOCALE(T)* enumLocale);
 
-    // CONFIG_DEFINE_CALLBACK
-    ConfigDef(std::string section, std::string name, T defaultValue, std::function<void(ConfigDef<T, isHidden>*)> callback);
-
     ConfigDef(const ConfigDef&) = delete;
     ConfigDef(ConfigDef&&) = delete;
     ~ConfigDef();
@@ -220,15 +222,17 @@ public:
 #define CONFIG_DEFINE_LOCALISED(section, type, name, defaultValue)              CONFIG_DECLARE(type, name)
 #define CONFIG_DEFINE_ENUM(section, type, name, defaultValue)                   CONFIG_DECLARE(type, name)
 #define CONFIG_DEFINE_ENUM_LOCALISED(section, type, name, defaultValue)         CONFIG_DECLARE(type, name)
-#define CONFIG_DEFINE_CALLBACK(section, type, name, defaultValue, readCallback) CONFIG_DECLARE(type, name)
 
 class Config
 {
 public:
     #include "config_def.h"
 
+    static inline bool s_isCallbacksCreated;
+
     static std::filesystem::path GetConfigPath();
 
+    static void CreateCallbacks();
     static void Load();
     static void Save();
 };

UnleashedRecomp/user/config_def.h

@@ -46,45 +46,22 @@ CONFIG_DEFINE_ENUM_LOCALISED("Audio", EChannelConfiguration, ChannelConfiguratio
 CONFIG_DEFINE_LOCALISED("Audio", bool, MusicAttenuation, false);
 CONFIG_DEFINE_LOCALISED("Audio", bool, BattleTheme, true);
 
-#ifdef UNLEASHED_RECOMP_D3D12
-CONFIG_DEFINE_ENUM("Video", EGraphicsAPI, GraphicsAPI, EGraphicsAPI::D3D12);
-#else
-CONFIG_DEFINE_ENUM("Video", EGraphicsAPI, GraphicsAPI, EGraphicsAPI::Vulkan);
-#endif
-
+CONFIG_DEFINE("Video", std::string, GraphicsDevice, "");
+CONFIG_DEFINE_ENUM("Video", EGraphicsAPI, GraphicsAPI, EGraphicsAPI::Auto);
 CONFIG_DEFINE("Video", int32_t, WindowX, WINDOWPOS_CENTRED);
 CONFIG_DEFINE("Video", int32_t, WindowY, WINDOWPOS_CENTRED);
 CONFIG_DEFINE_LOCALISED("Video", int32_t, WindowSize, -1);
 CONFIG_DEFINE("Video", int32_t, WindowWidth, 1280);
 CONFIG_DEFINE("Video", int32_t, WindowHeight, 720);
 CONFIG_DEFINE_ENUM("Video", EWindowState, WindowState, EWindowState::Normal);
-
-CONFIG_DEFINE_CALLBACK("Video", int32_t, Monitor, 0,
-{
-    def->Locale = &g_Monitor_locale;
-
-    Window_SetDisplay(def->Value);
-});
-
+CONFIG_DEFINE_LOCALISED("Video", int32_t, Monitor, 0);
 CONFIG_DEFINE_ENUM_LOCALISED("Video", EAspectRatio, AspectRatio, EAspectRatio::Auto);
-
-CONFIG_DEFINE_CALLBACK("Video", float, ResolutionScale, 1.0f,
-{
-    def->Locale = &g_ResolutionScale_locale;
-    def->Value = std::clamp(def->Value, 0.25f, 2.0f);
-});
-
-CONFIG_DEFINE_CALLBACK("Video", bool, Fullscreen, true,
-{
-    def->Locale = &g_Fullscreen_locale;
-
-    Window_SetFullscreen(def->Value);
-    Window_SetDisplay(Monitor);
-});
-
+CONFIG_DEFINE_LOCALISED("Video", float, ResolutionScale, 1.0f);
+CONFIG_DEFINE_LOCALISED("Video", bool, Fullscreen, true);
 CONFIG_DEFINE_LOCALISED("Video", bool, VSync, true);
 CONFIG_DEFINE_ENUM("Video", ETripleBuffering, TripleBuffering, ETripleBuffering::Auto);
 CONFIG_DEFINE_LOCALISED("Video", int32_t, FPS, 60);
+CONFIG_DEFINE("Video", bool, ShowFPS, false);
 CONFIG_DEFINE("Video", uint32_t, MaxFrameLatency, 2);
 CONFIG_DEFINE_LOCALISED("Video", float, Brightness, 0.5f);
 CONFIG_DEFINE_ENUM_LOCALISED("Video", EAntiAliasing, AntiAliasing, EAntiAliasing::MSAA4x);
@@ -98,15 +75,22 @@ CONFIG_DEFINE_LOCALISED("Video", bool, XboxColorCorrection, false);
 CONFIG_DEFINE_ENUM_LOCALISED("Video", ECutsceneAspectRatio, CutsceneAspectRatio, ECutsceneAspectRatio::Original);
 CONFIG_DEFINE_ENUM_LOCALISED("Video", EUIAlignmentMode, UIAlignmentMode, EUIAlignmentMode::Edge);
 
-CONFIG_DEFINE_HIDDEN("Exports", bool, AllowCancellingUnleash, false);
-CONFIG_DEFINE_HIDDEN("Exports", bool, DisableAutoSaveWarning, false);
-CONFIG_DEFINE_HIDDEN("Exports", bool, DisableDLCIcon, false);
-CONFIG_DEFINE_HIDDEN("Exports", bool, DisableDWMRoundedCorners, false);
-CONFIG_DEFINE_HIDDEN("Exports", bool, FixUnleashOutOfControlDrain, false);
-CONFIG_DEFINE_HIDDEN("Exports", bool, HomingAttackOnBoost, true);
-CONFIG_DEFINE_HIDDEN("Exports", bool, HUDToggleHotkey, false);
-CONFIG_DEFINE_HIDDEN("Exports", bool, SaveScoreAtCheckpoints, false);
-CONFIG_DEFINE_HIDDEN("Exports", bool, SkipIntroLogos, false);
-CONFIG_DEFINE_HIDDEN("Exports", bool, UseOfficialTitleOnTitleBar, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, AllowCancellingUnleash, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, DisableAutoSaveWarning, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, DisableDLCIcon, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, DisableDWMRoundedCorners, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, EnableEventCollisionDebugView, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, EnableGIMipLevelDebugView, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, EnableObjectCollisionDebugView, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, EnableStageCollisionDebugView, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, FixEggmanlandUsingEventGalleryTransition, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, FixUnleashOutOfControlDrain, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, HomingAttackOnJump, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, HUDToggleKey, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, SaveScoreAtCheckpoints, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, SkipIntroLogos, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, UseArrowsForTimeOfDayTransition, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, UseOfficialTitleOnTitleBar, false);
+CONFIG_DEFINE_HIDDEN("Codes", bool, DisableLowResolutionFontOnCustomUI, false);
 
 CONFIG_DEFINE("Update", time_t, LastChecked, 0);

UnleashedRecompLib/CMakeLists.txt

@@ -28,7 +28,10 @@ endforeach()
 add_custom_command(
     OUTPUT ${UNLEASHED_RECOMP_PPC_RECOMPILED_SOURCES}
     COMMAND $<TARGET_FILE:XenonRecomp>
-    DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/private/default.xex" "${CMAKE_CURRENT_SOURCE_DIR}/config/SWA.toml"
+    DEPENDS 
+        "${CMAKE_CURRENT_SOURCE_DIR}/private/default.xex"
+        "${CMAKE_CURRENT_SOURCE_DIR}/private/default.xexp"
+        "${CMAKE_CURRENT_SOURCE_DIR}/config/SWA.toml"
 )
 
 set(XENOS_RECOMP_ROOT "${UNLEASHED_RECOMP_TOOLS_ROOT}/XenosRecomp/XenosRecomp")

UnleashedRecompLib/config/SWA.toml

@@ -1,5 +1,7 @@
 [main]
 file_path = "../private/default.xex"
+patch_file_path = "../private/default.xexp"
+patched_file_path = "../private/default_patched.xex"
 out_directory_path = "../ppc"
 switch_table_file_path = "SWA_switch_tables.toml"
 
@@ -116,6 +118,72 @@ name = "DisableHintsMidAsmHook"
 address = 0x827A2E34
 jump_address_on_true = 0x827A2E4C
 
+# Disable Egg Dragoon hint "V_WHG_083" ("That lit-up part on the bottom looks fishy. I'll try aiming for that.")
+[[midasm_hook]]
+name = "DisableHintsMidAsmHook"
+address = 0x82AA3224
+jump_address_on_true = 0x82AA3228
+
+# Disable Egg Dragoon hint "V_CHP_057" ("That green round thing looks suspicious! Give it a bonk, Sonic!")
+[[midasm_hook]]
+name = "DisableHintsMidAsmHook"
+address = 0x82AB1A00
+jump_address_on_true = 0x82AB1A04
+
+# Disable Dark Moray hints
+[[midasm_hook]]
+name = "DisableHintsMidAsmHook"
+address = 0x829F7538
+jump_address_on_true = 0x829F753C
+
+# Disable Dark Moray hint "snow_boss_01" ("Ack, Sonic! You're frozen! Move the left stick left and right quickly to break free!")
+[[midasm_hook]]
+name = "DisableHintsMidAsmHook"
+address = 0x829F7C90
+jump_address_on_true = 0x829F7C94
+
+# Disable Dark Guardian hint "V_CHP_051" ("Ooh, ooh! Sonic! What if you took the boxes over to the blue place!")
+[[midasm_hook]]
+name = "DisableHintsMidAsmHook"
+address = 0x82A33008
+jump_address_on_true = 0x82A33054
+
+# Disable Dark Guardian hint "V_CHP_055" ("Looks like those annoying nightmares stay gone for a while if you clear 'em out!")
+[[midasm_hook]]
+name = "DisableHintsMidAsmHook"
+address = 0x82A1DE14
+jump_address_on_true = 0x82A1DE34
+
+# Disable Dark Guardian hint "V_WHG_076" ("I keep beating him down and he gets right back up! There's gotta be a better way.")
+[[midasm_hook]]
+name = "DisableHintsMidAsmHook"
+address = 0x82A260D8
+jump_address_on_true = 0x82A26198
+
+# Disable Dark Guardian hint "V_WHG_078" ("Looks like I can push this box thing.")
+[[midasm_hook]]
+name = "DisableHintsMidAsmHook"
+address = 0x82A2F934
+jump_address_on_true = 0x82A2F94C
+
+# Disable Dark Gaia Phoenix hint "V_WHG_070" ("Ngh! Looks like I can't get at it while it's covered in fire...")
+[[midasm_hook]]
+name = "DisableHintsMidAsmHook"
+address = 0x829D2388
+jump_address_on_true = 0x829D238C
+
+# Disable Dark Gaia Phoenix hint "V_WHG_071" ("Looks like he runs out of breath eventually. That's my chance.")
+[[midasm_hook]]
+name = "DisableHintsMidAsmHook"
+address = 0x829E409C
+jump_address_on_true = 0x829E40A0
+
+# Disable Chip hints for shoe upgrades
+[[midasm_hook]]
+name = "DisableHintsMidAsmHook"
+address = 0x82691CB0
+jump_address_on_true = 0x82691E24
+
 # Disable navigation volumes
 [[midasm_hook]]
 name = "DisableControlTutorialMidAsmHook"
@@ -355,6 +423,11 @@ name = "WerehogBattleMusicMidAsmHook"
 address = 0x82B47728
 registers = ["r11"]
 
+[[midasm_hook]]
+name = "WerehogBattleMusicMidAsmHook"
+address = 0x82B47C58
+registers = ["r11"]
+
 [[midasm_hook]]
 name = "MotionBlurMidAsmHook"
 address = 0x82BA99D0
@@ -522,11 +595,6 @@ address = 0x824B08C0
 registers = ["r3"]
 return_on_true = true
 
-[[midasm_hook]]
-name = "ToggleSubtitlesMidAsmHook"
-address = 0x82B9BB74
-registers = ["r27"]
-
 [[midasm_hook]]
 name = "AchievementManagerUnlockMidAsmHook"
 address = 0x82BCFF28
@@ -548,13 +616,13 @@ jump_address = 0x82585480
 name = "LoadingScreenControllerMidAsmHook"
 address = 0x824DC9D4
 
-# SWA::Player::CPlayerSpeedPostureInputOnPath
+# SWA::Player::CPlayerSpeedPostureInputOnPath / SWA::Player::CPlayerSpeedPostureInputForcePath / SWA::Player::CPlayerSpeedPostureInput2DStandard
 [[midasm_hook]]
 name = "PostureDPadSupportInvertYMidAsmHook"
 address = 0x8234F194
 registers = ["r31", "f13", "f0"]
 
-# SWA::Player::CPlayerSpeedPostureInputOnPathLocal
+# SWA::Player::CPlayerSpeedPostureInputPathLocal
 [[midasm_hook]]
 name = "PostureDPadSupportMidAsmHook"
 address = 0x8234F610
@@ -662,6 +730,12 @@ name = "PostureDPadSupportXMidAsmHook"
 address = 0x8266B6AC
 registers = ["r29", "f0"]
 
+# SWA::Player::CPlayerSpeedStateNormalDamageStandUp / SWA::Player::CSonicStateStartEvent / SWA::Player::CSonicStateStompingLand
+[[midasm_hook]]
+name = "PostureDPadSupportMidAsmHook"
+address = 0x8231F824
+registers = ["r29", "f12", "f13"]
+
 # SWA::Boss::Temple::CTemple (shared)
 [[midasm_hook]]
 name = "PostureDPadSupportMidAsmHook"
@@ -680,6 +754,12 @@ name = "PostureDPadSupportMidAsmHook"
 address = 0x82A7B288
 registers = ["r30", "f13", "f10"]
 
+# SWA::Boss::Temple::CTempleStateBoost / SWA::Boss::Temple::CTempleStateDamage / SWA::Boss::Temple::CTempleStateGuard
+[[midasm_hook]]
+name = "PostureDPadSupportXMidAsmHook"
+address = 0x82A72358
+registers = ["r30", "f13"]
+
 # SWA::Player::CSuperSonicPostureInputSpaceHurrier
 [[midasm_hook]]
 name = "PostureSpaceHurrierDPadSupportXMidAsmHook"
@@ -699,6 +779,30 @@ address = 0x82454104
 registers = ["r29", "f28", "f27"]
 after_instruction = true
 
+# SWA::CBossEggBeetle
+[[midasm_hook]]
+name = "PostureDPadSupportXMidAsmHook"
+address = 0x829A4FCC
+registers = ["r29", "f13"]
+
+# SWA::CBossEggRayBird (horizontal)
+[[midasm_hook]]
+name = "PostureDPadSupportXMidAsmHook"
+address = 0x829BA7E0
+registers = ["r21", "f13"]
+
+# SWA::CBossEggRayBird (vertical)
+[[midasm_hook]]
+name = "PostureDPadSupportYMidAsmHook"
+address = 0x829C53E8
+registers = ["r21", "f13"]
+
+# SWA::CBossEggLancer
+[[midasm_hook]]
+name = "PostureDPadSupportXMidAsmHook"
+address = 0x82A55A48
+registers = ["r21", "f13"]
+
 # SWA::CWorldMapCamera - disable rotation deadzone for touch
 [[midasm_hook]]
 name = "WorldMapDeadzoneMidAsmHook"
@@ -817,6 +921,12 @@ name = "AddPrimitive2DMidAsmHook"
 address = 0x82581C2C
 registers = ["r3"]
 
+# Shop
+[[midasm_hook]]
+name = "AddPrimitive2DMidAsmHook"
+address = 0x82B2BCD8
+registers = ["r3"]
+
 [[midasm_hook]]
 name = "ObjGetItemFieldOfViewMidAsmHook"
 address = 0x82692934
@@ -957,3 +1067,29 @@ registers = ["r3"]
 name = "EvilHudGuideUpdateMidAsmHook"
 address = 0x82449800
 registers = ["r30", "f30"]
+
+[[midasm_hook]]
+name = "SparkleLocusMidAsmHook"
+address = 0x82E96804
+jump_address_on_true = 0x82E96808
+
+# Rooftop Run barrel fix (works at up to ~400 FPS)
+[[midasm_hook]]
+name = "HighFrameRateDeltaTimeFixVectorMidAsmHook"
+address = 0x827673CC
+registers = ["v62"]
+
+[[midasm_hook]]
+name = "BossEggDragoonDrillMissileCMissileSetRotationMidAsmHook"
+address = 0x82A9BADC
+registers = ["r4"]
+
+[[midasm_hook]]
+name = "AnimationDataMakeMidAsmHook"
+address = 0x82BB38E4
+registers = ["r31", "r29", "r28"]
+
+[[midasm_hook]]
+name = "ObjGrindDashPanelAllocMidAsmHook"
+address = 0x82614948
+registers = ["r3"]

flatpak/io.github.hedge_dev.unleashedrecomp.json

@@ -38,6 +38,16 @@
           "path": "private/default.xex",
           "dest": "UnleashedRecompLib/private"
         },
+        {
+          "type": "file",
+          "path": "private/default.xexp",
+          "dest": "UnleashedRecompLib/private"
+        },
+        {
+          "type": "file",
+          "path": "private/default_patched.xex",
+          "dest": "UnleashedRecompLib/private"
+        },
         {
           "type": "file",
           "path": "private/shader.ar",

thirdparty/TinySHA1/TinySHA1.hpp

@@ -1,223 +0,0 @@
-/*
- *
- * TinySHA1 - a header only implementation of the SHA1 algorithm in C++. Based
- * on the implementation in boost::uuid::details.
- *
- * SHA1 Wikipedia Page: http://en.wikipedia.org/wiki/SHA-1
- *
- * Copyright (c) 2012-22 SAURAV MOHAPATRA <mohaps@gmail.com>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- * Taken from https://github.com/mohaps/TinySHA1
- * Modified for use by Xenia
- */
-#ifndef _TINY_SHA1_HPP_
-#define _TINY_SHA1_HPP_
-
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <stdint.h>
-
-namespace sha1 {
-class SHA1 {
- public:
-  typedef uint32_t digest32_t[5];
-  typedef uint8_t digest8_t[20];
-  inline static uint32_t LeftRotate(uint32_t value, size_t count) {
-    return (value << count) ^ (value >> (32 - count));
-  }
-  SHA1() { reset(); }
-  virtual ~SHA1() {}
-  SHA1(const SHA1& s) { *this = s; }
-  const SHA1& operator=(const SHA1& s) {
-    memcpy(m_digest, s.m_digest, 5 * sizeof(uint32_t));
-    memcpy(m_block, s.m_block, 64);
-    m_blockByteIndex = s.m_blockByteIndex;
-    m_byteCount = s.m_byteCount;
-
-    return *this;
-  }
-
-  SHA1& init(const uint32_t digest[5], const uint8_t block[64],
-             uint32_t count) {
-    std::memcpy(m_digest, digest, 20);
-    std::memcpy(m_block, block, count % 64);
-    m_byteCount = count;
-    m_blockByteIndex = count % 64;
-
-    return *this;
-  }
-
-  const uint32_t* getDigest() const { return m_digest; }
-  const uint8_t* getBlock() const { return m_block; }
-  size_t getBlockByteIndex() const { return m_blockByteIndex; }
-  size_t getByteCount() const { return m_byteCount; }
-
-  SHA1& reset() {
-    m_digest[0] = 0x67452301;
-    m_digest[1] = 0xEFCDAB89;
-    m_digest[2] = 0x98BADCFE;
-    m_digest[3] = 0x10325476;
-    m_digest[4] = 0xC3D2E1F0;
-    m_blockByteIndex = 0;
-    m_byteCount = 0;
-    return *this;
-  }
-
-  SHA1& processByte(uint8_t octet) {
-    this->m_block[this->m_blockByteIndex++] = octet;
-    ++this->m_byteCount;
-    if (m_blockByteIndex == 64) {
-      this->m_blockByteIndex = 0;
-      processBlock();
-    }
-
-    return *this;
-  }
-
-  SHA1& processBlock(const void* const start, const void* const end) {
-    const uint8_t* begin = static_cast<const uint8_t*>(start);
-    const uint8_t* finish = static_cast<const uint8_t*>(end);
-    while (begin != finish) {
-      processByte(*begin);
-      begin++;
-    }
-    return *this;
-  }
-
-  SHA1& processBytes(const void* const data, size_t len) {
-    const uint8_t* block = static_cast<const uint8_t*>(data);
-    processBlock(block, block + len);
-    return *this;
-  }
-
-  const uint32_t* finalize(digest32_t digest) {
-    size_t bitCount = this->m_byteCount * 8;
-    processByte(0x80);
-    if (this->m_blockByteIndex > 56) {
-      while (m_blockByteIndex != 0) {
-        processByte(0);
-      }
-      while (m_blockByteIndex < 56) {
-        processByte(0);
-      }
-    } else {
-      while (m_blockByteIndex < 56) {
-        processByte(0);
-      }
-    }
-    processByte(0);
-    processByte(0);
-    processByte(0);
-    processByte(0);
-    processByte(static_cast<unsigned char>((bitCount >> 24) & 0xFF));
-    processByte(static_cast<unsigned char>((bitCount >> 16) & 0xFF));
-    processByte(static_cast<unsigned char>((bitCount >> 8) & 0xFF));
-    processByte(static_cast<unsigned char>((bitCount)&0xFF));
-
-    memcpy(digest, m_digest, 5 * sizeof(uint32_t));
-    return digest;
-  }
-
-  const uint8_t* finalize(digest8_t digest) {
-    digest32_t d32;
-    finalize(d32);
-    size_t di = 0;
-    digest[di++] = ((d32[0] >> 24) & 0xFF);
-    digest[di++] = ((d32[0] >> 16) & 0xFF);
-    digest[di++] = ((d32[0] >> 8) & 0xFF);
-    digest[di++] = ((d32[0]) & 0xFF);
-
-    digest[di++] = ((d32[1] >> 24) & 0xFF);
-    digest[di++] = ((d32[1] >> 16) & 0xFF);
-    digest[di++] = ((d32[1] >> 8) & 0xFF);
-    digest[di++] = ((d32[1]) & 0xFF);
-
-    digest[di++] = ((d32[2] >> 24) & 0xFF);
-    digest[di++] = ((d32[2] >> 16) & 0xFF);
-    digest[di++] = ((d32[2] >> 8) & 0xFF);
-    digest[di++] = ((d32[2]) & 0xFF);
-
-    digest[di++] = ((d32[3] >> 24) & 0xFF);
-    digest[di++] = ((d32[3] >> 16) & 0xFF);
-    digest[di++] = ((d32[3] >> 8) & 0xFF);
-    digest[di++] = ((d32[3]) & 0xFF);
-
-    digest[di++] = ((d32[4] >> 24) & 0xFF);
-    digest[di++] = ((d32[4] >> 16) & 0xFF);
-    digest[di++] = ((d32[4] >> 8) & 0xFF);
-    digest[di++] = ((d32[4]) & 0xFF);
-    return digest;
-  }
-
- protected:
-  void processBlock() {
-    uint32_t w[80];
-    for (size_t i = 0; i < 16; i++) {
-      w[i] = (m_block[i * 4 + 0] << 24);
-      w[i] |= (m_block[i * 4 + 1] << 16);
-      w[i] |= (m_block[i * 4 + 2] << 8);
-      w[i] |= (m_block[i * 4 + 3]);
-    }
-    for (size_t i = 16; i < 80; i++) {
-      w[i] = LeftRotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]), 1);
-    }
-
-    uint32_t a = m_digest[0];
-    uint32_t b = m_digest[1];
-    uint32_t c = m_digest[2];
-    uint32_t d = m_digest[3];
-    uint32_t e = m_digest[4];
-
-    for (std::size_t i = 0; i < 80; ++i) {
-      uint32_t f = 0;
-      uint32_t k = 0;
-
-      if (i < 20) {
-        f = (b & c) | (~b & d);
-        k = 0x5A827999;
-      } else if (i < 40) {
-        f = b ^ c ^ d;
-        k = 0x6ED9EBA1;
-      } else if (i < 60) {
-        f = (b & c) | (b & d) | (c & d);
-        k = 0x8F1BBCDC;
-      } else {
-        f = b ^ c ^ d;
-        k = 0xCA62C1D6;
-      }
-      uint32_t temp = LeftRotate(a, 5) + f + e + k + w[i];
-      e = d;
-      d = c;
-      c = LeftRotate(b, 30);
-      b = a;
-      a = temp;
-    }
-
-    m_digest[0] += a;
-    m_digest[1] += b;
-    m_digest[2] += c;
-    m_digest[3] += d;
-    m_digest[4] += e;
-  }
-
- private:
-  digest32_t m_digest;
-  uint8_t m_block[64];
-  size_t m_blockByteIndex;
-  size_t m_byteCount;
-};
-}
-#endif