cfg: asio driver selector must list both 32-bit and 64-bit drivers (#734 )

## Link to GitHub Issue or related Pull Request, if one exists #730 ## Description of change spicecfg is a 32-bit application. When it uses the ASIO SDK it only saw the 32-bit drivers. There are some ASIO drivers that have different names under 32-bit and 64-bit (Xonar AE is one of them)... so we have to manually scan the registry and surface both the WOW32 and WOW64 nodes. ## Testing <img width="329" height="309" alt="image" src="https://github.com/user-attachments/assets/7abecf76-6835-4df5-8c2e-e7b425130f4c" /> Checked both 32-bit and 64-bit configurator, identical results.
gitadora: (arena model) flip realtek option (#733 )
2026-08-02 14:50:41 -07:00 · 2026-06-05 02:05:03 -07:00 · 2026-06-05 01:38:46 -07:00 · 2026-06-05 00:08:52 -07:00 · 2026-06-04 09:24:44 -07:00 · 2026-06-02 17:47:51 -07:00
306 changed files with 44329 additions and 12446 deletions
@@ -1,8 +1,7 @@
 ## Contributing
 Baseline rules for patch submissions are as follows. Any patches violating the rules below will not be accepted.

-### New as of March 2025
-Pull requests in GitHub are open. You don't need to bother with patch file submissions anymore. To contribute, fork the repo (just the main branch), make changes in your fork, and contribute to upstream by opening a pull request to the main repo.
+To contribute, fork the repo (just the main branch), make changes in your fork, and contribute to upstream by opening a pull request to the main repo.

 ### Adding support for games

@@ -12,6 +11,14 @@ Pull requests in GitHub are open. You don't need to bother with patch file submi
 * For a new game that was never supported (not a new version of a game, but rather a new series): please wait 1 year after official AC release in Japan.
 * For new version of an already supported game: proceed with caution and use generally-accepted community guidelines.

+### Forbidden "features" that will never be accepted
+
+* Performing decryption of encrypted files
+* Including (bundling), distributing, or linking to game data, or making it easier to find/download game data
+* Any features that [phone home](https://en.wikipedia.org/wiki/Phoning_home)
+  * This includes automatic updaters.
+  * Exception: we have allowed the "patch import from URL" feature, but this has only been done under very careful considerations and plenty of warnings to the user.
+
 ### Avoiding regressions

 The biggest risk in making code changes to spice is the risk of regressions. There is a **lot** of shared code used by many different games, reaching back game versions that are more than a decade old. It is practically impossible to test all supported games and versions.
@@ -22,7 +29,7 @@ Therefore, when making code changes, please be extremely careful about containin

 #### Config file compatibility

-Do not change the names of options, buttons binds, analogs, etc - since they are used as unique identifiers in config files. If they are changed, you will introduce an incompatibility with previous versions of config file.
+Do not change the names of buttons binds, analogs, strings for command line parameters, etc - since they are used as unique identifiers in config files. If they are changed, you will introduce an incompatibility with previous versions of config file.

 ### Code quality requirements

@@ -49,6 +56,9 @@ Watch out for legacy OS compatibility. Currently, the minimum support floor is W

 ### Code style requirements
 * Indents are four spaces.
+* Try to keep under 100 characters per line. This includes comments and string literals.
+* Avoid making unnecessary formatting or whitespace changes in a PR; e.g., watch out for text editor automatically stripping trailing whitespace. It pollutes the diff and slows down code review.
+* For signed/unsigned integer types, prefer `cstdint` types; e.g., use `int32_t`, `uint64_t` and not `int` and `unsigned long long`.
 * Always use \{ curly braces \} when appropriate; do not omit them even when it's optional; such as `for` `if` `else`, etc.

 OK:
@@ -7,7 +7,7 @@
 > 
 > Feel free to remove this section after you have read it.

-## Link to GitHub Issue, if one exists
+## Link to GitHub Issue or related Pull Request, if one exists
 #0

 ## Description of change
@@ -109,6 +109,12 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    # RapidJSON does this
    add_compile_definitions(_SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING)

+    add_compile_options("-Wno-nontrivial-memcall") # imgui, rapidjson
+    add_compile_options("-Wno-deprecated-builtins") # robin_hood
+    add_compile_options("-Wno-deprecated-declarations") # rapidjson
+    add_compile_options("-Wno-inconsistent-missing-override") # headsocket
+    add_compile_options("-Wno-microsoft-exception-spec") # gcc/clang have different noexcept specifiers on d3d9 COM interfaces
+
    # warnings
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wunknown-warning-option")

@@ -118,6 +124,9 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static")
 else()

+    # warnings as errors
+    set(CMAKE_COMPILE_WARNING_AS_ERROR ON)
+
    # warnings
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra") # enable stuff
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-pointer-arith") # but we love pointer arithmetic :)
@@ -167,8 +176,8 @@ else()
        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DNDEBUG")

        # file prefix map for relative working directory
-        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ffile-prefix-map=${CMAKE_SOURCE_DIR}=.")
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffile-prefix-map=${CMAKE_SOURCE_DIR}=.")
+        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ffile-prefix-map=\"${CMAKE_SOURCE_DIR}=.\"")
+        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffile-prefix-map=\"${CMAKE_SOURCE_DIR}=.\"")
    endif()

    # release with debug info flags
@@ -226,6 +235,13 @@ add_compile_definitions(
        _WIN32_IE=0x0400
 )

+# SPICE_XP: set by build_all.sh for the WinXP-compat toolchains. Gates out
+# the DX11 overlay backend (WinXP lacks D3DCOMPILER_47.dll).
+option(SPICE_XP "Build for the WinXP-compat toolchain" OFF)
+if(SPICE_XP)
+    add_compile_definitions(SPICE_XP=1)
+endif()
+
 # acioemu log
 #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DACIOEMU_LOG")

@@ -257,6 +273,7 @@ set_source_files_properties(cfg/manifest.rc PROPERTIES LANGUAGE RC)
 set_source_files_properties(cfg/icon.rc PROPERTIES LANGUAGE RC)
 set_source_files_properties(cfg/Win32D.rc PROPERTIES LANGUAGE RC)
 set_source_files_properties(build/manifest64.rc PROPERTIES LANGUAGE RC)
+set_source_files_properties(stubs/manifest.rc PROPERTIES LANGUAGE RC)

 # sources
 #########
@@ -343,6 +360,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
        cfg/configurator.cpp
        cfg/configurator_wnd.cpp
        cfg/screen_resize.cpp
+        cfg/controller_presets.cpp

        # easrv
        easrv/easrv.cpp
@@ -372,6 +390,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
        games/shared/twtouch.cpp
        games/popn/popn.cpp
        games/popn/io.cpp
+        games/popn/bi3a_hook.cpp
        games/bbc/bbc.cpp
        games/bbc/io.cpp
        games/hpm/hpm.cpp
@@ -397,7 +416,12 @@ set(SOURCE_FILES ${SOURCE_FILES}
        games/nost/io.cpp
        games/nost/poke.cpp
        games/gitadora/gitadora.cpp
+        games/gitadora/asio.cpp
        games/gitadora/io.cpp
+        games/gitadora/handle.cpp
+        games/gitadora/j32d.cpp
+        games/gitadora/j33i.cpp
+        games/gitadora/bi2x_hook.cpp
        games/mga/mga.cpp
        games/mga/io.cpp
        games/mga/gunio.cpp
@@ -434,6 +458,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
        games/scotto/io.cpp
        games/drs/drs.cpp
        games/drs/io.cpp
+        games/drs/rgb_cam.cpp
        games/we/we.cpp
        games/we/io.cpp
        games/we/touchpanel.cpp
@@ -469,14 +494,22 @@ set(SOURCE_FILES ${SOURCE_FILES}
        # hooks
        hooks/audio/acm.cpp
        hooks/audio/audio.cpp
+        hooks/audio/asio_driver_scan.cpp
+        hooks/audio/asio_proxy.cpp
        hooks/audio/buffer.cpp
+        hooks/audio/mme.cpp
        hooks/audio/util.cpp
        hooks/audio/backends/dsound/dsound_backend.cpp
        hooks/audio/backends/mmdevice/audio_endpoint_volume.cpp
        hooks/audio/backends/mmdevice/device.cpp
+        hooks/audio/backends/mmdevice/device_collection.cpp
        hooks/audio/backends/mmdevice/device_enumerator.cpp
+        hooks/audio/backends/mmdevice/null_device.cpp
+        hooks/audio/backends/mmdevice/null_discard_backend.cpp
        hooks/audio/backends/wasapi/audio_client.cpp
        hooks/audio/backends/wasapi/audio_render_client.cpp
+        hooks/audio/backends/wasapi/downmix.cpp
+        hooks/audio/backends/wasapi/resample.cpp
        hooks/audio/backends/wasapi/dummy_audio_client.cpp
        hooks/audio/backends/wasapi/dummy_audio_clock.cpp
        hooks/audio/backends/wasapi/dummy_audio_render_client.cpp
@@ -498,12 +531,19 @@ set(SOURCE_FILES ${SOURCE_FILES}
        hooks/graphics/backends/d3d9/d3d9_fake_swapchain.cpp
        hooks/graphics/backends/d3d9/d3d9_swapchain.cpp
        hooks/graphics/backends/d3d9/d3d9_texture.cpp
+        hooks/graphics/backends/d3d11/d3d11_backend.cpp
+        hooks/graphics/backends/d3d11/d3d11_swapchain.cpp
+        hooks/graphics/backends/d3d11/d3d11_factory.cpp
+        hooks/graphics/backends/d3d11/d3d11_vtable_capture.cpp
+        hooks/graphics/backends/d3d11/d3d11_screenshot.cpp
        hooks/input/dinput8/fake_backend.cpp
        hooks/input/dinput8/fake_device.cpp
        hooks/input/dinput8/hook.cpp
        hooks/lang.cpp
        hooks/libraryhook.cpp
        hooks/networkhook.cpp
+        hooks/icmphook_net.cpp
+        hooks/icmphook_iphlpapi.cpp
        hooks/powrprof.cpp
        #hooks/rom.cpp
        hooks/setupapihook.cpp
@@ -530,12 +570,14 @@ set(SOURCE_FILES ${SOURCE_FILES}
        misc/sciunit.cpp
        misc/sde.cpp
        misc/wintouchemu.cpp
+        misc/ami2000.cpp

        # nvapi
        nvapi/nvapi.cpp

        # overlay
        overlay/overlay.cpp
+        overlay/notifications.cpp
        overlay/window.cpp
        overlay/imgui/extensions.cpp
        overlay/imgui/impl_spice.cpp
@@ -544,9 +586,11 @@ set(SOURCE_FILES ${SOURCE_FILES}
        overlay/windows/camera_control.cpp
        overlay/windows/card_manager.cpp
        overlay/windows/drs_dancefloor.cpp
+        overlay/windows/gfdm_sub.cpp
        overlay/windows/screen_resize.cpp
        overlay/windows/sdvx_sub.cpp
        overlay/windows/config.cpp
+        overlay/windows/controller_presets.cpp
        overlay/windows/control.cpp
        overlay/windows/eadev.cpp
        overlay/windows/fps.cpp
@@ -561,6 +605,7 @@ set(SOURCE_FILES ${SOURCE_FILES}
        overlay/windows/log.cpp
        overlay/windows/midi.cpp
        overlay/windows/patch_manager.cpp
+        overlay/windows/popn_sub.cpp
        overlay/windows/wnd_manager.cpp

        # rawinput
@@ -575,6 +620,8 @@ set(SOURCE_FILES ${SOURCE_FILES}
        rawinput/smxstage.h
        rawinput/smxdedicab.cpp
        rawinput/smxdedicab.h
+        rawinput/xinput.cpp
+        rawinput/xinput.h

        # reader
        reader/reader.cpp
@@ -582,6 +629,9 @@ set(SOURCE_FILES ${SOURCE_FILES}
        reader/structuredmessage.cpp
        reader/crypt.cpp

+        # sdk
+        sdk/sdk.cpp
+
        # stubs
        stubs/stubs.cpp

@@ -608,12 +658,14 @@ set(SOURCE_FILES ${SOURCE_FILES}
        util/time.cpp
        util/cpuutils.cpp
        util/netutils.cpp
+        util/precise_timer.cpp
        util/sysutils.cpp
        util/lz77.cpp
        util/tapeled.cpp
        util/execexe.cpp
        util/dependencies.cpp
        util/deferlog.cpp
+        util/socd_cleaner.cpp
 )

 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "Source Files" FILES ${SOURCE_FILES})
@@ -681,6 +733,10 @@ target_link_libraries(spicetools_spice64 PUBLIC winscard)
 set_target_properties(spicetools_spice64 PROPERTIES PREFIX "")
 set_target_properties(spicetools_spice64 PROPERTIES OUTPUT_NAME "spice64")
 target_compile_definitions(spicetools_spice64 PRIVATE SPICE64=1)
+if(NOT SPICE_XP)
+    target_link_libraries(spicetools_spice64 PUBLIC d3d11 dxgi d3dcompiler)
+    target_compile_definitions(spicetools_spice64 PRIVATE SPICE_D3D11=1)
+endif()

 IF(NOT MSVC)
    set_target_properties(spicetools_spice64 PROPERTIES COMPILE_FLAGS "-m64" LINK_FLAGS "-m64")
@@ -700,6 +756,9 @@ set_target_properties(spicetools_spice64_linux PROPERTIES PREFIX "")
 set_target_properties(spicetools_spice64_linux PROPERTIES OUTPUT_NAME "spice64_linux")
 target_compile_definitions(spicetools_spice64_linux PRIVATE SPICE64=1)
 target_compile_definitions(spicetools_spice64_linux PRIVATE NO_SCARD=1 PRIVATE SPICE_LINUX=1)
+# spice64_linux is never built under the WinXP toolchain, so dx11 is always on.
+target_link_libraries(spicetools_spice64_linux PUBLIC d3d11 dxgi d3dcompiler)
+target_compile_definitions(spicetools_spice64_linux PRIVATE SPICE_D3D11=1)

 IF(NOT MSVC)
    set_target_properties(spicetools_spice64_linux PROPERTIES COMPILE_FLAGS "-m64" LINK_FLAGS "-m64")
@@ -712,7 +771,7 @@ set(SOURCE_FILES ${SOURCE_FILES} launcher/options.h launcher/options.cpp)
 set(RESOURCE_FILES cfg/manifest.manifest cfg/manifest.rc cfg/icon.rc cfg/Win32D.rc)
 add_executable(spicetools_cfg WIN32 ${SOURCE_FILES} ${RESOURCE_FILES})
 target_link_libraries(spicetools_cfg
-        PUBLIC ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp strmiids
+        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp strmiids
        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features)
 target_link_libraries(spicetools_cfg PUBLIC winscard)
 set_target_properties(spicetools_cfg PROPERTIES PREFIX "")
@@ -730,7 +789,7 @@ set(SOURCE_FILES ${SOURCE_FILES} launcher/options.h launcher/options.cpp)
 set(RESOURCE_FILES cfg/manifest.manifest cfg/manifest.rc cfg/icon.rc cfg/Win32D.rc)
 add_executable(spicetools_cfg_linux WIN32 ${SOURCE_FILES} ${RESOURCE_FILES})
 target_link_libraries(spicetools_cfg_linux
-        PUBLIC ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp strmiids
+        PUBLIC d3d9 ws2_32 version comctl32 shlwapi iphlpapi hid secur32 setupapi psapi winmm winhttp strmiids
        PRIVATE fmt::fmt-header-only discord-rpc imgui hash-library minhook imm32 dwmapi CpuFeatures::cpu_features)
 set_target_properties(spicetools_cfg_linux PROPERTIES PREFIX "")
 set_target_properties(spicetools_cfg_linux PROPERTIES OUTPUT_NAME "spicecfg_linux")
@@ -792,7 +851,8 @@ endif()

 # nvcuda.dll
 set(SOURCE_FILES stubs/nvcuda.cpp)
-add_library(spicetools_stubs_nvcuda SHARED ${SOURCE_FILES} stubs/nvcuda.def)
+set(RESOURCE_FILES stubs/manifest.rc)
+add_library(spicetools_stubs_nvcuda SHARED ${SOURCE_FILES} ${RESOURCE_FILES} stubs/nvcuda.def)
 set_target_properties(spicetools_stubs_nvcuda PROPERTIES PREFIX "")
 set_target_properties(spicetools_stubs_nvcuda PROPERTIES OUTPUT_NAME "nvcuda")

@@ -802,7 +862,8 @@ endif()

 # nvcuvid.dll
 set(SOURCE_FILES stubs/nvcuvid.cpp)
-add_library(spicetools_stubs_nvcuvid SHARED ${SOURCE_FILES} stubs/nvcuvid.def)
+set(RESOURCE_FILES stubs/manifest.rc)
+add_library(spicetools_stubs_nvcuvid SHARED ${SOURCE_FILES} ${RESOURCE_FILES} stubs/nvcuvid.def)
 set_target_properties(spicetools_stubs_nvcuvid PROPERTIES PREFIX "")
 set_target_properties(spicetools_stubs_nvcuvid PROPERTIES OUTPUT_NAME "nvcuvid")

@@ -812,7 +873,8 @@ endif()

 # nvEncodeAPI64.dll
 set(SOURCE_FILES stubs/nvEncodeAPI64.cpp)
-add_library(spicetools_stubs_nvEncodeAPI64 SHARED ${SOURCE_FILES} stubs/nvEncodeAPI64.def)
+set(RESOURCE_FILES stubs/manifest.rc)
+add_library(spicetools_stubs_nvEncodeAPI64 SHARED ${SOURCE_FILES} ${RESOURCE_FILES} stubs/nvEncodeAPI64.def)
 set_target_properties(spicetools_stubs_nvEncodeAPI64 PROPERTIES PREFIX "")
 set_target_properties(spicetools_stubs_nvEncodeAPI64 PROPERTIES OUTPUT_NAME "nvEncodeAPI64")

@@ -822,7 +884,8 @@ endif()

 # cpusbxpkm.dll (32 bit)
 set(SOURCE_FILES stubs/cpusbxpkm.cpp)
-add_library(spicetools_stubs_cpusbxpkm SHARED ${SOURCE_FILES} stubs/cpusbxpkm.def)
+set(RESOURCE_FILES stubs/manifest.rc)
+add_library(spicetools_stubs_cpusbxpkm SHARED ${SOURCE_FILES} ${RESOURCE_FILES} stubs/cpusbxpkm.def)
 set_target_properties(spicetools_stubs_cpusbxpkm PROPERTIES PREFIX "")
 set_target_properties(spicetools_stubs_cpusbxpkm PROPERTIES OUTPUT_NAME "cpusbxpkm")

@@ -830,6 +893,36 @@ if(NOT MSVC)
    set_target_properties(spicetools_stubs_cpusbxpkm PROPERTIES COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")
 endif()

+# sdk_sample_v0_flat_c.dll (32 bit)
+set(SOURCE_FILES sdk/sample/v0/flat_c/v0_flat_c.c)
+add_library(spicetools_sdk_sample_v0_flat_c_32 SHARED ${SOURCE_FILES} ${RESOURCE_FILES} sdk/sample/v0/flat_c/v0_flat_c.def)
+set_target_properties(spicetools_sdk_sample_v0_flat_c_32 PROPERTIES PREFIX "")
+set_target_properties(spicetools_sdk_sample_v0_flat_c_32 PROPERTIES OUTPUT_NAME "sdk_sample_v0_flat_c")
+
+if(NOT MSVC)
+    set_target_properties(spicetools_sdk_sample_v0_flat_c_32 PROPERTIES COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")
+endif()
+
+# sdk_sample_v0_flat_c.dll (64 bit)
+set(SOURCE_FILES sdk/sample/v0/flat_c/v0_flat_c.c)
+add_library(spicetools_sdk_sample_v0_flat_c_64 SHARED ${SOURCE_FILES} ${RESOURCE_FILES} sdk/sample/v0/flat_c/v0_flat_c.def)
+set_target_properties(spicetools_sdk_sample_v0_flat_c_64 PROPERTIES PREFIX "")
+set_target_properties(spicetools_sdk_sample_v0_flat_c_64 PROPERTIES OUTPUT_NAME "sdk_sample_v0_flat_c")
+
+if(NOT MSVC)
+    set_target_properties(spicetools_sdk_sample_v0_flat_c_64 PROPERTIES COMPILE_FLAGS "-m64" LINK_FLAGS "-m64")
+endif()
+
+# sdk_sample_v0_cpp.dll (64 bit)
+set(SOURCE_FILES sdk/sample/v0/cpp/v0_cpp.cpp)
+add_library(spicetools_sdk_sample_v0_cpp_64 SHARED ${SOURCE_FILES} ${RESOURCE_FILES} sdk/sample/v0/cpp/v0_cpp.def)
+set_target_properties(spicetools_sdk_sample_v0_cpp_64 PROPERTIES PREFIX "")
+set_target_properties(spicetools_sdk_sample_v0_cpp_64 PROPERTIES OUTPUT_NAME "sdk_sample_v0_cpp")
+
+if(NOT MSVC)
+    set_target_properties(spicetools_sdk_sample_v0_cpp_64 PROPERTIES COMPILE_FLAGS "-m64" LINK_FLAGS "-m64")
+endif()
+
 # output directories
 ####################

@@ -839,14 +932,14 @@ set_target_properties(spicetools_cfg spicetools_cfg_linux
        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/spicetools")

 # output 32bit
-set_target_properties(spicetools_spice spicetools_spice_laa spicetools_spice_linux spicetools_stubs_kbt spicetools_stubs_kld spicetools_stubs_cpusbxpkm
+set_target_properties(spicetools_spice spicetools_spice_laa spicetools_spice_linux spicetools_stubs_kbt spicetools_stubs_kld spicetools_stubs_cpusbxpkm spicetools_sdk_sample_v0_flat_c_32
        PROPERTIES
        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/archive32"
        LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/spicetools/32"
        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/spicetools/32")

 # output 64bit
-set_target_properties(spicetools_spice64 spicetools_spice64_linux spicetools_stubs_kbt64 spicetools_stubs_kld64 spicetools_stubs_nvcuda spicetools_stubs_nvcuvid spicetools_stubs_nvEncodeAPI64
+set_target_properties(spicetools_spice64 spicetools_spice64_linux spicetools_stubs_kbt64 spicetools_stubs_kld64 spicetools_stubs_nvcuda spicetools_stubs_nvcuvid spicetools_stubs_nvEncodeAPI64 spicetools_sdk_sample_v0_flat_c_64 spicetools_sdk_sample_v0_cpp_64
        PROPERTIES
        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/archive64"
        LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/spicetools/64"
@@ -283,6 +283,16 @@ Python is the only one that is fully spec compliant.
 Other libraries may be missing features and contain bugs; please feel free to
 contribute code to fill the gaps if you work on a project using these libraries.

+## Spice SDK (for DLL hooks / plugins)
+
+As an alternative to Spice API, Spice SDK is available.
+
+This is a flat C, header-only library that can be included in your DLL. Once
+initialized, you can call directly into helper routines provided by Spicetools
+executable, making low-latency and high-throughput interactions possible.
+
+Check the documentation on the wiki for more details.
+
 ## License
 Unless otherwise noted, all files are licensed under the GPLv3.
 See the LICENSE file for the full license text.
@@ -9,11 +9,22 @@
 #include "games/drs/drs.h"
 #include "misc/eamuse.h"
 #include "util/logging.h"
+#include "util/socd_cleaner.h"
+#include "util/time.h"
 #include "util/utils.h"
 #include "util/tapeled.h"

 using namespace GameAPI;

+#define DEBUG_VERBOSE 0
+
+#if DEBUG_VERBOSE
+#define log_debug(module, format_str, ...) logger::push( \
+    LOG_FORMAT("M", module, format_str, ## __VA_ARGS__), logger::Style::GREY)
+#else
+#define log_debug(module, format_str, ...)
+#endif
+
 // state
 static uint8_t STATUS_BUFFER[272] {};
 static bool STATUS_BUFFER_FREEZE = false;
@@ -94,18 +105,25 @@ static bool __cdecl ac_io_bi2a_update_control_status_buffer() {
        }

        // volume left
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Left))) {
+        const auto now = get_performance_milliseconds();
+        const auto vol_l_state = socd::socd_clean(0,
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Left)),
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Right)),
+            now);
+        if (vol_l_state == socd::SocdCCW) {
            BI2A_VOLL = (BI2A_VOLL - games::sdvx::DIGITAL_KNOB_SENS) & 1023;
-        }
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Right))) {
+        } else if (vol_l_state == socd::SocdCW) {
            BI2A_VOLL = (BI2A_VOLL + games::sdvx::DIGITAL_KNOB_SENS) & 1023;
        }

        // volume right
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Left))) {
+        const auto vol_r_state = socd::socd_clean(1,
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Left)),
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Right)),
+            now);
+        if (vol_r_state == socd::SocdCCW) {
            BI2A_VOLR = (BI2A_VOLR - games::sdvx::DIGITAL_KNOB_SENS) & 1023;
-        }
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Right))) {
+        } else if (vol_r_state == socd::SocdCW) {
            BI2A_VOLR = (BI2A_VOLR + games::sdvx::DIGITAL_KNOB_SENS) & 1023;
        }

@@ -127,6 +145,12 @@ static bool __cdecl ac_io_bi2a_update_control_status_buffer() {
        // save volumes in buffer
        *((uint16_t*) &STATUS_BUFFER[17]) = (uint16_t) ((vol_left) << 2);
        *((uint16_t*) &STATUS_BUFFER[19]) = (uint16_t) ((vol_right) << 2);
+
+        log_debug(
+            "bi2a",
+            "knobs = {} {}",
+            *((uint16_t*) &STATUS_BUFFER[17]),
+            *((uint16_t*) &STATUS_BUFFER[19]));
    }

    // DanceDanceRevolution
@@ -35,24 +35,33 @@ struct ICCA_STATUS_LA9 {
 static_assert(sizeof(struct ICCA_STATUS) == 24, "ICCA_STATUS must be 24 bytes");

 enum ICCA_WORKFLOW {
-    STEP,
-    SLEEP,
-    START,
-    INIT,
-    READY,
-    GET_USERID,
-    ACTIVE,
-    EJECT,
-    EJECT_CHECK,
-    END,
-    CLOSE_EJECT,
-    CLOSE_E_CHK,
-    CLOSE_END,
-    ERR_GETUID = -2
+    STEP = 0,
+    SLEEP = 1,
+    START = 2,
+    INIT = 3,
+    READY = 4,
+    GET_USERID = 5,
+    ACTIVE = 6,
+    EJECT = 7,
+    EJECT_CHECK = 8,
+    END = 9,
+    CLOSE_EJECT = 10,
+    CLOSE_E_CHK = 11,
+    CLOSE_END = 12,
+    ERR_GETUID = -2,
+    ERR_REMOVED = -11
 };
+
+// used by RA as the status_code
+enum ICCA_STATUS_CODE {
+    EMPTY = 1,
+    ENGAGED = 2
+};
+
 struct ICCA_UNIT {
    struct ICCA_STATUS status {};
    enum ICCA_WORKFLOW state = STEP;
+    enum ICCA_WORKFLOW state_jdz = SLEEP;
    bool card_cmd_pressed = false;
    bool card_in = false;
    double card_in_time = 0.0;
@@ -75,6 +84,11 @@ static inline int icca_get_active_count() {
 }

 static inline int icca_get_unit_id(int unit_id) {
+    // on RA the unit_id is zero-indexed
+    if (avs::game::is_model("JDZ")) {
+        return unit_id;
+    }
+
    if (icca_get_active_count() < 2)
        return 1;
    else {
@@ -122,9 +136,15 @@ static inline void update_card(int unit_id) {
                    IS_LAST_CARD_FELICA = is_card_uid_felica(unit->status.uid);

                    unit->state = acio::ICCA_COMPAT_ACTIVE ? START : ACTIVE;
+                    unit->state_jdz = ACTIVE;
                    unit->status.error = 0;
+                    unit->status.front_sensor = 1;
+                    unit->status.rear_sensor = 1;
                } else {
                    unit->state = ERR_GETUID;
+                    unit->state_jdz = ERR_GETUID;
+                    unit->status.front_sensor = 1;
+                    unit->status.rear_sensor = 1;
                    memset(unit->status.uid, 0, 8);
                }
                unit->card_in = true;
@@ -132,10 +152,25 @@ static inline void update_card(int unit_id) {
            } else if (unit->state == EJECT_CHECK) {
                unit->state = SLEEP;
                unit->card_in = false;
+                unit->status.front_sensor = 0;
+                unit->status.rear_sensor = 0;
+            } else if (unit->state_jdz == READY) {
+                unit->state = GET_USERID;
+                unit->state_jdz = GET_USERID;
+                unit->status.error = 0;
+                unit->status.front_sensor = 1;
+                unit->status.rear_sensor = 1;
+                unit->card_in = true;
+                unit->card_in_time = get_performance_seconds();
            }
        } else {
            unit->state = acio::ICCA_COMPAT_ACTIVE ? START : ACTIVE;
+            if (unit->state_jdz == READY) {
+                unit->state_jdz = GET_USERID;
+            }
            unit->status.error = 0;
+            unit->status.front_sensor = 1;
+            unit->status.rear_sensor = 1;
            unit->card_in = true;
            unit->card_in_time = get_performance_seconds();
        }
@@ -144,6 +179,12 @@ static inline void update_card(int unit_id) {
        unit->state = CLOSE_EJECT;
        if (fabs(get_performance_seconds() - unit->card_in_time) > CARD_TIMEOUT) {
            unit->card_in = false;
+            memset(unit->status.uid, 0, 8);
+            if (unit->state_jdz == ACTIVE || unit->state_jdz == GET_USERID) {
+                unit->state_jdz = ERR_REMOVED;
+            }
+            unit->status.front_sensor = 0;
+            unit->status.rear_sensor = 0;
        }
    }

@@ -302,7 +343,11 @@ static char __cdecl ac_io_icca_get_status(void *a1, void *a2) {

    // copy state to output buffer
    ICCA_UNIT *unit = &ICCA_UNITS[unit_id];
-    unit->status.status_code = unit->state;
+    if (avs::game::is_model("JDZ")) {
+        unit->status.status_code = unit->card_in ? ENGAGED : EMPTY;
+    } else {
+        unit->status.status_code = unit->state;
+    }
    memcpy(status, &unit->status, sizeof(struct ICCA_STATUS));

    // funny workaround
@@ -387,6 +432,11 @@ static char __cdecl ac_io_icca_req_uid(int unit_id) {
 static int __cdecl ac_io_icca_req_uid_isfinished(int unit_id, DWORD *read_state) {
    unit_id = icca_get_unit_id(unit_id);
    ICCA_UNIT *unit = &ICCA_UNITS[unit_id];
+    if (avs::game::is_model("JDZ")) {
+        // hack for RA - only ever seen it as this
+        *read_state = 8;
+        return 1;
+    }
    if (unit->card_in) {
        if (fabs(get_performance_seconds() - unit->card_in_time) < CARD_TIMEOUT) {
            unit->state = END;
@@ -403,16 +453,61 @@ static int __cdecl ac_io_icca_send_keep_alive_packet(int a1, int a2, int a3) {
    return 0;
 }

+static int __cdecl ac_io_icca_workflow_jdz(int workflow, int unit_id) {
+
+    unit_id = icca_get_unit_id(unit_id);
+    ICCA_UNIT *unit = &ICCA_UNITS[unit_id];
+    switch (workflow) {
+        // RA uses "STEP" as more of a polling thing it seems
+        case STEP:
+            switch (unit->state_jdz) {
+                case CLOSE_EJECT:
+                    unit->state_jdz = CLOSE_E_CHK;
+                    break;
+                case CLOSE_E_CHK:
+                    unit->state_jdz = CLOSE_END;
+                    break;
+                case CLOSE_END:
+                    unit->state_jdz = SLEEP;
+                    break;
+                default:
+                    break;
+            }
+            break;
+        case SLEEP:
+            unit->state = SLEEP;
+            break;
+        case START:
+            unit->state_jdz = INIT;
+            break;
+        case INIT:
+        case READY:
+            unit->state_jdz = READY;
+            break;
+        case CLOSE_EJECT:
+            unit->state_jdz = CLOSE_EJECT;
+            return CLOSE_E_CHK;
+        case CLOSE_END:
+            unit->state_jdz = SLEEP;
+            break;
+        default:
+            // should probably log a warning here
+            break;
+    }
+    return unit->state_jdz;
+}
+
 static int __cdecl ac_io_icca_workflow(int workflow, int unit_id) {
+    // RA uses a different workflow process for the slotted readers; treat it differently
+    if (avs::game::is_model("JDZ")) {
+        return ac_io_icca_workflow_jdz(workflow, unit_id);
+    }

    unit_id = icca_get_unit_id(unit_id);
    ICCA_UNIT *unit = &ICCA_UNITS[unit_id];
    switch (workflow) {
        case STEP:
-            if (avs::game::is_model("JDZ"))
-                unit->state = SLEEP;
-            else
-                unit->state = STEP;
+            unit->state = STEP;
            break;
        case SLEEP:
            unit->state = SLEEP;
@@ -441,7 +536,6 @@ static int __cdecl ac_io_icca_workflow(int workflow, int unit_id) {
        default:
            break;
    }
-
    return unit->state;
 }

@@ -467,6 +561,14 @@ acio::ICCAModule::ICCAModule(HMODULE module, acio::HookMode hookMode) : ACIOModu
 void acio::ICCAModule::attach() {
    ACIOModule::attach();

+    // workaround for RA; ac_io_icca_cardunit_init is never called so treat like both are initialized
+    if (avs::game::is_model("JDZ")) {
+        ICCA_UNITS[0].initialized = true;
+        ICCA_UNITS[1].initialized = true;
+
+        CARD_TIMEOUT = 10.0; // keep the card in the slot for longer
+    }
+
    // hooks
    ACIO_MODULE_HOOK(ac_io_icca_cardunit_init);
    ACIO_MODULE_HOOK(ac_io_icca_cardunit_init_isfinished);
@@ -52,7 +52,7 @@ static bool __cdecl ac_io_j32d_update_control_status_buffer(size_t a1) {
        float pad3_vel = Buttons::getVelocity(RI_MGR, buttons.at(games::ftt::Buttons::Pad3));
        float pad4_vel = Buttons::getVelocity(RI_MGR, buttons.at(games::ftt::Buttons::Pad4));
        // FIXME(felix): this logic seems wrong for analog handling but correct for digital inputs
-        if (pad1_vel > 0.f) {
+        if (Buttons::getState(RI_MGR, buttons.at(games::ftt::Buttons::Pad1))) {
            STATUS_BUFFER[6] = (int) (51.f * pad1_vel + 0.5f);
        }
        if (Buttons::getState(RI_MGR, buttons.at(games::ftt::Buttons::Pad2))) {
@@ -67,10 +67,10 @@ static bool __cdecl ac_io_j32d_update_control_status_buffer(size_t a1) {

        // process analogs
        auto &analogs = games::ftt::get_analogs();
-        auto pad1_analog = analogs.at(games::ftt::Analogs::Pad1);
-        auto pad2_analog = analogs.at(games::ftt::Analogs::Pad2);
-        auto pad3_analog = analogs.at(games::ftt::Analogs::Pad3);
-        auto pad4_analog = analogs.at(games::ftt::Analogs::Pad4);
+        auto &pad1_analog = analogs.at(games::ftt::Analogs::Pad1);
+        auto &pad2_analog = analogs.at(games::ftt::Analogs::Pad2);
+        auto &pad3_analog = analogs.at(games::ftt::Analogs::Pad3);
+        auto &pad4_analog = analogs.at(games::ftt::Analogs::Pad4);
        if (pad1_analog.isSet()) {
            auto val = (uint32_t) (51.f * Analogs::getState(RI_MGR, pad1_analog) + 0.5f);
            STATUS_BUFFER[6] = MAX(STATUS_BUFFER[6], val);
@@ -8,10 +8,21 @@
 #include "games/sdvx/io.h"
 #include "misc/eamuse.h"
 #include "rawinput/rawinput.h"
+#include "util/socd_cleaner.h"
+#include "util/time.h"
 #include "util/utils.h"

 using namespace GameAPI;

+#define DEBUG_VERBOSE 0
+
+#if DEBUG_VERBOSE
+#define log_debug(module, format_str, ...) logger::push( \
+    LOG_FORMAT("M", module, format_str, ## __VA_ARGS__), logger::Style::GREY)
+#else
+#define log_debug(module, format_str, ...)
+#endif
+
 // globals
 uint8_t KFCA_VOL_SOUND = 96;
 uint8_t KFCA_VOL_HEADPHONE = 96;
@@ -342,18 +353,25 @@ static char __cdecl ac_io_kfca_update_control_status_buffer() {
        }

        // volume left
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Left))) {
+        const auto now = get_performance_milliseconds();
+        const auto vol_l_state = socd::socd_clean(0,
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Left)),
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Right)),
+            now);
+        if (vol_l_state == socd::SocdCCW) {
            KFCA_VOLL = (KFCA_VOLL - games::sdvx::DIGITAL_KNOB_SENS) & 1023;
-        }
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_L_Right))) {
+        } else if (vol_l_state == socd::SocdCW) {
            KFCA_VOLL = (KFCA_VOLL + games::sdvx::DIGITAL_KNOB_SENS) & 1023;
        }

        // volume right
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Left))) {
+        const auto vol_r_state = socd::socd_clean(1,
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Left)),
+            Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Right)),
+            now);
+        if (vol_r_state == socd::SocdCCW) {
            KFCA_VOLR = (KFCA_VOLR - games::sdvx::DIGITAL_KNOB_SENS) & 1023;
-        }
-        if (Buttons::getState(RI_MGR, buttons.at(games::sdvx::Buttons::VOL_R_Right))) {
+        } else if (vol_r_state == socd::SocdCW) {
            KFCA_VOLR = (KFCA_VOLR + games::sdvx::DIGITAL_KNOB_SENS) & 1023;
        }

@@ -372,6 +390,8 @@ static char __cdecl ac_io_kfca_update_control_status_buffer() {
        vol_left %= 1024;
        vol_right %= 1024;
        
+        log_debug("kfca", "knobs = {} {}", vol_left, vol_right);
+
        // save volumes in buffer
        STATUS_BUFFER[input_offset + 16 + 0] |= (unsigned char) ((vol_left << 6) & 0xFF);
        STATUS_BUFFER[input_offset + 16 + 1] |= (unsigned char) ((vol_left >> 2) & 0xFF);
@@ -1,13 +1,16 @@
 #include "mdxf.h"
 #include "mdxf_poll.h"

+#include <mutex>
+
 #include "avs/game.h"
+#include "games/ddr/ddr.h"
 #include "games/ddr/io.h"
 #include "launcher/launcher.h"
 #include "rawinput/rawinput.h"
 #include "util/logging.h"
+#include "util/precise_timer.h"
 #include "util/utils.h"
-#include <mutex>

 #define MDFX_DEBUG_VERBOSE 0

@@ -108,9 +111,10 @@ static void mdxf_thread_start() {
    MDXF_THREAD = std::thread([] {
        SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_BELOW_NORMAL);

+        timeutils::PreciseSleepTimer timer;
        while (MDXF_THREAD_RUNNING.load(std::memory_order_acquire)) {
            mdxf_poll(false);
-            std::this_thread::sleep_for(THREAD_PERIOD);
+            timer.sleep(THREAD_PERIOD);
        }
    });
 }
@@ -357,14 +361,17 @@ static bool __cdecl ac_io_mdxf_update_control_status_buffer_impl(int node, MDXFP

        // decide on button map
        const size_t *button_map = nullptr;
+        int player = 0;
        switch (node) {
            case 17:
            case 25:
                button_map = &buttons_p1[0];
+                player = 1;
                break;
            case 18:
            case 26:
                button_map = &buttons_p2[0];
+                player = 2;
                break;
        }
        
@@ -374,19 +381,27 @@ static bool __cdecl ac_io_mdxf_update_control_status_buffer_impl(int node, MDXFP
        if (source == EXTERNAL_POLL) {
            // get buttons
            auto &buttons = games::ddr::get_buttons();
+            
+            // get analogs
+            bool analog_left = false;
+            bool analog_right = false;
+            games::ddr::get_analog_x_axis(player, analog_left, analog_right);
+            bool analog_up = false;
+            bool analog_down = false;
+            games::ddr::get_analog_y_axis(player, analog_up, analog_down);
+            
            uint8_t up_down = 0;
            uint8_t left_right = 0;
-            
-            if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[0]))) {
+            if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[0])) || analog_up) {
                up_down |= 0xF0;
            }
-            if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[1]))) {
+            if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[1])) || analog_down) {
                up_down |= 0x0F;
            }
-            if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[2]))) {
+            if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[2])) || analog_left) {
                left_right |= 0xF0;
            }
-            if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[3]))) {
+            if (GameAPI::Buttons::getState(RI_MGR, buttons.at(button_map[3])) || analog_right) {
                left_right |= 0x0F;
            }
            current_state = (uint16_t(up_down) << 8) | left_right;
@@ -1,5 +1,6 @@
 #pragma once

+#include <cstdint>
 #include <string>

 #include "util/circular_buffer.h"
@@ -2,8 +2,10 @@

 #include "acio/icca/icca.h"
 #include "avs/game.h"
+#include "games/sdvx/sdvx.h"
 #include "misc/eamuse.h"
 #include "util/logging.h"
+#include "util/precise_timer.h"
 #include "util/utils.h"

 using namespace acioemu;
@@ -45,11 +47,12 @@ ICCADevice::ICCADevice(bool flip_order, bool keypad_thread, uint8_t node_count)
    // keypad thread for faster polling
    if (keypad_thread) {
        this->keypad_thread = new std::thread([this]() {
+            timeutils::PreciseSleepTimer timer;
            while (this->cards) {
                for (int unit = 0; unit < this->node_count; unit++) {
                    this->update_keypad(unit, false);
                }
-                Sleep(7);
+                timer.sleep(7);
            }
        });
    }
@@ -101,13 +104,10 @@ bool ICCADevice::parse_msg(MessageData *msg_in,

            // send version data
            auto msg = this->create_msg(msg_in, MSG_VERSION_SIZE);
-            if (
-                avs::game::is_model({"LDJ", "TBS", "UJK", "XIF"}) ||
-                // SDVX Valkyrie cabinet mode
-                (avs::game::is_model("KFC") && (avs::game::SPEC[0] == 'G' || avs::game::SPEC[0] == 'H'))
-            ) {
+            if (avs::game::is_model({"LDJ", "TBS", "UJK", "XIF"}) ||
+                games::sdvx::is_valkyrie_model()) {
                this->set_version(msg, 0x3, 0, 1, 7, 0, "ICCA");
-            } else if (avs::game::is_model({"VFG"})) {
+            } else if (avs::game::is_model("VFG")) {
                this->set_version(msg, 0x3, 0, 1, 7, 0, "ICCB");
            } else {
                this->set_version(msg, 0x3, 0, 1, 6, 0, "ICCA");
@@ -520,11 +520,7 @@ void ICCADevice::update_status(int unit) {
            buffer[1] = felica ? 0x01 : 0x00;
            buffer[10] = felica ? 0x01 : 0x00;

-        } else if (
-            avs::game::is_model({"LDJ", "TBS", "XIF"}) ||
-            // SDVX Valkyrie cabinet mode
-            (avs::game::is_model("KFC") && (avs::game::SPEC[0] == 'G' || avs::game::SPEC[0] == 'H'))) {
-
+        } else if (avs::game::is_model({"LDJ", "TBS", "XIF"}) || games::sdvx::is_valkyrie_model()) {
            // set status to 0 otherwise reader power on fails
            buffer[0] = 0x00;
        } else {
@@ -11,6 +11,8 @@
 #include "util/logging.h"
 #include "util/utils.h"

+#include "overlay/notifications.h"
+
 #include "module.h"
 #include "modules/analogs.h"
 #include "modules/buttons.h"
@@ -197,6 +199,9 @@ void Controller::connection_handler(api::ClientState client_state) {

    // log connection
    log_info("api", "client connected: {}", client_address_str);
+    overlay::notifications::add(
+            overlay::notifications::Severity::Success,
+            fmt::format("API client connected ({})", client_address_str));
    client_states_m.lock();
    client_states.emplace_back(&client_state);
    client_states_m.unlock();
@@ -277,6 +282,9 @@ void Controller::connection_handler(api::ClientState client_state) {

    // log disconnect
    log_info("api", "client disconnected: {}", client_address_str);
+    overlay::notifications::add(
+            overlay::notifications::Severity::Info,
+            fmt::format("API client disconnected ({})", client_address_str));
    client_states_m.lock();
    client_states.erase(std::remove(client_states.begin(), client_states.end(), &client_state));
    client_states_m.unlock();
@@ -6,6 +6,7 @@
 #include "launcher/launcher.h"
 #include "games/io.h"
 #include "util/utils.h"
+#include "acio/mdxf/mdxf_poll.h"

 using namespace std::placeholders;
 using namespace rapidjson;
@@ -104,6 +105,7 @@ namespace api::modules {
                for (auto &analog : *this->analogs) {
                    analog.override_enabled = false;
                }
+                mdxf_poll(true);
            }
            return;
        }
@@ -148,6 +150,7 @@ namespace api::modules {
            if (analog.getName() == name) {
                analog.override_state = CLAMP(state, 0.f, 1.f);
                analog.override_enabled = true;
+                mdxf_poll(true);
                return true;
            }
        }
@@ -167,6 +170,7 @@ namespace api::modules {
        for (auto &analog : *this->analogs) {
            if (analog.getName() == name) {
                analog.override_enabled = false;
+                mdxf_poll(true);
                return true;
            }
        }
@@ -6,6 +6,7 @@
 #include "launcher/launcher.h"
 #include "games/io.h"
 #include "util/utils.h"
+#include "acio/mdxf/mdxf_poll.h"

 using namespace std::placeholders;
 using namespace rapidjson;
@@ -107,6 +108,7 @@ namespace api::modules {
                for (auto &button : *this->buttons) {
                    button.override_enabled = false;
                }
+                mdxf_poll(true);
            }
            return;
        }
@@ -153,6 +155,7 @@ namespace api::modules {
                        GameAPI::Buttons::BUTTON_PRESSED : GameAPI::Buttons::BUTTON_NOT_PRESSED;
                button.override_velocity = CLAMP(state, 0.f, 1.f);
                button.override_enabled = true;
+                mdxf_poll(true);
                return true;
            }
        }
@@ -172,6 +175,7 @@ namespace api::modules {
        for (auto &button : *this->buttons) {
            if (button.getName() == name) {
                button.override_enabled = false;
+                mdxf_poll(true);
                return true;
            }
        }
@@ -34,7 +34,7 @@ namespace api::modules {
    void DRS::touch_set(Request &req, Response &res) {

        // get all touch points
-        games::drs::drs_touch_t touches[16];
+        auto touches = std::make_unique<games::drs::drs_touch_t[]>(req.params.Size());
        size_t i = 0;
        for (Value &param : req.params.GetArray()) {

@@ -86,6 +86,6 @@ namespace api::modules {
        }

        // apply touch points
-        games::drs::fire_touches(touches, i);
+        games::drs::fire_touches(touches.get(), i);
    }
 }
@@ -7,6 +7,7 @@
 #include "avs/game.h"
 #include "external/rapidjson/document.h"
 #include "misc/eamuse.h"
+#include "util/precise_timer.h"

 using namespace std::placeholders;
 using namespace rapidjson;
@@ -58,6 +59,7 @@ namespace api::modules {
        // get params
        auto keypad = req.params[0].GetUint();
        auto input = std::string(req.params[1].GetString());
+        timeutils::PreciseSleepTimer timer;

        // process all chars
        for (auto c : input) {
@@ -91,11 +93,11 @@ namespace api::modules {

            // set
            eamuse_set_keypad_overrides(keypad, state);
-            Sleep(sleep_time);
+            timer.sleep(sleep_time);

            // unset
            eamuse_set_keypad_overrides(keypad, 0);
-            Sleep(sleep_time);
+            timer.sleep(sleep_time);
        }
    }

@@ -58,7 +58,7 @@ namespace api::modules {

        // check if file exists in modules
        if (!fileutils::file_exists(dll_path)) {
-            return error(res, "Couldn't find " + dll_path.string());
+            return error(res, fmt::format("Couldn't find {}", dll_path));
        }

        // get module
@@ -118,7 +118,7 @@ namespace api::modules {

        // check if file exists in modules
        if (!fileutils::file_exists(dll_path)) {
-            return error(res, "Couldn't find " + dll_path.string());
+            return error(res, fmt::format("Couldn't find {}", dll_path));
        }

        // get module
@@ -196,7 +196,7 @@ namespace api::modules {

        // check if file exists in modules
        if (!fileutils::file_exists(dll_path)) {
-            return error(res, "Couldn't find " + dll_path.string());
+            return error(res, fmt::format("Couldn't find {}", dll_path));
        }

        // get module
@@ -5,6 +5,7 @@
 #include <utility>

 #include "util/logging.h"
+#include "util/precise_timer.h"
 #include "util/utils.h"


@@ -16,6 +17,7 @@ namespace api {
        controller->init_state(this->state);
        this->thread = new std::thread([this] () {
            log_warning("api::serial", "listening on {} (baud: {})", this->port, this->baud);
+            timeutils::PreciseSleepTimer timer;

            // read buffer
            uint8_t read_buffer[16*1024];
@@ -160,7 +162,7 @@ namespace api {

                // slow down on reconnect
                if (this->running) {
-                    Sleep(retry_time);
+                    timer.sleep(retry_time);
                }
            }
        });
@@ -5,6 +5,7 @@
 #include "util/utils.h"
 #include "util/rc4.h"
 #include "util/logging.h"
+#include "overlay/notifications.h"
 #include "controller.h"

 using namespace headsocket;
@@ -91,12 +92,18 @@ namespace api {

        // log connection
        log_info("api::websocket", "client connected");
+        overlay::notifications::add(
+                overlay::notifications::Severity::Success,
+                "API websocket client connected");
    }

    void WebSocketClient::on_disconnect() {

        // log disconnection
        log_info("api::websocket", "client disconnected");
+        overlay::notifications::add(
+                overlay::notifications::Severity::Info,
+                "API websocket client disconnected");

        // get pointer to server
        auto srv = reinterpret_cast<WebSocketServer *>(server().get());
@@ -7,6 +7,7 @@
 #include <stdint.h>

 #include "external/robin_hood.h"
+#include "games/popn/popn.h"
 #include "launcher/logger.h"
 #include "launcher/signal.h"
 #include "util/deferlog.h"
@@ -1108,6 +1109,8 @@ namespace avs {

            // SOUND VOLTEX
            {"soundvoltex.dll", 0x10000000},
+            // GITADORA
+            {"gdxg.dll", 0x2000000},
 #endif
            // jubeat
            {"jubeat.dll", 0x2000000},
@@ -1177,6 +1180,15 @@ namespace avs {
                return;
            }

+            // hack, both hello! popn and popn hc using popn.dll
+            if (games::popn::is_pikapika_model()) {
+                auto old_size = HEAP_SIZE;
+                HEAP_SIZE = 0x20000000;
+                DEFAULT_HEAP_SIZE_SET = true;
+                log_info("avs-core", "updated heap size: {} -> {}", old_size, avs::core::HEAP_SIZE);
+                return;
+            }
+
            if (HEAP_SIZE_DEFAULTS.find(dll_name) != HEAP_SIZE_DEFAULTS.end()) {
                auto old_size = HEAP_SIZE;

@@ -1232,6 +1244,7 @@ namespace avs {
                                break;
                            case 'F':
                                new_style = logger::Style::RED;
+                                deferredlogs::report_fatal_message();
                                break;
                            default:
                                position = 0;
@@ -1300,6 +1313,7 @@ namespace avs {
                    break;
                case 'F':
                    style = logger::Style::RED;
+                    deferredlogs::report_fatal_message();
                    break;
                case 'W':
                    style = logger::Style::YELLOW;
@@ -1502,7 +1516,7 @@ namespace avs {
                        "    * It's also possible that you have incomplete game data\n"
                        "    * Do NOT copy over random DLLs from another game installation; DLL must match game version\n"
                        "\n"
-                    , DLL_NAME, MODULE_PATH.string()) };
+                    , DLL_NAME, MODULE_PATH) };
                    log_warning("avs-ea3", "{}", info_str);
                    log_fatal("avs-ea3", "Failed to find critical avs DLL on disk (avs2-core.dll OR {})", DLL_NAME);
                }
@@ -1743,8 +1757,8 @@ namespace avs {
        {
            deferredlogs::defer_error_messages({
                "AVS filesystem initialization failure was previously detected during boot!",
-                fmt::format("    ERROR: directory could not be created: {}", src_path.string().c_str()),
-                fmt::format("    if you see a crash, it may have been caused by bad <mounttable> contents in {}", avs::core::CFG_PATH.c_str()),
+                fmt::format("    ERROR: directory could not be created: {}", src_path),
+                fmt::format("    if you see a crash, it may have been caused by bad <mounttable> contents in {}", avs::core::CFG_PATH),
                "    fix the XML file and try again"
            });
        }
@@ -1766,14 +1780,14 @@ namespace avs {
            auto created = std::filesystem::create_directories(real_path, err);

            if (created) {
-                log_info("avs-core", "created '{}' at '{}'", avs_path, real_path.string());
+                log_info("avs-core", "created '{}' at '{}'", avs_path, real_path);
            }

            if (err) {
                avs_dir_err(real_path);
                log_warning("avs-core", "failed to create '{}' folder at '{}': {}",
                        avs_path,
-                        real_path.string(),
+                        real_path,
                        err.message());
            }
        }
@@ -1907,6 +1921,15 @@ namespace avs {
            // create nvram and raw directories if possible for mounttable configurations
            create_avs_config_fs_table(config, config_node);

+#if !SPICE64
+            // sdvx4 bad log config fix
+            if (avs::game::DLL_NAME == "soundvoltex.dll" &&  // it's too early for avs::game::is_model
+                property_search_safe(config, config_node, "/log/enable_console")) {
+                log_info("avs-core", "applying SDVX4 avs-config.xml fix for <log><enable_console>");
+                property_search_remove_safe(config, config_node, "/log/enable_console");
+            }
+#endif
+
            // set log level
            if (!LOG_LEVEL_CUSTOM.empty()) {
                property_search_remove_safe(config, config_node, "/log/level");
@@ -5,8 +5,9 @@
 #include "build/defs.h"
 #include "easrv/easrv.h"
 #include "easrv/smartea.h"
-#include "games/mfc/mfc.h"
+#include "games/gitadora/gitadora.h"
 #include "hooks/avshook.h"
+#include "hooks/graphics/graphics.h"
 #include "util/detour.h"
 #include "util/deferlog.h"
 #include "util/fileutils.h"
@@ -150,7 +151,7 @@ namespace avs {
                        "    * It's also possible that you have incomplete game data\n"
                        "    * Do NOT copy over random DLLs from another game installation; DLL must match game version\n"
                        "\n"
-                    , DLL_NAME, MODULE_PATH.string()) };
+                    , DLL_NAME, MODULE_PATH) };

                    log_warning("avs-ea3", "{}", info_str);
                    log_fatal("avs-ea3", "Failed to find critical ea3 DLL on disk (avs2-ea3.dll OR {})", DLL_NAME);
@@ -216,7 +217,25 @@ namespace avs {
                ea3_config_name = "prop/eamuse-config.xml";
            }

-            log_info("avs-ea3", "booting (using {})", ea3_config_name);
+            if (fileutils::file_exists(ea3_config_name)) {
+                log_info("avs-ea3", "found {} on disk", ea3_config_name);
+            } else if (CFG_PATH.size()) {
+                log_fatal("avs-ea3", "user-specified ea3 config file is missing: {}", ea3_config_name);
+            } else {
+                log_warning("avs-ea3", "looked for the following files in order:");
+                log_warning("avs-ea3", "  * prop/ea3-config.xml");
+                log_warning("avs-ea3", "  * prop/ea3-cfg.xml");
+                if (avs::game::DLL_NAME == "beatstream1.dll") {
+                    log_warning("avs-ea3", "  * prop/ea3-config-1.xml");
+                }
+                if (avs::game::DLL_NAME == "beatstream2.dll") {
+                    log_warning("avs-ea3", "  * prop/ea3-config-2.xml");
+                }
+                log_warning("avs-ea3", "  * prop/eamuse-config.xml");
+                log_warning("avs-ea3", "none of the files above were found, game will fail to boot");
+                log_warning("avs-ea3", "usually, this means your game data is incomplete");
+                log_fatal("avs-ea3", "no ea3 config file found in prop directory; check log messages");
+            }

            // remember new config path
            CFG_PATH = ea3_config_name;
@@ -494,7 +513,9 @@ namespace avs {
            std::ostringstream init_code;
            init_code << EA3_MODEL;
            init_code << EA3_DEST;
-            if (strcmp(EA3_MODEL, "MDX") == 0 && strcmp(EA3_SPEC, "I") == 0) {
+            if (avs::game::DLL_NAME == "arkmdxbio2.dll" &&
+                strcmp(EA3_MODEL, "MDX") == 0 && strcmp(EA3_SPEC, "I") == 0) {
+                // ddr gold cab
                init_code << "G";
                init_code << "B";
            } else {
@@ -526,12 +547,42 @@ namespace avs {
                }
            }

+            // update -WINDOW in app-config
+            if (games::gitadora::is_arena_model()) {
+                avs::core::property_search_remove_safe(app_config, nullptr, "/param/cmdline");
+                std::string cmdline{};
+                if (games::gitadora::is_drum()) {
+                    if (GRAPHICS_WINDOWED) {
+                        cmdline = "-d -DM -WINDOW";
+                    } else {
+                        cmdline = "-d -DM";
+                    }
+                } else {
+                    if (GRAPHICS_WINDOWED) {
+                        cmdline = "-g -GF -WINDOW";
+                    } else {
+                        cmdline = "-g -GF";
+                    }
+                }
+                log_info("avs-ea3", "using cmdline: `{}`", cmdline);
+                avs::core::property_node_create(app_config, nullptr,
+                        avs::core::NODE_TYPE_str, "/param/cmdline", cmdline.c_str());
+            }
+
            auto app_param = avs::core::property_search_safe(app_config, nullptr, "/param");

            // call the game init
-            log_info("avs-ea3", "calling entry init");
+            log_info("avs-ea3", "calling dll_entry_init (init code = {})", init_code_str);
            if (!avs::game::entry_init(init_code_str.data(), app_param)) {
-                log_fatal("avs-ea3", "entry init failed :(");
+                for (size_t i = 0; i < 255; i++) {
+                    log_warning("avs-ea3", "dll_entry_init failed :(");
+                }
+                deferredlogs::defer_error_messages({
+                    "dll_entry_init failed",
+                    "    init code: " + init_code_str,
+                    "    this is a fatal error that causes boot failure",
+                    "    most likely, your prop files have errors"
+                });
            }

            // accommodate changes to soft id code
@@ -73,11 +73,10 @@ namespace avs {

            // load game instance
            const auto dll_path = MODULE_PATH / DLL_NAME;
-            const auto dll_path_s = dll_path.string();
-            log_info("avs-game", "DLL path: {}", dll_path_s.c_str());
+            log_info("avs-game", "DLL path: {}", dll_path);

            // MAX_PATH is 260
-            if (130 <= dll_path_s.length()) {
+            if (const auto dll_path_len = dll_path.wstring().length(); 130 <= dll_path_len) {
                log_warning(
                    "avs-game",
                    "PATH TOO LONG WARNING\n\n"
@@ -93,7 +92,7 @@ namespace avs {
                    "long, often resulting in random crashes. Move the game contents to\n"
                    "a directory with shorter path.\n"
                    "-------------------------------------------------------------------\n\n",
-                    dll_path_s, dll_path_s.length());
+                    dll_path, dll_path_len);
            }

            // ddr gamemdx.dll user error
@@ -112,7 +111,7 @@ namespace avs {

            // file not found on disk
            if (!fileutils::file_exists(dll_path)) {
-                log_warning("avs-game", "game DLL could not be found on disk: {}", dll_path.string().c_str());
+                log_warning("avs-game", "game DLL could not be found on disk: {}", dll_path);
                log_warning("avs-game", "double check -exec and -modules parameters; unless you know what you're doing, leave them blank");
            }

@@ -0,0 +1,327 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<templates>
+    <!-- PHOENIXWAN controller preset for Beatmania IIDX
+
+       Button indices 0-6: keys 1-7
+       Button indices 8-11: E1 (Start for Deluxe Model Style), E2 (Effect), E3 (VEFX), E4 (P1 Start for Lightning Model Style)
+
+        P1 Side                     P2 Side
+             8 9 10 11          8 9 10 11
+              2  4  6            2  4  6
+       TT   1  3  5  7         1  3  5  7   TT -->
+    <template name="DJ DAO PHOENIXWAN" game="Beatmania IIDX">
+        <buttons>
+            <button name="P1 1" vkey="0" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 2" vkey="1" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 3" vkey="2" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 4" vkey="3" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 5" vkey="4" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 6" vkey="5" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 7" vkey="6" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 1" vkey="0" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 2" vkey="1" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 3" vkey="2" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 4" vkey="3" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 5" vkey="4" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 6" vkey="5" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 7" vkey="6" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <!-- P1 Start: E1 primary (index 8), E4 alternative (index 11) -->
+            <button name="P1 Start" vkey="8" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 Start" vkey="11" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <!-- P2 Start: E1 primary (index 8), E4 alternative (index 11) -->
+            <button name="P2 Start" vkey="8" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 Start" vkey="11" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <!-- EFFECT: E2 (index 9), primary P2 side, alternative P1 side -->
+            <button name="EFFECT" vkey="9" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="EFFECT" vkey="9" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <!-- VEFX: E3 (index 10), primary P2 side, alternative P1 side -->
+            <button name="VEFX" vkey="10" analogtype="0" devid="Player 2" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="VEFX" vkey="10" analogtype="0" devid="Player 1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+        </buttons>
+        <analogs>
+            <analog name="Turntable P1" devid="Player 1" index="4" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Turntable P2" devid="Player 2" index="4" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+        </analogs>
+        <lights>
+            <light name="P1 1" devid="Player 1" index="0"/>
+            <light name="P1 2" devid="Player 1" index="1"/>
+            <light name="P1 3" devid="Player 1" index="2"/>
+            <light name="P1 4" devid="Player 1" index="3"/>
+            <light name="P1 5" devid="Player 1" index="4"/>
+            <light name="P1 6" devid="Player 1" index="5"/>
+            <light name="P1 7" devid="Player 1" index="6"/>
+            <light name="P2 1" devid="Player 2" index="0"/>
+            <light name="P2 2" devid="Player 2" index="1"/>
+            <light name="P2 3" devid="Player 2" index="2"/>
+            <light name="P2 4" devid="Player 2" index="3"/>
+            <light name="P2 5" devid="Player 2" index="4"/>
+            <light name="P2 6" devid="Player 2" index="5"/>
+            <light name="P2 7" devid="Player 2" index="6"/>
+            <!-- Start buttons bind both E1 (index 8) and E4 (index 11), but lights use
+           Lightning Model style only (one per side) to avoid both lighting up at once -->
+            <light name="P1 Start" devid="Player 1" index="10"/>
+            <light name="P2 Start" devid="Player 2" index="7"/>
+            <light name="VEFX" devid="Player 1" index="8"/>
+            <light name="VEFX" devid="Player 2" index="8"/>
+            <light name="Effect" devid="Player 1" index="9"/>
+            <light name="Effect" devid="Player 2" index="9"/>
+        </lights>
+    </template>
+    <!-- Common "double scratch" BMS playstyle: LSHIFT   A S D SPACE L ; '   RSHIFT -->
+    <!-- Uses Up/Down arrows for turntable navigation -->
+    <template name="Keyboard (linear, double scratch, QWERTY)" game="Beatmania IIDX">
+        <buttons>
+            <button name="P1 1" vkey="65" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 2" vkey="83" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 3" vkey="68" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 4" vkey="32" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 5" vkey="76" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 6" vkey="186" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 7" vkey="222" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 TT+" vkey="40" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 TT-" vkey="38" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 TT+/-" vkey="160" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 TT+/- Alternate" vkey="161" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 Start" vkey="13" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 Start" vkey="69" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="EFFECT" vkey="81" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="VEFX" vkey="87" analogtype="0" devid="" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+        </buttons>
+        <keypad_buttons/>
+        <analogs/>
+        <lights/>
+    </template>
+    <template name="arcin (arcin-infinitas)" game="Beatmania IIDX">
+        <buttons>
+            <button name="P1 1" vkey="0" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 2" vkey="1" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 3" vkey="2" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 4" vkey="3" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 5" vkey="4" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 6" vkey="5" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 7" vkey="6" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P1 Start" vkey="9" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 1" vkey="0" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 2" vkey="1" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 3" vkey="2" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 4" vkey="3" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 5" vkey="4" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 6" vkey="5" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 7" vkey="6" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="P2 Start" vkey="9" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="EFFECT" vkey="11" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="EFFECT" vkey="11" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="VEFX" vkey="10" analogtype="0" devid="arcin (1p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="VEFX" vkey="10" analogtype="0" devid="arcin (2p)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+        </buttons>
+        <keypad_buttons/>
+        <!-- Assumes analog mode. Need to invert direction since this FW is designed for INF. -->
+        <analogs>
+            <analog name="Turntable P1" devid="arcin (1p)" index="0" sensivity="1" deadzone="0" deadzone_mirror="false" invert="true" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Turntable P2" devid="arcin (2p)" index="0" sensivity="1" deadzone="0" deadzone_mirror="false" invert="true" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+        </analogs>
+        <lights>
+            <light name="P1 1" devid="arcin (1p)" index="0"/>
+            <light name="P1 2" devid="arcin (1p)" index="1"/>
+            <light name="P1 3" devid="arcin (1p)" index="2"/>
+            <light name="P1 4" devid="arcin (1p)" index="3"/>
+            <light name="P1 5" devid="arcin (1p)" index="4"/>
+            <light name="P1 6" devid="arcin (1p)" index="5"/>
+            <light name="P1 7" devid="arcin (1p)" index="6"/>
+            <light name="P2 1" devid="arcin (2p)" index="0"/>
+            <light name="P2 2" devid="arcin (2p)" index="1"/>
+            <light name="P2 3" devid="arcin (2p)" index="2"/>
+            <light name="P2 4" devid="arcin (2p)" index="3"/>
+            <light name="P2 5" devid="arcin (2p)" index="4"/>
+            <light name="P2 6" devid="arcin (2p)" index="5"/>
+            <light name="P2 7" devid="arcin (2p)" index="6"/>
+            <light name="P1 Start" devid="arcin (1p)" index="9"/>
+            <light name="P2 Start" devid="arcin (2p)" index="9"/>
+        </lights>
+    </template>
+    <!-- This controller has many modes; here, we use HID Analog mode which is meant for data -->
+    <template name="DJ DAO Nostroller (Analog mode)" game="Nostalgia">
+        <buttons/>
+        <keypad_buttons/>
+        <analogs>
+            <analog name="Key 1" devid="Analogs key 01-28" index="4" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 2" devid="Analogs key 01-28" index="5" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 3" devid="Analogs key 01-28" index="6" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 4" devid="Analogs key 01-28" index="7" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 5" devid="Analogs key 01-28" index="8" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 6" devid="Analogs key 01-28" index="9" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 7" devid="Analogs key 01-28" index="10" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 8" devid="Analogs key 01-28" index="11" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 9" devid="Analogs key 01-28" index="12" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 10" devid="Analogs key 01-28" index="13" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 11" devid="Analogs key 01-28" index="14" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 12" devid="Analogs key 01-28" index="15" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 13" devid="Analogs key 01-28" index="16" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 14" devid="Analogs key 01-28" index="17" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 15" devid="Analogs key 01-28" index="18" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 16" devid="Analogs key 01-28" index="19" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 17" devid="Analogs key 01-28" index="20" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 18" devid="Analogs key 01-28" index="21" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 19" devid="Analogs key 01-28" index="22" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 20" devid="Analogs key 01-28" index="23" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 21" devid="Analogs key 01-28" index="24" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 22" devid="Analogs key 01-28" index="25" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 23" devid="Analogs key 01-28" index="26" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 24" devid="Analogs key 01-28" index="27" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 25" devid="Analogs key 01-28" index="28" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 26" devid="Analogs key 01-28" index="29" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 27" devid="Analogs key 01-28" index="30" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Key 28" devid="Analogs key 01-28" index="31" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+        </analogs>
+        <lights>
+            <light name="Key 1 R" devid="Lights 01-14" index="0"/>
+            <light name="Key 1 G" devid="Lights 01-14" index="1"/>
+            <light name="Key 1 B" devid="Lights 01-14" index="2"/>
+            <light name="Key 2 R" devid="Lights 01-14" index="3"/>
+            <light name="Key 2 G" devid="Lights 01-14" index="4"/>
+            <light name="Key 2 B" devid="Lights 01-14" index="5"/>
+            <light name="Key 3 R" devid="Lights 01-14" index="6"/>
+            <light name="Key 3 G" devid="Lights 01-14" index="7"/>
+            <light name="Key 3 B" devid="Lights 01-14" index="8"/>
+            <light name="Key 4 R" devid="Lights 01-14" index="9"/>
+            <light name="Key 4 G" devid="Lights 01-14" index="10"/>
+            <light name="Key 4 B" devid="Lights 01-14" index="11"/>
+            <light name="Key 5 R" devid="Lights 01-14" index="12"/>
+            <light name="Key 5 G" devid="Lights 01-14" index="13"/>
+            <light name="Key 5 B" devid="Lights 01-14" index="14"/>
+            <light name="Key 6 R" devid="Lights 01-14" index="15"/>
+            <light name="Key 6 G" devid="Lights 01-14" index="16"/>
+            <light name="Key 6 B" devid="Lights 01-14" index="17"/>
+            <light name="Key 7 R" devid="Lights 01-14" index="18"/>
+            <light name="Key 7 G" devid="Lights 01-14" index="19"/>
+            <light name="Key 7 B" devid="Lights 01-14" index="20"/>
+            <light name="Key 8 R" devid="Lights 01-14" index="21"/>
+            <light name="Key 8 G" devid="Lights 01-14" index="22"/>
+            <light name="Key 8 B" devid="Lights 01-14" index="23"/>
+            <light name="Key 9 R" devid="Lights 01-14" index="24"/>
+            <light name="Key 9 G" devid="Lights 01-14" index="25"/>
+            <light name="Key 9 B" devid="Lights 01-14" index="26"/>
+            <light name="Key 10 R" devid="Lights 01-14" index="27"/>
+            <light name="Key 10 G" devid="Lights 01-14" index="28"/>
+            <light name="Key 10 B" devid="Lights 01-14" index="29"/>
+            <light name="Key 11 R" devid="Lights 01-14" index="30"/>
+            <light name="Key 11 G" devid="Lights 01-14" index="31"/>
+            <light name="Key 11 B" devid="Lights 01-14" index="32"/>
+            <light name="Key 12 R" devid="Lights 01-14" index="33"/>
+            <light name="Key 12 G" devid="Lights 01-14" index="34"/>
+            <light name="Key 12 B" devid="Lights 01-14" index="35"/>
+            <light name="Key 13 R" devid="Lights 01-14" index="36"/>
+            <light name="Key 13 G" devid="Lights 01-14" index="37"/>
+            <light name="Key 13 B" devid="Lights 01-14" index="38"/>
+            <light name="Key 14 R" devid="Lights 01-14" index="39"/>
+            <light name="Key 14 G" devid="Lights 01-14" index="40"/>
+            <light name="Key 14 B" devid="Lights 01-14" index="41"/>
+            <light name="Key 15 R" devid="Lights 15-28" index="0"/>
+            <light name="Key 15 G" devid="Lights 15-28" index="1"/>
+            <light name="Key 15 B" devid="Lights 15-28" index="2"/>
+            <light name="Key 16 R" devid="Lights 15-28" index="3"/>
+            <light name="Key 16 G" devid="Lights 15-28" index="4"/>
+            <light name="Key 16 B" devid="Lights 15-28" index="5"/>
+            <light name="Key 17 R" devid="Lights 15-28" index="6"/>
+            <light name="Key 17 G" devid="Lights 15-28" index="7"/>
+            <light name="Key 17 B" devid="Lights 15-28" index="8"/>
+            <light name="Key 18 R" devid="Lights 15-28" index="9"/>
+            <light name="Key 18 G" devid="Lights 15-28" index="10"/>
+            <light name="Key 18 B" devid="Lights 15-28" index="11"/>
+            <light name="Key 19 R" devid="Lights 15-28" index="12"/>
+            <light name="Key 19 G" devid="Lights 15-28" index="13"/>
+            <light name="Key 19 B" devid="Lights 15-28" index="14"/>
+            <light name="Key 20 R" devid="Lights 15-28" index="15"/>
+            <light name="Key 20 G" devid="Lights 15-28" index="16"/>
+            <light name="Key 20 B" devid="Lights 15-28" index="17"/>
+            <light name="Key 21 R" devid="Lights 15-28" index="18"/>
+            <light name="Key 21 G" devid="Lights 15-28" index="19"/>
+            <light name="Key 21 B" devid="Lights 15-28" index="20"/>
+            <light name="Key 22 R" devid="Lights 15-28" index="21"/>
+            <light name="Key 22 G" devid="Lights 15-28" index="22"/>
+            <light name="Key 22 B" devid="Lights 15-28" index="23"/>
+            <light name="Key 23 R" devid="Lights 15-28" index="24"/>
+            <light name="Key 23 G" devid="Lights 15-28" index="25"/>
+            <light name="Key 23 B" devid="Lights 15-28" index="26"/>
+            <light name="Key 24 R" devid="Lights 15-28" index="27"/>
+            <light name="Key 24 G" devid="Lights 15-28" index="28"/>
+            <light name="Key 24 B" devid="Lights 15-28" index="29"/>
+            <light name="Key 25 R" devid="Lights 15-28" index="30"/>
+            <light name="Key 25 G" devid="Lights 15-28" index="31"/>
+            <light name="Key 25 B" devid="Lights 15-28" index="32"/>
+            <light name="Key 26 R" devid="Lights 15-28" index="33"/>
+            <light name="Key 26 G" devid="Lights 15-28" index="34"/>
+            <light name="Key 26 B" devid="Lights 15-28" index="35"/>
+            <light name="Key 27 R" devid="Lights 15-28" index="36"/>
+            <light name="Key 27 G" devid="Lights 15-28" index="37"/>
+            <light name="Key 27 B" devid="Lights 15-28" index="38"/>
+            <light name="Key 28 R" devid="Lights 15-28" index="39"/>
+            <light name="Key 28 G" devid="Lights 15-28" index="40"/>
+            <light name="Key 28 B" devid="Lights 15-28" index="41"/>
+        </lights>
+    </template>
+    <!-- Gitaller has two modes - digital tilt and analog axis. This binds both of them at the same time. -->
+    <template name="DJ DAO Gitaller" game="GitaDora">
+        <buttons>
+            <button name="Guitar P1 Start" vkey="9" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 Help" vkey="8" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 Pick Up" vkey="5" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 Pick Down" vkey="6" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 R" vkey="0" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 G" vkey="1" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 B" vkey="2" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 Y" vkey="3" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 P" vkey="4" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 Wail Up" vkey="10" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Guitar P1 Wail Down" vkey="11" analogtype="0" devid="Gitaller P1" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+        </buttons>
+        <keypad_buttons/>
+        <analogs>
+            <analog name="Guitar P1 Wail X" devid="Gitaller P1" index="1" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Guitar P1 Wail Y" devid="Gitaller P1" index="0" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="Guitar P1 Wail Z" devid="Gitaller P1" index="5" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+        </analogs>
+        <lights/>
+    <!-- Gen 1 FAUCETWO in HID mode; should also work for later gens -->
+    </template>
+        <template name="DJ DAO FAUCETWO" game="Sound Voltex">
+        <buttons>
+            <button name="BT-A" vkey="1" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="BT-B" vkey="2" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="BT-C" vkey="3" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="BT-D" vkey="4" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="FX-L" vkey="5" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="FX-R" vkey="6" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+            <button name="Start" vkey="0" analogtype="0" devid="Buttons (MI_01)" invert="false" debounce_up="0" debounce_down="0" velocity_threshold="0"/>
+        </buttons>
+        <keypad_buttons/>
+        <analogs>
+            <analog name="VOL-L" devid="Buttons (MI_01)" index="1" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+            <analog name="VOL-R" devid="Buttons (MI_01)" index="0" sensivity="1" deadzone="0" deadzone_mirror="false" invert="false" smoothing="false" multiplier="1" relative="false" delay_ms="0"/>
+        </analogs>
+        <lights>
+            <light name="BT-A" devid="Lights (MI_02)" index="24"/>
+            <light name="BT-B" devid="Lights (MI_02)" index="25"/>
+            <light name="BT-C" devid="Lights (MI_02)" index="26"/>
+            <light name="BT-D" devid="Lights (MI_02)" index="27"/>
+            <light name="FX-L" devid="Lights (MI_02)" index="28"/>
+            <light name="FX-R" devid="Lights (MI_02)" index="29"/>
+            <light name="Start" devid="Lights (MI_02)" index="30"/>
+            <light name="Upper Left Speaker Avg R" devid="Lights (MI_02)" index="0"/>
+            <light name="Upper Left Speaker Avg G" devid="Lights (MI_02)" index="1"/>
+            <light name="Upper Left Speaker Avg B" devid="Lights (MI_02)" index="2"/>
+            <light name="Upper Right Speaker Avg R" devid="Lights (MI_02)" index="9"/>
+            <light name="Upper Right Speaker Avg G" devid="Lights (MI_02)" index="10"/>
+            <light name="Upper Right Speaker Avg B" devid="Lights (MI_02)" index="11"/>
+            <light name="Lower Left Speaker Avg R" devid="Lights (MI_02)" index="3"/>
+            <light name="Lower Left Speaker Avg G" devid="Lights (MI_02)" index="4"/>
+            <light name="Lower Left Speaker Avg B" devid="Lights (MI_02)" index="5"/>
+            <light name="Lower Right Speaker Avg R" devid="Lights (MI_02)" index="6"/>
+            <light name="Lower Right Speaker Avg G" devid="Lights (MI_02)" index="7"/>
+            <light name="Lower Right Speaker Avg B" devid="Lights (MI_02)" index="8"/>
+            <light name="Control Panel Avg R" devid="Lights (MI_02)" index="15"/>
+            <light name="Control Panel Avg G" devid="Lights (MI_02)" index="16"/>
+            <light name="Control Panel Avg B" devid="Lights (MI_02)" index="17"/>
+        </lights>
+    </template>
+</templates>
@@ -23,7 +23,7 @@
    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
        <security>
            <requestedPrivileges>
-                <requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>
+                <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
            </requestedPrivileges>
        </security>
    </trustInfo>
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash

 # set to EN-US for consistency
 LANG=en_us_8859_1
@@ -41,12 +41,18 @@ done
 # settings
 GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD 2> /dev/null || echo "none")
 GIT_HEAD=$(git rev-parse HEAD || echo "none")
-TOOLCHAIN_32="/usr/share/mingw/toolchain-i686-w64-mingw32.cmake"
-TOOLCHAIN_64="/usr/share/mingw/toolchain-x86_64-w64-mingw32.cmake"
+TOOLCHAIN_32="${TOOLCHAIN_32:-"/usr/share/mingw/toolchain-i686-w64-mingw32.cmake"}"
+TOOLCHAIN_64="${TOOLCHAIN_64:-"/usr/share/mingw/toolchain-x86_64-w64-mingw32.cmake"}"
+TOOLCHAIN_WINXP_32="${TOOLCHAIN_WINXP_32:-"/opt/llvm-mingw-xp/toolchain-files/cmake/i686-mingw32-clang.cmake"}"
+TOOLCHAIN_WINXP_64="${TOOLCHAIN_WINXP_64:-"/opt/llvm-mingw-xp/toolchain-files/cmake/x86_64-mingw32-clang.cmake"}"
 BUILDDIR_32_RELEASE="./cmake-build-release-32"
 BUILDDIR_32_DEBUG="./cmake-build-debug-32"
 BUILDDIR_64_RELEASE="./cmake-build-release-64"
 BUILDDIR_64_DEBUG="./cmake-build-debug-64"
+BUILDDIR_WINXP_32_RELEASE="./cmake-build-release-winxp-32"
+BUILDDIR_WINXP_32_DEBUG="./cmake-build-debug-winxp-32"
+BUILDDIR_WINXP_64_RELEASE="./cmake-build-release-winxp-64"
+BUILDDIR_WINXP_64_DEBUG="./cmake-build-debug-winxp-64"
 DEBUG=0
 OUTDIR="./bin/spice2x"
 OUTDIR_EXTRAS="./bin/spice2x/extras"
@@ -62,19 +68,36 @@ DIST_FOLDER="./dist"
 DIST_NAME="spice2x-$(date +%y)-$(date +%m)-$(date +%d).zip"
 DIST_NAME_EXTRAS="spice2x-$(date +%y)-$(date +%m)-$(date +%d)-full.zip"
 DIST_COMMENT=${DIST_NAME}$'\n'"$GIT_BRANCH - $GIT_HEAD"$'\nThank you for playing.'
-TARGETS_32="spicetools_stubs_kbt spicetools_stubs_kld spicetools_cfg spicetools_cfg_linux spicetools_spice spicetools_spice_laa spicetools_spice_linux spicetools_stubs_cpusbxpkm"
-TARGETS_64="spicetools_stubs_kbt64 spicetools_stubs_kld64 spicetools_stubs_nvEncodeAPI64 spicetools_stubs_nvcuvid spicetools_stubs_nvcuda spicetools_spice64 spicetools_spice64_linux"
+TARGETS_32="spicetools_stubs_kbt spicetools_stubs_kld spicetools_cfg spicetools_cfg_linux spicetools_spice spicetools_spice_laa spicetools_spice_linux spicetools_stubs_cpusbxpkm spicetools_sdk_sample_v0_flat_c_32"
+TARGETS_64="spicetools_stubs_kbt64 spicetools_stubs_kld64 spicetools_stubs_nvEncodeAPI64 spicetools_stubs_nvcuvid spicetools_stubs_nvcuda spicetools_spice64 spicetools_spice64_linux spicetools_sdk_sample_v0_flat_c_64 spicetools_sdk_sample_v0_cpp_64"
+TARGETS_XP32="spicetools_cfg spicetools_spice"
+TARGETS_XP64="spicetools_spice64"

 # determine build type
 BUILD_TYPE="Release"
 BUILDDIR_32=${BUILDDIR_32_RELEASE}
 BUILDDIR_64=${BUILDDIR_64_RELEASE}
+BUILDDIR_WINXP_32=${BUILDDIR_WINXP_32_RELEASE}
+BUILDDIR_WINXP_64=${BUILDDIR_WINXP_64_RELEASE}
 if ((DEBUG > 0))
 then
 	BUILD_TYPE="Debug"
 	BUILDDIR_32=${BUILDDIR_32_DEBUG}
 	BUILDDIR_64=${BUILDDIR_64_DEBUG}
-	DIST_NAME=$(echo ${DIST_NAME} | sed 's/\.[^.]*$/-dbg&/')
+	BUILDDIR_WINXP_32=${BUILDDIR_WINXP_32_DEBUG}
+	BUILDDIR_WINXP_64=${BUILDDIR_WINXP_64_DEBUG}
+	DIST_NAME=$(echo "${DIST_NAME}" | sed 's/\.[^.]*$/-dbg&/')
+fi
+
+# is the XP-compatible toolchain installed?
+XP_MUST_BUILD=0
+BUILD_XP=0
+if [ -f "$TOOLCHAIN_WINXP_32" ] && [ -f "$TOOLCHAIN_WINXP_64" ]; then
+	BUILD_XP=1;
+elif ((XP_MUST_BUILD > 0))
+then
+	echo "WinXP toolchain not available, aborting"
+	exit 1
 fi

 # determine number of cores
@@ -90,6 +113,13 @@ echo "Git Branch: $GIT_BRANCH"
 echo "Git Head: $GIT_HEAD"
 echo "Toolchain for 32bit targets: $TOOLCHAIN_32"
 echo "Toolchain for 64bit targets: $TOOLCHAIN_64"
+if ((BUILD_XP > 0))
+then
+	echo "Toolchain for WinXP 32bit targets: $TOOLCHAIN_WINXP_32"
+	echo "Toolchain for WinXP 64bit targets: $TOOLCHAIN_WINXP_64"
+else
+	echo "WinXP toolchain not available, skipping WinXP builds"
+fi
 echo "Distribution Name: $DIST_NAME"
 echo "Build Type: $BUILD_TYPE"
 echo "Cores: $CORES"
@@ -114,7 +144,7 @@ time (
 	fi
 	mkdir -p ${BUILDDIR_32}
 	pushd ${BUILDDIR_32} > /dev/null
-	cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_32} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} $OLDPWD && ninja ${TARGETS_32}
+	cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_32} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} "$OLDPWD" && ninja ${TARGETS_32}
 	popd > /dev/null

 	# 64 bit
@@ -127,14 +157,62 @@ time (
 	fi
 	mkdir -p ${BUILDDIR_64}
 	pushd ${BUILDDIR_64} > /dev/null
-	cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_64} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} $OLDPWD && ninja ${TARGETS_64}
+	cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_64} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} "$OLDPWD" && ninja ${TARGETS_64}
 	popd > /dev/null

+	if ((BUILD_XP > 0))
+	then
+		# 32 bit Windows XP
+		echo ""
+		echo "Building 32bit targets (WinXP toolchain)..."
+		echo "========================="
+		if ((CLEAN_BUILD > 0))
+		then
+			rm -rf ${BUILDDIR_WINXP_32}
+		fi
+		mkdir -p ${BUILDDIR_WINXP_32}
+		pushd ${BUILDDIR_WINXP_32} > /dev/null
+		cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_WINXP_32} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DSPICE_XP=ON "$OLDPWD" && ninja ${TARGETS_XP32}
+		popd > /dev/null
+
+		# 64 bit Windows XP
+		echo ""
+		echo "Building 64bit targets (WinXP toolchain)..."
+		echo "========================="
+		if ((CLEAN_BUILD > 0))
+		then
+			rm -rf ${BUILDDIR_WINXP_64}
+		fi
+		mkdir -p ${BUILDDIR_WINXP_64}
+		pushd ${BUILDDIR_WINXP_64} > /dev/null
+		cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_WINXP_64} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DSPICE_XP=ON "$OLDPWD" && ninja ${TARGETS_XP64}
+		popd > /dev/null
+	else
+		echo ""
+		echo "Skipping WinXP builds, toolchain not specified"
+	fi
+
 	echo ""
 	echo "Compilation process done :)"
 	echo "==========================="
 )

+if ((BUILD_XP > 0))
+then
+	echo ""
+	echo "Checking XP compatibility..."
+	echo "============================="
+	if ! command -v windows_dll_compat_checker &> /dev/null; then
+		echo "WARNING: windows_dll_compat_checker not found, skipping XP compatibility check"
+	else
+		windows_dll_compat_checker -s PREMADE/winxp_x86_64.ini \
+			${BUILDDIR_WINXP_64}/spicetools/64/spice64.exe
+		windows_dll_compat_checker -s PREMADE/winxp_x86_64_32bit_dlls.ini \
+			${BUILDDIR_WINXP_32}/spicetools/spicecfg.exe \
+			${BUILDDIR_WINXP_32}/spicetools/32/spice.exe
+	fi
+fi
+
 # generate PDBs
 if false  # ((DEBUG > 0))
 then
@@ -191,6 +269,12 @@ rm -rf ${OUTDIR_EXTRAS}
 mkdir -p ${OUTDIR_EXTRAS}
 mkdir -p ${OUTDIR_EXTRAS}/largeaddressaware
 mkdir -p ${OUTDIR_EXTRAS}/linux
+mkdir -p ${OUTDIR_EXTRAS}/sdk/samples/32
+mkdir -p ${OUTDIR_EXTRAS}/sdk/samples/64
+if ((BUILD_XP > 0))
+then
+mkdir -p ${OUTDIR_EXTRAS}/winxp
+fi

 if false # ((DEBUG > 0))
 then
@@ -199,16 +283,8 @@ then
    cp ${BUILDDIR_32}/spicetools/spicecfg-pdb.pdb ${OUTDIR} 2>/dev/null
    cp ${BUILDDIR_32}/spicetools/32/spice-pdb.exe ${OUTDIR} 2>/dev/null
    cp ${BUILDDIR_32}/spicetools/32/spice-pdb.pdb ${OUTDIR} 2>/dev/null
-    #cp ${BUILDDIR_32}/spicetools/32/kbt.dll ${OUTDIR}/stubs/32 2>/dev/null
-    #cp ${BUILDDIR_32}/spicetools/32/kld.dll ${OUTDIR}/stubs/32 2>/dev/null
    cp ${BUILDDIR_64}/spicetools/64/spice64-pdb.exe ${OUTDIR} 2>/dev/null
    cp ${BUILDDIR_64}/spicetools/64/spice64-pdb.pdb ${OUTDIR} 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/kbt.dll ${OUTDIR}/stubs/64 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/kld.dll ${OUTDIR}/stubs/64 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/nvEncodeAPI64.dll ${OUTDIR}/stubs/64 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/nvcuda.dll ${OUTDIR}/stubs/64 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/nvcuvid.dll ${OUTDIR}/stubs/64 2>/dev/null
-	#cp ${BUILDDIR_32}/spicetools/32/cpusbxpkm.dll ${OUTDIR}/stubs/32 2>/dev/null
 else
    # release files
    cp ${BUILDDIR_32}/spicetools/spicecfg.exe ${OUTDIR} 2>/dev/null
@@ -216,16 +292,21 @@ else
    cp ${BUILDDIR_32}/spicetools/32/spice.exe ${OUTDIR} 2>/dev/null
    cp ${BUILDDIR_32}/spicetools/32/spice_laa.exe ${OUTDIR_EXTRAS}/largeaddressaware/spice.exe 2>/dev/null
    cp ${BUILDDIR_32}/spicetools/32/spice_linux.exe ${OUTDIR_EXTRAS}/linux/spice.exe 2>/dev/null
-    #cp ${BUILDDIR_32}/spicetools/32/kbt.dll ${OUTDIR}/stubs/32 2>/dev/null
-    #cp ${BUILDDIR_32}/spicetools/32/kld.dll ${OUTDIR}/stubs/32 2>/dev/null
    cp ${BUILDDIR_64}/spicetools/64/spice64.exe ${OUTDIR} 2>/dev/null
    cp ${BUILDDIR_64}/spicetools/64/spice64_linux.exe ${OUTDIR_EXTRAS}/linux/spice64.exe 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/kbt.dll ${OUTDIR}/stubs/64 2>/dev/null
-    #cp ${BUILDDIR_64}/spicetools/64/kld.dll ${OUTDIR}/stubs/64 2>/dev/null
    cp ${BUILDDIR_64}/spicetools/64/nvEncodeAPI64.dll ${OUTDIR}/stubs/64 2>/dev/null
    cp ${BUILDDIR_64}/spicetools/64/nvcuda.dll ${OUTDIR}/stubs/64 2>/dev/null
    cp ${BUILDDIR_64}/spicetools/64/nvcuvid.dll ${OUTDIR}/stubs/64 2>/dev/null
    cp ${BUILDDIR_32}/spicetools/32/cpusbxpkm.dll ${OUTDIR}/stubs/32 2>/dev/null
+	cp ${BUILDDIR_32}/spicetools/32/sdk_sample_v0_flat_c.dll ${OUTDIR_EXTRAS}/sdk/samples/32/v0_flat_c.dll 2>/dev/null
+	cp ${BUILDDIR_64}/spicetools/64/sdk_sample_v0_flat_c.dll ${OUTDIR_EXTRAS}/sdk/samples/64/v0_flat_c.dll 2>/dev/null
+	cp ${BUILDDIR_64}/spicetools/64/sdk_sample_v0_cpp.dll ${OUTDIR_EXTRAS}/sdk/samples/64/v0_cpp.dll 2>/dev/null
+	if ((BUILD_XP > 0))
+	then
+		cp ${BUILDDIR_WINXP_32}/spicetools/spicecfg.exe ${OUTDIR_EXTRAS}/winxp 2>/dev/null
+		cp ${BUILDDIR_WINXP_32}/spicetools/32/spice.exe ${OUTDIR_EXTRAS}/winxp 2>/dev/null
+		cp ${BUILDDIR_WINXP_64}/spicetools/64/spice64.exe ${OUTDIR_EXTRAS}/winxp 2>/dev/null
+	fi
 fi

 # pack source files to output directory
@@ -234,10 +315,13 @@ mkdir -p ${OUTDIR}/src
 if ((INCLUDE_SRC > 0))
 then
 	echo "Generating source file archive..."
-	git archive --format tar.gz --prefix=spice2x/ HEAD ./ > ${OUTDIR}/src/spice2x-${GIT_BRANCH}.tar.gz 2>/dev/null || \
+	git archive --format tar.gz --prefix=spice2x/ HEAD ./ > "${OUTDIR}/src/spice2x-${GIT_BRANCH}.tar.gz" 2>/dev/null || \
 		echo "WARNING: Couldn't get git to create the archive. Is this a git repository?"
 fi

+# sdk headers
+cp -r ./sdk/include ${OUTDIR_EXTRAS}/sdk
+
 # copy resources
 rm -rf ${OUTDIR_EXTRAS}/api
 mkdir ${OUTDIR_EXTRAS}/api
@@ -249,11 +333,11 @@ if ((DIST_ENABLE > 0))
 then
 	echo "Building dist..."
 	mkdir -p ${DIST_FOLDER}
-	rm -rf ${DIST_FOLDER}/${DIST_NAME}
-	pushd ${OUTDIR}/.. > /dev/null
-	zip -qrXT9 $OLDPWD/${DIST_FOLDER}/${DIST_NAME} spice2x -x "spice2x/extras/*" -z <<< "$DIST_COMMENT"
+	rm -rf "${DIST_FOLDER}/${DIST_NAME}"
+	pushd ${OUTDIR} > /dev/null
+	zip -qrXT9 "$OLDPWD/${DIST_FOLDER}/${DIST_NAME}" . -x "extras/*" -z <<< "$DIST_COMMENT"
 	echo "Building extras..."
-	zip -qrXT9 $OLDPWD/${DIST_FOLDER}/${DIST_NAME_EXTRAS} spice2x -z <<< "$DIST_COMMENT"
+	zip -qrXT9 "$OLDPWD/${DIST_FOLDER}/${DIST_NAME_EXTRAS}" . -z <<< "$DIST_COMMENT"
 	popd > /dev/null
 fi

@@ -1,6 +1,6 @@
 docker build --pull external/docker -t spicetools/deps
 docker build --build-context gitroot=%cd%/../../.git . -t spicetools/spice
-docker run --rm -it -v %cd%/dist:/src/src/spice2x/dist -v %cd%/bin:/src/src/spice2x/bin -v %cd%/.ccache:/src/src/spice2x/.ccache spicetools/spice %*
+docker run --rm -i -v %cd%/dist:/src/src/spice2x/dist -v %cd%/bin:/src/src/spice2x/bin -v %cd%/.ccache:/src/src/spice2x/.ccache spicetools/spice %*
@REM to generate PDBs, set DEBUG to 1 in build_all.sh, place cv2pdb in external\cv2pdb, and run below
@REM external\cv2pdb\cv2pdb.exe bin\spice2x\spicecfg.exe bin\spice2x\spicecfg-pdb.exe bin\spice2x\spicecfg-pdb.pdb
@REM external\cv2pdb\cv2pdb.exe bin\spice2x\spice.exe bin\spice2x\spice-pdb.exe bin\spice2x\spice-pdb.pdb
@@ -1,4 +1,12 @@
-#!/bin/bash
-docker build --pull $PWD/external/docker -t spicetools/deps --platform linux/x86_64
-docker build --build-context gitroot=$PWD/../../.git . -t spicetools/spice:latest
-docker run --rm -v $PWD/dist:/src/src/spice2x/dist -v $PWD/bin:/src/src/spice2x/bin -v $PWD/.ccache:/src/src/spice2x/.ccache spicetools/spice "$@"
+#!/usr/bin/env bash
+
+set -eu
+
+docker build --pull "$PWD/external/docker" -t spicetools/deps --platform linux/x86_64
+docker build --build-context gitroot="$PWD/../../.git" . -t spicetools/spice:latest
+
+# Interactive TTY if available, so docker build can be Ctrl+C'd
+DOCKER_FLAGS=""
+[ -t 0 ] && DOCKER_FLAGS="-it"
+
+docker run $DOCKER_FLAGS --rm -v "$PWD/dist:/src/src/spice2x/dist" -v "$PWD/bin:/src/src/spice2x/bin" -v "$PWD/.ccache:/src/src/spice2x/.ccache" spicetools/spice "$@"
@@ -13,5 +13,6 @@ IDR_LICENSES RCDATA "../licenses.txt"
 IDR_PATCHES RCDATA "../build/patches.json"
 IDR_README RCDATA "../readme.txt"
 IDR_DSEGFONT RCDATA "../external/dseg/DSEG14Classic-Italic.ttf"
+IDR_CONTROLLER_PRESETS_BUILTIN RCDATA "../build/controller_presets.xml"

 #endif
@@ -90,6 +90,10 @@ std::string Analog::getDisplayString(rawinput::RawInputManager *manager) {
                return "MIDI Unknown Index " + indexString + " (" + device->desc + ")";
            }
        }
+        case rawinput::XINPUT_GAMEPAD:
+            return fmt::format("{} ({})",
+                xinput::get_analog_string(static_cast<xinput::XInputAnalogEnum>(index)),
+                device->desc);
        case rawinput::DESTROYED:
            return "Device unplugged (" + indexString + ")";
        default:
@@ -203,22 +207,38 @@ float Analog::applyMultiplier(float value) {
 }

 float Analog::normalizeAnalogValue(float value) {
-    // effectively the same as fmodf(value, 1.f)
-    // for small values, this is MUCH faster than fmodf.
-    float new_value = value;
-    while (new_value > 1.f) {
-        new_value -= 1.f;
+    if (getType() == GameAPI::Analogs::AnalogType::Circular) {
+        // effectively the same as fmodf(value, 1.f)
+        // for small values, this is MUCH faster than fmodf.
+        float new_value = value;
+        while (new_value > 1.f) {
+            new_value -= 1.f;
+        }
+        while (new_value < 0.f) {
+            new_value += 1.f;
+        }
+        return new_value;
+
+    } else {
+        // clamp to [0, 1] range
+        return std::clamp(value, 0.f, 1.f);
    }
-    while (new_value < 0.f) {
-        new_value += 1.f;
-    }
-    return new_value;
 }

 float Analog::applyDeadzone(float raw_value) {
    float value = raw_value;
-    const auto deadzone = this->getDeadzone();
-    if (deadzone > 0) {
+    auto deadzone = this->getDeadzone();
+
+    // in the past, positive deadzone applied in the center, negative deadzone applied to 0
+    // after each analog value received a type (circular/linear) this has been simpliifed to
+    // positive values only since we can figure out where the rest value is
+    // for back compat, treat negative value as positive
+    if (deadzone < 0.f) {
+        deadzone = -deadzone;
+    }
+
+    // relative mode assumes that user is using a stick, so center is neutral regardless of analog type
+    if (getType() != GameAPI::Analogs::AnalogType::LinearPositive || isRelativeMode()) {

        // calculate values
        const auto delta = value - 0.5f;
@@ -251,7 +271,7 @@ float Analog::applyDeadzone(float raw_value) {
            }
        }

-    } else if (deadzone < 0) {
+    } else {

        // invert for mirror
        if (this->getDeadzoneMirror()) {
@@ -259,8 +279,8 @@ float Analog::applyDeadzone(float raw_value) {
        }

        // deadzone from minimum value
-        if (deadzone > -1 && value > -deadzone) {
-            value = std::min(1.f, (value + deadzone) / (1.f + deadzone));
+        if (deadzone < 1.f && deadzone < value) {
+            value = std::max(0.f, (value - deadzone) / (1.f - deadzone));
        } else {
            value = 0.f;
        }
@@ -272,3 +292,74 @@ float Analog::applyDeadzone(float raw_value) {
    }
    return value;
 }
+
+float Analog::getRelativeModeValue(float raw_value) {
+    const auto now = get_performance_seconds();
+    auto delta_time = now - this->rel_mode_last_read_time_s;
+
+    if (this->rel_mode_last_read_time_s != 0.f) {
+        // some heuristics to prevent huge jumps:
+        //  * if we went for more than 250ms without polls, discard it (e.g., during loading screens)
+        //  * cap the delta at 100ms to prevent huge jumps in case of very infrequent polling
+        if (delta_time < 0.f || 0.25f < delta_time) {
+            delta_time = 0.f;
+        } else if (delta_time > 0.1f) {
+            delta_time = 0.1f;
+        }
+
+        // scale [0, 1] to [-1, 1] to simplify calculations
+        const auto delta_raw_value = (raw_value - 0.5f) * 2.f;
+
+        // target is one revolution per second at max speed at 1.0 sensitivity
+        auto adjusted_delta_value = delta_raw_value * delta_time;
+
+        // multiplier / divisor
+        if (this->getMultiplier() > 1) {
+            adjusted_delta_value *= this->getMultiplier();
+        } else if (this->getMultiplier() < -1) {
+            adjusted_delta_value /= -this->getMultiplier();
+        }
+
+        // sensitivity
+        if (this->isSensitivitySet()) {
+            adjusted_delta_value *= this->getSensitivity();
+        }
+
+        // calculate the new absolute value
+        this->rel_mode_absolute_value += adjusted_delta_value;
+    }
+
+    // update for next poll
+    this->rel_mode_last_read_time_s = now;
+    this->rel_mode_absolute_value = normalizeAnalogValue(this->rel_mode_absolute_value);
+    return this->rel_mode_absolute_value;
+}
+
+float Analog::getDelayedValue(float raw_value) {
+    const double delay_ms = static_cast<double>(this->getDelayMs());
+    if (delay_ms == 0.0) {
+        return raw_value;
+    }
+
+    // always push a new value
+    const auto now = get_performance_milliseconds();
+    this->delayed_inputs.emplace(now, raw_value);
+    
+    // drain the queue down to reasonable length to prevent unconstrained growth
+    // this would accommodate 1 second at ~1000Hz which is overkill
+    // (UI only allows for 250ms of delay)
+    while (this->delayed_inputs.size() > 1024) {
+        this->delayed_inputs.pop();
+    }
+
+    // pop until we find the oldest value still inside the delay window
+    while (this->delayed_inputs.size() > 1) {
+        const auto delta_t = now - this->delayed_inputs.front().time_in_ms;
+        if (delta_t <= delay_ms) {
+            break;
+        }
+        this->delayed_inputs.pop();
+    }
+
+    return this->delayed_inputs.front().value;
+}
@@ -1,5 +1,6 @@
 #pragma once

+#include <cstdint>
 #include <array>
 #include <string>
 #include <cmath>
@@ -13,12 +14,32 @@ namespace rawinput {
    class RawInputManager;
 }

+namespace GameAPI::Analogs {
+    enum class AnalogType {
+        // default; values wrap around (below 0 turns into 1, over 1 is 0)
+        // knobs, turntables
+        Circular = 0,
+
+        // typical joystick that rests at the center and caps at [0, 1]
+        LinearCentered = 1,
+
+        // one-directional value (sliders and instruments like piano/drum velocity)
+        // starts at 0 and goes up to 1
+        LinearPositive = 2,
+    };
+}
+
 struct AnalogMovingAverage {
    double time_in_ms;
    float sine;
    float cosine;
 };

+struct AnalogDelayEntry {
+    double time_in_ms;
+    float value;
+};
+
 class Analog {
 private:
    std::string name;
@@ -31,10 +52,11 @@ private:
    float last_state = 0.5f;
    bool sensitivity_set = false;
    bool deadzone_set = false;
+    GameAPI::Analogs::AnalogType type = GameAPI::Analogs::AnalogType::Circular;
    
    // smoothing function
    bool smoothing = false;
-    std::array<AnalogMovingAverage, ANALOG_HISTORY_CNT> vector_history;
+    std::array<AnalogMovingAverage, ANALOG_HISTORY_CNT> vector_history = {};
    int vector_history_index = 0;
    float smoothed_last_state = 0.f;

@@ -48,12 +70,13 @@ private:
    unsigned short divisor_region = 0;

    // relative input mode
-    float absolute_value_for_rel_mode = 0.5f;
+    float rel_mode_absolute_value = 0.5f;
+    float rel_mode_last_read_time_s = 0.f;
    bool relative_mode = false;

-    // circular buffer (delayed input)
-    int delay_buffer_depth = 0;
-    std::queue<float> delay_buffer;
+    // delay
+    uint32_t delay_ms = 0;
+    std::queue<AnalogDelayEntry> delayed_inputs;

    float calculateAngularDifference(float old_rads, float new_rads);
    float normalizeAngle(float rads);
@@ -66,7 +89,8 @@ public:
    float override_state = 0.5f;

    explicit Analog(std::string name) : name(std::move(name)) {
-        vector_history.fill({0.0, 0.f, 0.f});
+    };
+    explicit Analog(std::string name, GameAPI::Analogs::AnalogType type) : name(std::move(name)), type(type) {
    };

    std::string getDisplayString(rawinput::RawInputManager* manager);
@@ -74,6 +98,8 @@ public:
    float applyAngularSensitivity(float raw_rads);
    float applyMultiplier(float raw_value);
    float applyDeadzone(float raw_value);
+    float getRelativeModeValue(float raw_value);
+    float getDelayedValue(float raw_value);

    inline bool isSet() {
        if (this->override_enabled) {
@@ -90,7 +116,8 @@ public:
        deadzone_mirror = false;
        setMultiplier(1);
        setRelativeMode(false);
-        setDelayBufferDepth(0);
+        setLastState(0.5f);
+        setDelayMs(0);
    }

    inline void clearBindings() {
@@ -192,25 +219,27 @@ public:
    }

    inline void setRelativeMode(bool relative_mode) {
+        if (relative_mode) {
+            this->smoothing = false;
+        }
        this->relative_mode = relative_mode;
-        this->absolute_value_for_rel_mode = 0.5f;
+        this->rel_mode_absolute_value = 0.5f;
+        this->rel_mode_last_read_time_s = 0.f;
    }

-    inline float getAbsoluteValue(float relative_delta) {
-        this->absolute_value_for_rel_mode =
-            normalizeAnalogValue(this->absolute_value_for_rel_mode + relative_delta);
-        return this->absolute_value_for_rel_mode;
+    inline GameAPI::Analogs::AnalogType getType() const {
+        return this->type;
    }

-    inline int getDelayBufferDepth() const {
-        return this->delay_buffer_depth;
+    inline void setType(GameAPI::Analogs::AnalogType type) {
+        this->type = type;
    }

-    inline void setDelayBufferDepth(int depth) {
-        this->delay_buffer_depth = depth;
+    inline uint32_t getDelayMs() const {
+        return this->delay_ms;
    }

-    inline std::queue<float> &getDelayBuffer() {
-        return this->delay_buffer;
+    inline void setDelayMs(uint32_t delay_ms) {
+        this->delay_ms = delay_ms;
    }
 };
@@ -1,5 +1,6 @@
 #include "api.h"

+#include <cassert>
 #include <optional>

 #include "launcher/superexit.h"
@@ -37,7 +38,11 @@ std::vector<Button> GameAPI::Buttons::sortButtons(
        for (auto &bt : buttons) {
            if (name == bt.getName()) {
                button_found = true;
-                sorted.push_back(bt);
+                Button button_new = bt;
+                if (vkey_defaults) {
+                    button_new.setVKeyDefault(vkey_defaults->at(index));
+                }
+                sorted.push_back(button_new);
                break;
            }
        }
@@ -47,6 +52,7 @@ std::vector<Button> GameAPI::Buttons::sortButtons(

            if (vkey_defaults) {
                button.setVKey(vkey_defaults->at(index));
+                button.setVKeyDefault(vkey_defaults->at(index));
            }
        }

@@ -193,9 +199,19 @@ GameAPI::Buttons::State GameAPI::Buttons::getState(rawinput::RawInputManager *ma
                            if (vKey < value_states->size()) {
                                auto value = value_states->at(vKey);
                                if (current_button->getAnalogType() == BAT_POSITIVE) {
-                                    state = value > 0.6f ? BUTTON_PRESSED : BUTTON_NOT_PRESSED;
+                                    float threshold = 0.6f;
+                                    if (current_button->getBatThreshold() > 0) {
+                                        threshold = std::clamp(current_button->getBatThreshold() / 100.f, 0.01f, 0.99f);
+                                    }
+                                    state = value > threshold ? BUTTON_PRESSED : BUTTON_NOT_PRESSED;
+
                                } else if (current_button->getAnalogType() == BAT_NEGATIVE) {
-                                    state = value < 0.4f ? BUTTON_PRESSED : BUTTON_NOT_PRESSED;
+                                    float threshold = 0.4f;
+                                    if (current_button->getBatThreshold() > 0) {
+                                        threshold = std::clamp((100 - current_button->getBatThreshold()) / 100.f, 0.01f, 0.99f);
+                                    }
+                                    state = value < threshold ? BUTTON_PRESSED : BUTTON_NOT_PRESSED;
+
                                } else {
                                    state = value > 0.01f ? BUTTON_PRESSED : BUTTON_NOT_PRESSED;
                                }
@@ -384,6 +400,16 @@ GameAPI::Buttons::State GameAPI::Buttons::getState(rawinput::RawInputManager *ma
                }
                case rawinput::PIUIO_DEVICE: {
                    state = device->piuioDev->IsPressed(vKey) ? BUTTON_PRESSED : BUTTON_NOT_PRESSED;
+                    break;
+                }
+                case rawinput::XINPUT_GAMEPAD: {
+                    assert(reinterpret_cast<uintptr_t>(device->handle) < XUSER_MAX_COUNT);
+                    const auto player = static_cast<uint8_t>(reinterpret_cast<uintptr_t>(device->handle));
+                    state = manager->XINPUT_MGR->is_button_pressed(
+                        player,
+                        static_cast<xinput::XInputButtonEnum>(vKey)) ?
+                        BUTTON_PRESSED : BUTTON_NOT_PRESSED;
+                    break;
                }
                default:
                    break;
@@ -581,7 +607,7 @@ float Buttons::getVelocity(std::unique_ptr<rawinput::RawInputManager> &manager,
    }
 }

-float GameAPI::Analogs::getState(rawinput::Device *device, Analog &analog) {
+float GameAPI::Analogs::getState(rawinput::RawInputManager *manager, rawinput::Device *device, Analog &analog) {
    float value = 0.5f;
    if (!device) {
        return value;
@@ -644,88 +670,107 @@ float GameAPI::Analogs::getState(rawinput::Device *device, Analog &analog) {
        case rawinput::HID: {

            // get value
-            if (inverted) {
-                value = 1.f - device->hidInfo->value_states[index];
-            } else {
-                value = device->hidInfo->value_states[index];
+            if (index < device->hidInfo->value_states.size()) {
+                if (inverted) {
+                    value = 1.f - device->hidInfo->value_states[index];
+                } else {
+                    value = device->hidInfo->value_states[index];
+                }
            }

            // deadzone
-            if (analog.isDeadzoneSet()) {
+            // do not apply deadzone to circular analogs since it doesn't make sense (except in relative mode)
+            if (analog.isDeadzoneSet() &&
+                (analog.getType() != AnalogType::Circular || analog.isRelativeMode())) {
                value = analog.applyDeadzone(value);
            }

-            if (analog.isRelativeMode()) {
-                float relative_delta = value - 0.5f;
-                // built-in scaling to make values reasonable
-                relative_delta /= 80.f;
+            if (analog.getType() == AnalogType::Circular) {

-                // integer multiplier/divisor
-                const auto mult = analog.getMultiplier();
-                if (mult < -1) {
-                    relative_delta /= -mult;
-                } else if (1 < mult) {
-                    relative_delta *= mult;
-                }
+                if (analog.isRelativeMode()) {
+                    value = analog.getRelativeModeValue(value);

-                // sensitivity (ranges from 0.0 to 4.0)
-                if (analog.isSensitivitySet()) {
-                    relative_delta *= analog.getSensitivity();
-                }
+                } else {
+                    // integer multiplier
+                    value = analog.applyMultiplier(value);

-                // translate relative movement to absolute value
-                value = analog.getAbsoluteValue(relative_delta);
+                    // smoothing/sensitivity
+                    if (analog.getSmoothing() || analog.isSensitivitySet()) {
+                        float rads = value * (float) M_TAU;

-            } else {
-                // integer multiplier
-                value = analog.applyMultiplier(value);
+                        // smoothing
+                        if (analog.getSmoothing()) {

-                // smoothing/sensitivity
-                if (analog.getSmoothing() || analog.isSensitivitySet()) {
-                    float rads = value * (float) M_TAU;
+                            // preserve direction
+                            if (rads >= M_TAU) {
+                                rads -= 0.0001f;
+                            }

-                    // smoothing
-                    if (analog.getSmoothing()) {
-
-                        // preserve direction
-                        if (rads >= M_TAU) {
-                            rads -= 0.0001f;
+                            // calculate angle
+                            rads = analog.getSmoothedValue(rads);
                        }

-                        // calculate angle
-                        rads = analog.getSmoothedValue(rads);
+                        // sensitivity
+                        if (analog.isSensitivitySet()) {
+                            rads = analog.applyAngularSensitivity(rads);
+                        }
+
+                        // apply to value
+                        value = rads * (float) M_1_TAU;
+                    }
+                }
+            } else {
+                // sensitivity
+                if (analog.isSensitivitySet()) {
+                    // adjust curve
+                    // values < 1.f : less sensitive around neutral
+                    // values > 1.f : more sensitive around neutral
+                    float curve = analog.getSensitivity();
+                    if (curve <= 0.f) {
+                        curve = 0.01f;
+                    }
+                    curve = 1.f / curve;
+
+                    if (analog.getType() == AnalogType::LinearCentered) {
+                        // convert 0.0..1.0 to -1.0..+1.0
+                        float signed_raw = (value - 0.5f) * 2.0f;
+                        // apply curve
+                        float sign = signed_raw < 0.0f ? -1.0f : 1.0f;
+                        float magnitude = fabsf(signed_raw);
+                        float curved = sign * powf(magnitude, curve);
+                        // convert back to 0.0..1.0
+                        value = curved * 0.5f + 0.5f;
+                    } else {
+                        value = powf(value, curve);
                    }

-                    // sensitivity
-                    if (analog.isSensitivitySet()) {
-                        rads = analog.applyAngularSensitivity(rads);
+                    value = std::clamp(value, 0.f, 1.f);
+                }
+
+                // multiplier / divisor
+                if (analog.getMultiplier() < -1) {
+                    if (analog.getType() == AnalogType::LinearCentered) {
+                        value = (value - 0.5f) / (-analog.getMultiplier()) + 0.5f;
+                    } else {
+                        value /= -analog.getMultiplier();
                    }

-                    // apply to value
-                    value = rads * (float) M_1_TAU;
+                    value = std::clamp(value, 0.f, 1.f);
+
+                } else if (analog.getMultiplier() > 1) {
+                    if (analog.getType() == AnalogType::LinearCentered) {
+                        value = (value - 0.5f) * analog.getMultiplier() + 0.5f;
+                    } else {
+                        value *= analog.getMultiplier();
+                    }
+
+                    value = std::clamp(value, 0.f, 1.f);
                }
            }

            // delay
-            if (0 < analog.getDelayBufferDepth()) {
-                auto& queue = analog.getDelayBuffer();
-
-                // ensure the queue isn't too long; drop old values
-                while (analog.getDelayBufferDepth() <= (int)queue.size()) {
-                    queue.pop();
-                }
-
-                // always push new value
-                queue.push(value);
-
-                // get a new value to return
-                if ((int)queue.size() < analog.getDelayBufferDepth()) {
-                    // not enough in the queue, stall for now, shouldn't happen often
-                    value = analog.getLastState();
-                } else {
-                    value = queue.front();
-                    queue.pop();
-                }
+            if (analog.getDelayMs() > 0) {
+                value = analog.getDelayedValue(value);
            }

            break;
@@ -760,6 +805,18 @@ float GameAPI::Analogs::getState(rawinput::Device *device, Analog &analog) {
            }
            break;
        }
+        case rawinput::XINPUT_GAMEPAD: {
+            assert(reinterpret_cast<uintptr_t>(device->handle) < XUSER_MAX_COUNT);
+            const auto player = static_cast<uint8_t>(reinterpret_cast<uintptr_t>(device->handle));
+            value = manager->XINPUT_MGR->get_analog_state(
+                player,
+                static_cast<xinput::XInputAnalogEnum>(index));
+            // invert value
+            if (inverted) {
+                value = 1.f - value;
+            }
+            break;
+        }
        default:
            break;
    }
@@ -799,6 +856,42 @@ std::vector<Analog> GameAPI::Analogs::sortAnalogs(
    return sorted;
 }

+static std::vector<Analog> sortAnalogsWithTypeInternal(
+    std::vector<Analog> &analogs,
+    const std::initializer_list<GameAPI::Analogs::AnalogWithType> list) {
+
+    std::vector<Analog> sorted;
+
+    bool analog_found;
+    for (auto &a : list) {
+        analog_found = false;
+
+        for (auto &analog : analogs) {
+            if (a.name == analog.getName()) {
+                analog_found = true;
+                analog.setType(a.type);
+                sorted.push_back(analog);
+                break;
+            }
+        }
+
+        if (!analog_found) {
+            sorted.emplace_back(a.name, a.type);
+        }
+    }
+
+    return sorted;
+}
+
+void GameAPI::Analogs::sortAnalogsWithType(
+    std::vector<Analog> *analogs,
+    const std::initializer_list<AnalogWithType> list) {
+
+    if (analogs) {
+        *analogs = sortAnalogsWithTypeInternal(*analogs, list);
+    }
+}
+
 float GameAPI::Analogs::getState(rawinput::RawInputManager *manager, Analog &analog) {

    // check override
@@ -815,7 +908,7 @@ float GameAPI::Analogs::getState(rawinput::RawInputManager *manager, Analog &ana
        return analog.getLastState();
    }

-    float state = getState(device, analog);
+    float state = getState(manager, device, analog);
    analog.setLastState(state);

    return state;
@@ -859,7 +952,45 @@ std::vector<Light> GameAPI::Lights::sortLights(
    return sorted;
 }

-void GameAPI::Lights::writeLight(rawinput::Device *device, int index, float value) {
+static std::vector<Light> sortLightsWithCategoryInternal(
+    const std::vector<Light> &lights,
+    const std::initializer_list<GameAPI::Lights::LightAndCategory> list)
+{
+    std::vector<Light> sorted;
+
+    bool light_found;
+    for (auto &name : list) {
+        light_found = false;
+
+        for (auto &light : lights) {
+            if (name.light_name == light.getName()) {
+                light_found = true;
+                Light light_new = light;
+                light_new.setCategory(name.category_name);
+                sorted.push_back(light_new);
+                break;
+            }
+        }
+
+        if (!light_found) {
+            sorted.emplace_back(name.light_name, name.category_name);
+        }
+    }
+
+    return sorted;
+}
+
+void GameAPI::Lights::sortLightsWithCategory(
+    std::vector<Light> *lights,
+    const std::initializer_list<LightAndCategory> list) {
+
+    if (lights) {
+        *lights = sortLightsWithCategoryInternal(*lights, list);
+    }
+}
+
+
+void GameAPI::Lights::writeLight(rawinput::RawInputManager *manager, rawinput::Device *device, int index, float value) {

    // check device
    if (!device) {
@@ -946,6 +1077,18 @@ void GameAPI::Lights::writeLight(rawinput::Device *device, int index, float valu
            }
            break;
        }
+        case rawinput::XINPUT_GAMEPAD: {
+            assert(reinterpret_cast<uintptr_t>(device->handle) < XUSER_MAX_COUNT);
+            const auto player = static_cast<uint8_t>(reinterpret_cast<uintptr_t>(device->handle));
+            if (index < static_cast<int>(xinput::XInputOutputEnum::COUNT)) {
+                manager->XINPUT_MGR->set_output_state(
+                    player, static_cast<xinput::XInputOutputEnum>(index), value);
+                // no need to set output_pending; xinput output handled immediately
+            } else {
+                log_warning("api", "invalid xinput light index: {}", index);
+            }
+            break;
+        }
        default:
            break;
    }
@@ -971,9 +1114,9 @@ void GameAPI::Lights::writeLight(rawinput::RawInputManager *manager, Light &ligh

        // write state
        if (light.override_enabled) {
-            writeLight(device, light.getIndex(), light.override_state);
+            writeLight(manager, device, light.getIndex(), light.override_state);
        } else {
-            writeLight(device, light.getIndex(), value);
+            writeLight(manager, device, light.getIndex(), value);
        }
    }

@@ -6,24 +6,20 @@
 #include <windows.h>
 #include "option.h"

+#include "button.h"
+#include "analog.h"
+#include "light.h"
+
 namespace rawinput {
    class RawInputManager;
    struct Device;
 }

-class Button;
-class Analog;
-class Light;
 class Game;
 class Option;

 namespace GameAPI {
    namespace Buttons {
-        enum State {
-            BUTTON_PRESSED = true,
-            BUTTON_NOT_PRESSED = false
-        };
-
        /**
         * Parses the config and returns the buttons set by the user.
         *
@@ -89,14 +85,15 @@ namespace GameAPI {
                const std::vector<Analog> &analogs,
                const std::vector<std::string> &analog_names);

-        template<typename T>
-        void sortAnalogs(std::vector<Analog> *analogs, T t) {
-            const std::vector<std::string> analog_names { t };
+        struct AnalogWithType {
+            const std::string name;
+            const AnalogType type;

-            if (analogs) {
-                *analogs = GameAPI::Analogs::sortAnalogs(*analogs, analog_names);
-            }
-        }
+            AnalogWithType(std::string name, AnalogType type) :
+                name(std::move(name)), type(type) {}
+        };
+
+        void sortAnalogsWithType(std::vector<Analog> *analogs, const std::initializer_list<AnalogWithType> list);

        template<typename T, typename... Rest>
        void sortAnalogs(std::vector<Analog> *analogs, T t, Rest... rest) {
@@ -107,27 +104,19 @@ namespace GameAPI {
            }
        }

-        float getState(rawinput::Device *device, Analog &analog);
+        float getState(rawinput::RawInputManager *manager, rawinput::Device *device, Analog &analog);
        float getState(rawinput::RawInputManager *manager, Analog &analog);
        float getState(std::unique_ptr<rawinput::RawInputManager> &manager, Analog &analog);
    }

    namespace Lights {
+
        std::vector<Light> getLights(const std::string &game_name);

        std::vector<Light> sortLights(
                const std::vector<Light> &lights,
                const std::vector<std::string> &light_names);

-        template<typename T>
-        void sortLights(std::vector<Light> *lights, T t) {
-            const std::vector<std::string> light_names { t };
-
-            if (lights) {
-                *lights = GameAPI::Lights::sortLights(*lights, light_names);
-            }
-        }
-
        template<typename T, typename... Rest>
        void sortLights(std::vector<Light> *lights, T t, Rest... rest) {
            const std::vector<std::string> light_names { t, rest... };
@@ -137,7 +126,17 @@ namespace GameAPI {
            }
        }

-        void writeLight(rawinput::Device *device, int index, float value);
+        struct LightAndCategory {
+            const std::string category_name;
+            const std::string light_name;
+
+            LightAndCategory(std::string category_name, std::string light_name) :
+                category_name(std::move(category_name)), light_name(std::move(light_name))  {}
+        };
+
+        void sortLightsWithCategory(std::vector<Light> *lights, const std::initializer_list<LightAndCategory> list);
+
+        void writeLight(rawinput::RawInputManager *manager, rawinput::Device *device, int index, float value);
        void writeLight(rawinput::RawInputManager *manager, Light &light, float value);
        void writeLight(std::unique_ptr<rawinput::RawInputManager> &manager, Light &light, float value);

@@ -152,7 +151,3 @@ namespace GameAPI {
        void sortOptions(std::vector<Option> &, const std::vector<OptionDefinition> &);
    }
 }
-
-#include "button.h"
-#include "analog.h"
-#include "light.h"
@@ -44,7 +44,7 @@ std::string Button::getVKeyString() {
        case 0x0C:
            return "Clear";
        case 0x0D:
-            return "Enter";
+            return "Enter/Return";
        case 0x10:
            return "Shift";
        case 0x11:
@@ -58,8 +58,28 @@ std::string Button::getVKeyString() {
            return "Pause";
        case 0x14:
            return "Caps Lock";
+        case 0x15:
+            return "IME Kana/Hangul";
+        case 0x16:
+            return "IME On";
+        case 0x17:
+            return "IME Junja";
+        case 0x18:
+            return "IME Final";
+        case 0x19:
+            return "IME Hanja/Kanji";
+        case 0x1A:
+            return "IME Off";
        case 0x1B:
            return "Escape";
+        case 0x1C:
+            return "IME Convert";
+        case 0x1D:
+            return "IME Nonconvert";
+        case 0x1E:
+            return "IME Accept";
+        case 0x1F:
+            return "IME Mode Change";
        case 0x20:
            return "Space";
        case 0x21:
@@ -163,37 +183,37 @@ std::string Button::getVKeyString() {
        case 0x5D:
            return "Apps";
        case 0x60:
-            return "Num 0";
+            return "Numpad 0";
        case 0x61:
-            return "Num 1";
+            return "Numpad 1";
        case 0x62:
-            return "Num 2";
+            return "Numpad 2";
        case 0x63:
-            return "Num 3";
+            return "Numpad 3";
        case 0x64:
-            return "Num 4";
+            return "Numpad 4";
        case 0x65:
-            return "Num 5";
+            return "Numpad 5";
        case 0x66:
-            return "Num 6";
+            return "Numpad 6";
        case 0x67:
-            return "Num 7";
+            return "Numpad 7";
        case 0x68:
-            return "Num 8";
+            return "Numpad 8";
        case 0x69:
-            return "Num 9";
+            return "Numpad 9";
        case 0x6A:
-            return "*";
+            return "Numpad *";
        case 0x6B:
-            return "+";
+            return "Numpad +";
        case 0x6C:
-            return "Seperator";
+            return "Numpad Seperator";
        case 0x6D:
-            return "-";
+            return "Numpad -";
        case 0x6E:
-            return ".";
+            return "Numpad .";
        case 0x6F:
-            return "/";
+            return "Numpad /";
        case 0x70:
            return "F1";
        case 0x71:
@@ -255,9 +275,11 @@ std::string Button::getVKeyString() {
        case 0xA3:
            return "Right Control";
        case 0xA4:
-            return "Left Menu";
+            return "Left Alt";
        case 0xA5:
-            return "Right Menu";
+            return "Right Alt";
+        case INVALID_VKEY:
+            return "Invalid";
        default:

            // check win API
@@ -284,7 +306,10 @@ std::string Button::getDisplayString(rawinput::RawInputManager* manager) {
    std::string vKeyString = fmt::format("{:#x}", vKey);

    // device must be existing
-    if (this->device_identifier.empty() && vKey == INVALID_VKEY) {
+    if (this->isNaive() && vKey == INVALID_VKEY) {
+        if (this->getInvert()) {
+            return "(always on)";
+        }
        return "";
    }

@@ -301,17 +326,17 @@ std::string Button::getDisplayString(rawinput::RawInputManager* manager) {
        switch (device->type) {
            case rawinput::MOUSE: {
                const char *btn = "Unknown";
-                static const char *MOUSE_NAMES[] = {
-                        "Left Mouse",
-                        "Right Mouse",
-                        "Middle Mouse",
-                        "Mouse 1",
-                        "Mouse 2",
-                        "Mouse 3",
-                        "Mouse 4",
-                        "Mouse 5",
-                };
-                if (vKey < sizeof(MOUSE_NAMES)) {
+                static const std::array<const char *, 8>MOUSE_NAMES = {
+                    "Left Mouse",
+                    "Right Mouse",
+                    "Middle Mouse",
+                    "Mouse 1",
+                    "Mouse 2",
+                    "Mouse 3",
+                    "Mouse 4",
+                    "Mouse 5",
+                    };
+                if (vKey < MOUSE_NAMES.size()) {
                    btn = MOUSE_NAMES[vKey];
                }
                return fmt::format("{} ({})", btn, device->desc);
@@ -395,6 +420,10 @@ std::string Button::getDisplayString(rawinput::RawInputManager* manager) {
            }
            case rawinput::PIUIO_DEVICE:
                return "PIUIO " + vKeyString;
+            case rawinput::XINPUT_GAMEPAD:
+                return fmt::format("{} ({})",
+                    xinput::get_button_string(static_cast<xinput::XInputButtonEnum>(vKey)),
+                    device->desc);
            case rawinput::DESTROYED:
                return "Device unplugged (" + vKeyString + ")";
            default:
@@ -1,15 +1,23 @@
 #pragma once

+#include <cstdint>
 #include <string>
 #include <utility>
 #include <vector>

-#include "api.h"
-
 namespace rawinput {
    class RawInputManager;
 }

+namespace GameAPI {
+    namespace Buttons {
+        enum State {
+            BUTTON_PRESSED = true,
+            BUTTON_NOT_PRESSED = false
+        };
+    }
+}
+
 enum ButtonAnalogType {
    BAT_NONE = 0,
    BAT_POSITIVE = 1,
@@ -41,19 +49,25 @@ private:
    std::string name;
    std::string device_identifier = "";
    unsigned short vKey = INVALID_VKEY;
+
+    // default bindings are always naive
+    unsigned short vKey_default = INVALID_VKEY;
+
    ButtonAnalogType analog_type = BAT_NONE;
    double debounce_up = 0.0;
    double debounce_down = 0.0;
+    int bat_threshold = 0; // for positive/negative only, value in percentage, zero is default
    bool invert = false;
+    bool is_temporary = false;

    GameAPI::Buttons::State last_state = GameAPI::Buttons::BUTTON_NOT_PRESSED;
    float last_velocity = 0.f;
    unsigned short velocity_threshold = 0;

-    std::string getVKeyString();
    std::string getMidiNoteString();

 public:
+    std::string getVKeyString();

    // overrides
    bool override_enabled = false;
@@ -70,12 +84,20 @@ public:
        if (this->override_enabled) {
            return true;
        }
+
+        // has a device
+        if (!this->device_identifier.empty()) {
+            return true;
+        }
+
+        // naive, and has a valid vKey
        if (this->vKey != INVALID_VKEY) {
            return true;
        }

        for (auto &alternative : this->alternatives) {
-            if (alternative.vKey != INVALID_VKEY) {
+            if (!alternative.getDeviceIdentifier().empty() ||
+                alternative.getVKey() != INVALID_VKEY) {
                return true;
            }
        }
@@ -88,6 +110,7 @@ public:
        alternatives.clear();
        device_identifier = "";
        analog_type = BAT_NONE;
+        bat_threshold = 0;
    }

    std::string getDisplayString(rawinput::RawInputManager* manager);
@@ -116,6 +139,14 @@ public:
        this->vKey = vKey;
    }

+    inline unsigned short getVKeyDefault() const {
+        return this->vKey_default;
+    }
+
+    inline void setVKeyDefault(unsigned short vKey_default) {
+        this->vKey_default = vKey_default;
+    }
+
    inline ButtonAnalogType getAnalogType() const {
        return this->analog_type;
    }
@@ -140,6 +171,14 @@ public:
        this->debounce_down = debounce_time_down;
    }

+    inline void setBatThreshold(int bat_threshold) {
+        this->bat_threshold = bat_threshold;
+    }
+
+    inline int getBatThreshold() const {
+        return this->bat_threshold;
+    }
+
    inline bool getInvert() const {
        return this->invert;
    }
@@ -164,6 +203,14 @@ public:
        this->last_velocity = last_velocity;
    }

+    inline bool isTemporary() const {
+        return this->is_temporary;
+    }
+
+    inline void setTemporary(bool is_temporary) {
+        this->is_temporary = is_temporary;
+    }
+
    inline unsigned short getVelocityThreshold() const {
        return this->velocity_threshold;
    }
@@ -172,6 +219,20 @@ public:
        this->velocity_threshold = velocity_threshold;
    }

+    inline bool isValid() {
+        // temporarily created by UI
+        if (isTemporary()) {
+            return true;
+        }
+
+        // nothing is set
+        if (getDeviceIdentifier().empty() && getVKey() == INVALID_VKEY) {
+            return false;
+        }
+
+        return true;
+    }
+
    void getMidiVKey(int& channel, int& index);
    void setMidiVKey(rawinput::RawInputManager* manager, bool is_note, int channel, int index);

@@ -1,5 +1,6 @@
 #include "config.h"
 #include "util/logging.h"
+#include "cfg/button.h"

 /*
 * This code absolutely sucks.
@@ -10,6 +11,14 @@
 // settings
 std::string CONFIG_PATH_OVERRIDE = "";

+#define CFG_DEBUG_VERBOSE 0
+
+#if CFG_DEBUG_VERBOSE
+#define log_debug(module, format_str, ...) logger::push( \
+    LOG_FORMAT("M", module, format_str, ## __VA_ARGS__), logger::Style::GREY)
+#else
+#define log_debug(module, format_str, ...)
+#endif

 ///////////////////
 /// Constructor ///
@@ -19,7 +28,7 @@ Config::Config() {
    this->status = false;
    if (CONFIG_PATH_OVERRIDE.length() > 0) {
        this->configLocation = CONFIG_PATH_OVERRIDE;
-        log_info("cfg", "using custom config file: {}", this->configLocation.string());
+        log_info("cfg", "using custom config file: {}", this->configLocation);
    } else {
        this->configLocation = std::filesystem::path(_wgetenv(L"APPDATA")) / L"spicetools.xml";
        // avoids logging the expanded appdata path as it contains user name
@@ -48,7 +57,7 @@ Config::Config() {
                this->firstFillConfigFile();
                break;
            case tinyxml2::XMLError::XML_ERROR_FILE_COULD_NOT_BE_OPENED:
-                log_fatal("cfg", "could not open config file: {}", this->configLocation.string());
+                log_fatal("cfg", "could not open config file: {}", this->configLocation);
                break;
            case tinyxml2::XMLError::XML_ERROR_FILE_NOT_FOUND:
                this->createConfigFile();
@@ -63,7 +72,7 @@ Config::Config() {
            case tinyxml2::XMLError::XML_ERROR_PARSING_UNKNOWN:
            case tinyxml2::XMLError::XML_ERROR_MISMATCHED_ELEMENT:
            case tinyxml2::XMLError::XML_ERROR_PARSING:
-                log_warning("cfg", "Couldn't read config file: {}", this->configLocation.string());
+                log_warning("cfg", "Couldn't read config file: {}", this->configLocation);
                this->createConfigFile();
                this->firstFillConfigFile();
                break;
@@ -89,7 +98,7 @@ bool Config::getStatus() {
    return this->status;
 }

-bool Config::addGame(Game &game) {
+bool Config::addGame(Game &game, bool save) {
    tinyxml2::XMLNode *rootNode = this->configFile.LastChild();
    tinyxml2::XMLElement *gameNodes = rootNode->FirstChildElement("game");

@@ -153,6 +162,7 @@ bool Config::addGame(Game &game) {
                    auto analogType = (int) BAT_NONE;
                    double debounce_up = 0.0;
                    double debounce_down = 0.0;
+                    int bat_threshold = 0;
                    int velocity_threshold = 0;
                    bool invert = false;
                    tinyxml2::XMLError attrError = gameButtonNode->QueryIntAttribute("vkey", &vKey);
@@ -160,6 +170,7 @@ bool Config::addGame(Game &game) {
                    gameButtonNode->QueryIntAttribute("analogtype", &analogType);
                    gameButtonNode->QueryDoubleAttribute("debounce_up", &debounce_up);
                    gameButtonNode->QueryDoubleAttribute("debounce_down", &debounce_down);
+                    gameButtonNode->QueryIntAttribute("bat_threshold", &bat_threshold);
                    gameButtonNode->QueryIntAttribute("velocity_threshold", &velocity_threshold);
                    gameButtonNode->QueryBoolAttribute("invert", &invert);
                    if (attrError != tinyxml2::XMLError::XML_SUCCESS) {
@@ -171,6 +182,7 @@ bool Config::addGame(Game &game) {
                        gameButtonNode->SetAttribute("devid", button->getDeviceIdentifier().c_str());
                        gameButtonNode->SetAttribute("debounce_up", debounce_up);
                        gameButtonNode->SetAttribute("debounce_down", debounce_down);
+                        gameButtonNode->SetAttribute("bat_threshold", bat_threshold);
                        gameButtonNode->SetAttribute("velocity_threshold", velocity_threshold);
                        gameButtonNode->SetAttribute("invert", invert);
                        gameButtonsNode->InsertEndChild(gameButtonNode);
@@ -179,6 +191,7 @@ bool Config::addGame(Game &game) {
                        button->setAnalogType((ButtonAnalogType) analogType);
                        button->setDebounceUp(debounce_up);
                        button->setDebounceDown(debounce_down);
+                        button->setBatThreshold(bat_threshold);
                        button->setVelocityThreshold(velocity_threshold);
                        button->setInvert(invert);
                        if (devid) {
@@ -198,6 +211,7 @@ bool Config::addGame(Game &game) {
                gameButtonNode->SetAttribute("analogtype", (int) it.getAnalogType());
                gameButtonNode->SetAttribute("debounce_up", it.getDebounceUp());
                gameButtonNode->SetAttribute("debounce_down", it.getDebounceDown());
+                gameButtonNode->SetAttribute("bat_threshold", it.getBatThreshold());
                gameButtonNode->SetAttribute("velocity_threshold", it.getVelocityThreshold());
                gameButtonNode->SetAttribute("invert", it.getInvert());
                gameButtonNode->SetAttribute("devid", it.getDeviceIdentifier().c_str());
@@ -239,7 +253,7 @@ bool Config::addGame(Game &game) {
                bool smoothing = false;
                int multiplier = 1;
                bool relative_mode = false;
-                int delay_buffer_depth = 0;
+                uint32_t delay = 0;
                tinyxml2::XMLError err1 = gameAnalogNode->QueryIntAttribute("index", &index);
                gameAnalogNode->QueryFloatAttribute("sensivity", &sensitivity);
                gameAnalogNode->QueryFloatAttribute("deadzone", &deadzone);
@@ -248,7 +262,7 @@ bool Config::addGame(Game &game) {
                gameAnalogNode->QueryBoolAttribute("smoothing", &smoothing);
                gameAnalogNode->QueryIntAttribute("multiplier", &multiplier);
                gameAnalogNode->QueryBoolAttribute("relative", &relative_mode);
-                gameAnalogNode->QueryIntAttribute("delay", &delay_buffer_depth);
+                gameAnalogNode->QueryUnsignedAttribute("delay_ms", &delay);
                const char *devid = gameAnalogNode->Attribute("devid");

                if (err1 != tinyxml2::XMLError::XML_SUCCESS || !devid) {
@@ -264,7 +278,7 @@ bool Config::addGame(Game &game) {
                    gameAnalogNode->SetAttribute("smoothing", it.getSmoothing());
                    gameAnalogNode->SetAttribute("multiplier", it.getMultiplier());
                    gameAnalogNode->SetAttribute("relative", it.isRelativeMode());
-                    gameAnalogNode->SetAttribute("delay", it.getDelayBufferDepth());
+                    gameAnalogNode->SetAttribute("delay_ms", it.getDelayMs());
                    gameAnalogsNode->InsertEndChild(gameAnalogNode);
                } else {
                    it.setIndex(static_cast<unsigned short int>(index));
@@ -276,7 +290,7 @@ bool Config::addGame(Game &game) {
                    it.setSmoothing(smoothing);
                    it.setMultiplier(multiplier);
                    it.setRelativeMode(relative_mode);
-                    it.setDelayBufferDepth(delay_buffer_depth);
+                    it.setDelayMs(delay);
                }
            } else {
                gameAnalogNode = this->configFile.NewElement("analog");
@@ -289,7 +303,7 @@ bool Config::addGame(Game &game) {
                gameAnalogNode->SetAttribute("smoothing", it.getSmoothing());
                gameAnalogNode->SetAttribute("multiplier", it.getMultiplier());
                gameAnalogNode->SetAttribute("relative", it.isRelativeMode());
-                gameAnalogNode->SetAttribute("delay", it.getDelayBufferDepth());
+                gameAnalogNode->SetAttribute("delay_ms", it.getDelayMs());
                gameAnalogNode->SetAttribute("devid", it.getDeviceIdentifier().c_str());
                gameAnalogsNode->InsertEndChild(gameAnalogNode);
            }
@@ -423,6 +437,7 @@ bool Config::addGame(Game &game) {
            gameButtonNode->SetAttribute("analogtype", it.getAnalogType());
            gameButtonNode->SetAttribute("debounce_up", it.getDebounceUp());
            gameButtonNode->SetAttribute("debounce_down", it.getDebounceDown());
+            gameButtonNode->SetAttribute("bat_threshold", it.getBatThreshold());
            gameButtonNode->SetAttribute("velocity_threshold", it.getVelocityThreshold());
            gameButtonNode->SetAttribute("invert", it.getInvert());
            gameButtonNode->SetAttribute("devid", it.getDeviceIdentifier().c_str());
@@ -443,7 +458,7 @@ bool Config::addGame(Game &game) {
            gameAnalogNode->SetAttribute("smoothing", it.getSmoothing());
            gameAnalogNode->SetAttribute("multiplier", it.getMultiplier());
            gameAnalogNode->SetAttribute("relative", it.isRelativeMode());
-            gameAnalogNode->SetAttribute("delay", it.getDelayBufferDepth());
+            gameAnalogNode->SetAttribute("delay_ms", it.getDelayMs());
            gameAnalogsNode->InsertEndChild(gameAnalogNode);
        }

@@ -471,13 +486,20 @@ bool Config::addGame(Game &game) {
        rootNode->InsertEndChild(gameNode);
    }

-    // save config
-    this->saveConfigFile();
+    // save config (skipped when caller batches multiple addGame calls
+    // and flushes once at the end via Config::save())
+    if (save) {
+        this->saveConfigFile();
+    }

    // return success
    return true;
 }

+void Config::save() {
+    this->saveConfigFile();
+}
+
 bool Config::updateBinding(const Game &game, const Button &button, int alternative) {

    // get root node
@@ -510,8 +532,10 @@ bool Config::updateBinding(const Game &game, const Button &button, int alternati
        return false;
    }

+    tinyxml2::XMLElement *gameButtonNode = nullptr;
+
    // iterate button nodes
-    tinyxml2::XMLElement *gameButtonNode = gameButtonsNode->FirstChildElement("button");
+    gameButtonNode = gameButtonsNode->FirstChildElement("button");
    int button_count = 0;
    while (gameButtonNode != nullptr) {
        const char *buttonNodeName = gameButtonNode->Attribute("name");
@@ -524,6 +548,7 @@ bool Config::updateBinding(const Game &game, const Button &button, int alternati
                gameButtonNode->SetAttribute("analogtype", (int) button.getAnalogType());
                gameButtonNode->SetAttribute("debounce_up", button.getDebounceUp());
                gameButtonNode->SetAttribute("debounce_down", button.getDebounceDown());
+                gameButtonNode->SetAttribute("bat_threshold", button.getBatThreshold());
                gameButtonNode->SetAttribute("velocity_threshold", button.getVelocityThreshold());
                gameButtonNode->SetAttribute("invert", button.getInvert());
                gameButtonNode->SetAttribute("devid", button.getDeviceIdentifier().c_str());
@@ -540,6 +565,7 @@ bool Config::updateBinding(const Game &game, const Button &button, int alternati
            gameButtonNode->SetAttribute("analogtype", 0);
            gameButtonNode->SetAttribute("debounce_up", 0.0);
            gameButtonNode->SetAttribute("debounce_down", 0.0);
+            gameButtonNode->SetAttribute("bat_threshold", 0);
            gameButtonNode->SetAttribute("velocity_threshold", 0);
            gameButtonNode->SetAttribute("invert", false);
            gameButtonNode->SetAttribute("devid", "");
@@ -574,6 +600,39 @@ bool Config::updateBinding(const Game &game, const Button &button, int alternati
        }
    }

+    // trim the trailing invalid (unbound) alternatives
+    tinyxml2::XMLElement *to_delete = nullptr;
+    gameButtonNode = gameButtonsNode->LastChildElement("button");
+    while (gameButtonNode != nullptr) {
+        const char *name = gameButtonNode->Attribute("name");
+        const char *devid = gameButtonNode->Attribute("devid");
+        int vkey = INVALID_VKEY;
+        gameButtonNode->QueryIntAttribute("vkey", &vkey);
+
+        // wrong button, ignore and keep iterating backwards
+        if (name == nullptr || std::string(name) != button.getName()) {
+            gameButtonNode = gameButtonNode->PreviousSiblingElement("button");
+            continue;
+        }
+
+        // found a node for this button, which means to_delete is not the first one
+        // delete the node for to_delete
+        if (to_delete != nullptr) {
+            log_debug("cfg", "deleting excessive button binding for {}", name);
+            gameButtonsNode->DeleteChild(to_delete);
+            to_delete = nullptr;
+        }
+
+        if ((devid == nullptr || strlen(devid) == 0) && vkey == INVALID_VKEY) {
+            // unbound button with no device ID, make a note of it so it can be deleted later
+            to_delete = gameButtonNode;
+            gameButtonNode = gameButtonNode->PreviousSiblingElement("button");
+        } else {
+            // valid binding found; stop iterating
+            break;
+        }
+    }
+
    // check if button was not found
    if (button_count == 0) {
        return false;
@@ -640,7 +699,7 @@ bool Config::updateBinding(const Game &game, const Analog &analog) {
        gameAnalogNode->SetAttribute("smoothing", analog.getSmoothing());
        gameAnalogNode->SetAttribute("multiplier", analog.getMultiplier());
        gameAnalogNode->SetAttribute("relative", analog.isRelativeMode());
-        gameAnalogNode->SetAttribute("delay", analog.getDelayBufferDepth());
+        gameAnalogNode->SetAttribute("delay_ms", analog.getDelayMs());
        gameAnalogNode->SetAttribute("devid", analog.getDeviceIdentifier().c_str());
    } else {
        gameAnalogNode = this->configFile.NewElement("analog");
@@ -652,7 +711,7 @@ bool Config::updateBinding(const Game &game, const Analog &analog) {
        gameAnalogNode->SetAttribute("smoothing", analog.getSmoothing());
        gameAnalogNode->SetAttribute("multiplier", analog.getMultiplier());
        gameAnalogNode->SetAttribute("relative", analog.isRelativeMode());
-        gameAnalogNode->SetAttribute("delay", analog.getDelayBufferDepth());
+        gameAnalogNode->SetAttribute("delay_ms", analog.getDelayMs());
        gameAnalogNode->SetAttribute("devid", analog.getDeviceIdentifier().c_str());
        gameAnalogsNode->InsertEndChild(gameAnalogNode);
    }
@@ -760,6 +819,37 @@ bool Config::updateBinding(const Game &game, const Light &light, int alternative
        }
    }

+    // trim the trailing invalid (unbound) alternatives
+    tinyxml2::XMLElement *to_delete = nullptr;
+    gameLightNode = gameLightsNode->LastChildElement("light");
+    while (gameLightNode != nullptr) {
+        const char *name = gameLightNode->Attribute("name");
+        const char *devid = gameLightNode->Attribute("devid");
+
+        // wrong light, ignore and keep iterating backwards
+        if (name == nullptr || std::string(name) != light.getName()) {
+            gameLightNode = gameLightNode->PreviousSiblingElement("light");
+            continue;
+        }
+
+        // found a node for this button, which means to_delete is not the first one
+        // delete the node for to_delete
+        if (to_delete != nullptr) {
+            log_debug("cfg", "deleting excessive light binding for {}", name);
+            gameLightsNode->DeleteChild(to_delete);
+            to_delete = nullptr;
+        }
+
+        if (devid == nullptr || strlen(devid) == 0) {
+            // unbound light, make a note of it so it can be deleted later
+            to_delete = gameLightNode;
+            gameLightNode = gameLightNode->PreviousSiblingElement("light");
+        } else {
+            // valid binding found; stop iterating
+            break;
+        }
+    }
+
    // check if light was not found
    if (light_count == 0) {
        return false;
@@ -871,12 +961,14 @@ std::vector<Button> Config::getButtons(const std::string &gameName) {
                auto analogType = (int) BAT_NONE;
                double debounce_up = 0.0;
                double debounce_down = 0.0;
+                int bat_threshold = 0;
                int velocity_threshold = 0;
                bool invert = false;
                gameButtonNode->QueryIntAttribute("vkey", &vKey);
                gameButtonNode->QueryIntAttribute("analogtype", &analogType);
                gameButtonNode->QueryDoubleAttribute("debounce_up", &debounce_up);
                gameButtonNode->QueryDoubleAttribute("debounce_down", &debounce_down);
+                gameButtonNode->QueryIntAttribute("bat_threshold", &bat_threshold);
                gameButtonNode->QueryIntAttribute("velocity_threshold", &velocity_threshold);
                gameButtonNode->QueryBoolAttribute("invert", &invert);
                const char *devid = gameButtonNode->Attribute("devid");
@@ -891,6 +983,7 @@ std::vector<Button> Config::getButtons(const std::string &gameName) {
                        alt.setAnalogType((ButtonAnalogType) analogType);
                        alt.setDebounceUp(debounce_up);
                        alt.setDebounceDown(debounce_down);
+                        alt.setBatThreshold(bat_threshold);
                        alt.setVelocityThreshold(velocity_threshold);
                        alt.setInvert(invert);
                        if (devid) {
@@ -909,6 +1002,7 @@ std::vector<Button> Config::getButtons(const std::string &gameName) {
                    button.setAnalogType((ButtonAnalogType) analogType);
                    button.setDebounceUp(debounce_up);
                    button.setDebounceDown(debounce_down);
+                    button.setBatThreshold(bat_threshold);
                    button.setVelocityThreshold(velocity_threshold);
                    button.setInvert(invert);
                    if (devid) {
@@ -1055,7 +1149,7 @@ std::vector<Analog> Config::getAnalogs(const std::string &gameName) {
                bool smoothing = false;
                int multiplier = 1;
                bool relative_mode = false;
-                int delay_buffer_depth = 0;
+                uint32_t delay = 0;
                gameAnalogNode->QueryIntAttribute("index", &index);
                gameAnalogNode->QueryFloatAttribute("sensivity", &sensitivity);
                gameAnalogNode->QueryFloatAttribute("deadzone", &deadzone);
@@ -1064,7 +1158,7 @@ std::vector<Analog> Config::getAnalogs(const std::string &gameName) {
                gameAnalogNode->QueryBoolAttribute("smoothing", &smoothing);
                gameAnalogNode->QueryIntAttribute("multiplier", &multiplier);
                gameAnalogNode->QueryBoolAttribute("relative", &relative_mode);
-                gameAnalogNode->QueryIntAttribute("delay", &delay_buffer_depth);
+                gameAnalogNode->QueryUnsignedAttribute("delay_ms", &delay);
                const char *devid = gameAnalogNode->Attribute("devid");

                // create analog and add to list
@@ -1077,7 +1171,7 @@ std::vector<Analog> Config::getAnalogs(const std::string &gameName) {
                analog.setSmoothing(smoothing);
                analog.setMultiplier(multiplier);
                analog.setRelativeMode(relative_mode);
-                analog.setDelayBufferDepth(delay_buffer_depth);
+                analog.setDelayMs(delay);
                if (devid) {
                    analog.setDeviceIdentifier(devid);
                }
@@ -1240,7 +1334,7 @@ void Config::saveConfigFile() {
    // create a .tmp file and write to it...
    const auto xml_result = this->configFile.SaveFile(this->configLocationTemp.c_str(), false);
    if (xml_result != tinyxml2::XMLError::XML_SUCCESS) {
-        log_info("cfg", "failed to write file: {}", this->configLocationTemp.string());
+        log_info("cfg", "failed to write file: {}", this->configLocationTemp);
        return;
    }
    // copy the .tmp file to the main file...
@@ -22,7 +22,12 @@ public:
    bool getStatus();
    bool createConfigFile();

-    bool addGame(Game &game);
+    bool addGame(Game &game, bool save = true);
+
+    // flush pending in-memory changes to disk; intended to be paired with
+    // addGame(game, false) in bulk-init paths so we write the XML once instead
+    // of once per game
+    void save();

    bool updateBinding(const Game &game, const Button &button, int alternative);
    bool updateBinding(const Game &game, const Analog &analog);
@@ -1,11 +1,15 @@
-#include "configurator.h"
+#include "configurator.h"
+
+#include <d3d9.h>

 #include "overlay/overlay.h"
+#include "util/logging.h"

 namespace cfg {

    // globals
    bool CONFIGURATOR_STANDALONE = false;
+    bool CONFIGURATOR_FORCE_SOFTWARE_RENDER = false;
    ConfigType CONFIGURATOR_TYPE = ConfigType::Config;

    Configurator::Configurator() {
@@ -16,11 +20,78 @@ namespace cfg {
        CONFIGURATOR_STANDALONE = false;
    }

+    // Attempt to bring up a D3D9 device backing the configurator's window so the
+    // overlay can use the hardware-accelerated imgui_impl_dx9 path instead of
+    // the CPU rasterizer. Returns true if both Direct3DCreate9 and CreateDevice
+    // succeed; the caller falls back to overlay::create_software() otherwise so
+    // that environments without D3D9 (Wine without dxvk, headless test boxes,
+    // GPUs whose drivers reject HAL) still get a working configurator.
+    static bool try_init_d3d9(ConfiguratorWindow &wnd) {
+        if (cfg::CONFIGURATOR_FORCE_SOFTWARE_RENDER) {
+            return false;
+        }
+
+        if (wnd.hWnd == nullptr) {
+            return false;
+        }
+
+        IDirect3D9 *d3d = Direct3DCreate9(D3D_SDK_VERSION);
+        if (d3d == nullptr) {
+            log_warning("configurator", "Direct3DCreate9 returned NULL, falling back to software renderer");
+            return false;
+        }
+
+        D3DPRESENT_PARAMETERS pp {};
+        pp.Windowed = TRUE;
+        pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
+        // D3DFMT_UNKNOWN -> driver picks the current desktop format
+        pp.BackBufferFormat = D3DFMT_UNKNOWN;
+        pp.BackBufferWidth = static_cast<UINT>(wnd.client_width);
+        pp.BackBufferHeight = static_cast<UINT>(wnd.client_height);
+        pp.hDeviceWindow = wnd.hWnd;
+        pp.EnableAutoDepthStencil = FALSE;
+        pp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
+
+        IDirect3DDevice9 *device = nullptr;
+        // SOFTWARE_VERTEXPROCESSING is the most compatible behavior flag; the UI
+        // is tiny so we don't need hardware T&L. FPU_PRESERVE keeps our floating
+        // point environment intact in case other spice code relies on it.
+        const DWORD behavior_flags = D3DCREATE_SOFTWARE_VERTEXPROCESSING | D3DCREATE_FPU_PRESERVE;
+        HRESULT hr = d3d->CreateDevice(
+                D3DADAPTER_DEFAULT,
+                D3DDEVTYPE_HAL,
+                wnd.hWnd,
+                behavior_flags,
+                &pp,
+                &device);
+        if (FAILED(hr) || device == nullptr) {
+            log_warning("configurator",
+                "D3D9 CreateDevice failed (hr={:#x}), falling back to software renderer",
+                static_cast<unsigned int>(hr));
+            d3d->Release();
+            return false;
+        }
+
+        wnd.d3d = d3d;
+        wnd.device = device;
+        wnd.pp = pp;
+        wnd.use_d3d9 = true;
+        return true;
+    }
+
    void Configurator::run() {

-        // create instance
+        // bring up the overlay against either a real D3D9 device or the software
+        // rasterizer. The choice is one-shot - the in-game overlay always uses
+        // the same renderer the configurator picked here.
        overlay::ENABLED = true;
-        overlay::create_software(this->wnd.hWnd);
+        if (try_init_d3d9(this->wnd)) {
+            log_info("configurator", "using D3D9 hardware-accelerated renderer");
+            overlay::create_d3d9(this->wnd.hWnd, this->wnd.d3d, this->wnd.device);
+        } else {
+            log_info("configurator", "using software renderer");
+            overlay::create_software(this->wnd.hWnd);
+        }
        overlay::OVERLAY->set_active(true);
        overlay::OVERLAY->hotkeys_enable = false;
        ImGui::GetIO().MouseDrawCursor = false;
@@ -11,6 +11,7 @@ namespace cfg {
    // globals
    extern bool CONFIGURATOR_STANDALONE;
    extern ConfigType CONFIGURATOR_TYPE;
+    extern bool CONFIGURATOR_FORCE_SOFTWARE_RENDER;

    class Configurator {
    private:
@@ -1,11 +1,17 @@
-#include "configurator_wnd.h"
+#include "configurator_wnd.h"
+
+#include <algorithm>
+#include <cstring>

 #include <windows.h>
+#include <windowsx.h>

 #include "build/defs.h"
+#include "external/imgui/imgui.h"
 #include "launcher/shutdown.h"
 #include "overlay/overlay.h"
 #include "util/logging.h"
+#include "util/precise_timer.h"
 #include "cfg/configurator.h"

 #include "icon.h"
@@ -16,6 +22,156 @@ static int WINDOW_SIZE_X = 800;
 static int WINDOW_SIZE_Y = 600;
 static HICON WINDOW_ICON = LoadIcon(GetModuleHandle(nullptr), MAKEINTRESOURCE(MAINICON));

+static const UINT_PTR RENDER_TIMER_ID = 1;
+
+// Map a virtual key code to the matching ImGuiKey. Mirrors the table used by
+// the in-game ImGui spice backend so navigation keys behave identically when
+// the configurator runs standalone and drives ImGui from Win32 messages.
+static ImGuiKey vk_to_imgui_key(WPARAM vkey) {
+    switch (vkey) {
+        case VK_TAB: return ImGuiKey_Tab;
+        case VK_LEFT: return ImGuiKey_LeftArrow;
+        case VK_RIGHT: return ImGuiKey_RightArrow;
+        case VK_UP: return ImGuiKey_UpArrow;
+        case VK_DOWN: return ImGuiKey_DownArrow;
+        case VK_PRIOR: return ImGuiKey_PageUp;
+        case VK_NEXT: return ImGuiKey_PageDown;
+        case VK_HOME: return ImGuiKey_Home;
+        case VK_END: return ImGuiKey_End;
+        case VK_INSERT: return ImGuiKey_Insert;
+        case VK_DELETE: return ImGuiKey_Delete;
+        case VK_BACK: return ImGuiKey_Backspace;
+        case VK_SPACE: return ImGuiKey_Space;
+        case VK_RETURN: return ImGuiKey_Enter;
+        case VK_ESCAPE: return ImGuiKey_Escape;
+        case VK_LSHIFT: return ImGuiKey_LeftShift;
+        case VK_RSHIFT: return ImGuiKey_RightShift;
+        case VK_SHIFT: return ImGuiKey_LeftShift;
+        case VK_LCONTROL: return ImGuiKey_LeftCtrl;
+        case VK_RCONTROL: return ImGuiKey_RightCtrl;
+        case VK_CONTROL: return ImGuiKey_LeftCtrl;
+        case 'A': return ImGuiKey_A;
+        case 'C': return ImGuiKey_C;
+        case 'V': return ImGuiKey_V;
+        case 'X': return ImGuiKey_X;
+        case 'Y': return ImGuiKey_Y;
+        case 'Z': return ImGuiKey_Z;
+        default: return ImGuiKey_None;
+    }
+}
+
+static ImGuiKey vk_to_imgui_mod_key(WPARAM vkey) {
+    switch (vkey) {
+        case VK_SHIFT:
+        case VK_LSHIFT:
+        case VK_RSHIFT:
+            return ImGuiMod_Shift;
+        case VK_CONTROL:
+        case VK_LCONTROL:
+        case VK_RCONTROL:
+            return ImGuiMod_Ctrl;
+        case VK_MENU:
+        case VK_LMENU:
+        case VK_RMENU:
+            return ImGuiMod_Alt;
+        default:
+            return ImGuiMod_None;
+    }
+}
+
+static cfg::ConfiguratorWindow *get_state(HWND hWnd) {
+    return reinterpret_cast<cfg::ConfiguratorWindow *>(
+        GetWindowLongPtrW(hWnd, GWLP_USERDATA));
+}
+
+// Returns the refresh rate (Hz) of the monitor the window currently lives on,
+// clamped to a sane range. Falls back to 60 if detection fails or the value
+// looks invalid (DEVMODE may report 0 or 1 to mean "use hardware default").
+static UINT detect_monitor_refresh_hz(HWND hWnd) {
+    UINT hz = 0;
+    HMONITOR mon = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST);
+    if (mon) {
+        MONITORINFOEXW mi {};
+        mi.cbSize = sizeof(mi);
+        if (GetMonitorInfoW(mon, reinterpret_cast<LPMONITORINFO>(&mi))) {
+            DEVMODEW dm {};
+            dm.dmSize = sizeof(dm);
+            if (EnumDisplaySettingsW(mi.szDevice, ENUM_CURRENT_SETTINGS, &dm)) {
+                hz = dm.dmDisplayFrequency;
+            }
+        }
+    }
+    if (hz <= 1) {
+        HDC hdc = GetDC(hWnd);
+        if (hdc) {
+            int v = GetDeviceCaps(hdc, VREFRESH);
+            if (v > 1) {
+                hz = static_cast<UINT>(v);
+            }
+            ReleaseDC(hWnd, hdc);
+        }
+    }
+    if (hz < 30 || hz > 240) {
+        hz = 60;
+    }
+    return hz;
+}
+
+// Software-path WM_PAINT: blit the overlay's pixel buffer to the window using
+// SetDIBitsToDevice. Avoids creating/destroying a GDI HBITMAP every frame.
+static void paint_software(HWND hWnd) {
+    if (!overlay::OVERLAY) {
+        PAINTSTRUCT ps {};
+        BeginPaint(hWnd, &ps);
+        EndPaint(hWnd, &ps);
+        return;
+    }
+
+    int width = 0;
+    int height = 0;
+    uint32_t *pixel_data = overlay::OVERLAY->sw_get_pixel_data(&width, &height);
+
+    PAINTSTRUCT paint {};
+    HDC hdc = BeginPaint(hWnd, &paint);
+
+    if (pixel_data && width > 0 && height > 0) {
+        BITMAPINFO bmi {};
+        bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+        bmi.bmiHeader.biWidth = width;
+        // negative height -> top-down DIB, matching how ImGui packs pixels
+        bmi.bmiHeader.biHeight = -height;
+        bmi.bmiHeader.biPlanes = 1;
+        bmi.bmiHeader.biBitCount = 32;
+        bmi.bmiHeader.biCompression = BI_RGB;
+
+        SetDIBitsToDevice(
+            hdc,
+            0, 0,
+            width, height,
+            0, 0,
+            0, height,
+            pixel_data,
+            &bmi,
+            DIB_RGB_COLORS);
+    }
+
+    EndPaint(hWnd, &paint);
+}
+
+void cfg::ConfiguratorWindow::start_timer() {
+    if (!this->timer_running && this->hWnd) {
+        SetTimer(this->hWnd, RENDER_TIMER_ID, this->timer_interval_ms, nullptr);
+        this->timer_running = true;
+    }
+}
+
+void cfg::ConfiguratorWindow::stop_timer() {
+    if (this->timer_running && this->hWnd) {
+        KillTimer(this->hWnd, RENDER_TIMER_ID);
+        this->timer_running = false;
+    }
+}
+
 cfg::ConfiguratorWindow::ConfiguratorWindow() {

    // register the window class
@@ -27,12 +183,22 @@ cfg::ConfiguratorWindow::ConfiguratorWindow() {
    wc.hIcon = WINDOW_ICON;
    RegisterClass(&wc);

+    // raise SetTimer resolution so high refresh rates (120/144Hz) are actually
+    // achievable. Without this, USER timers quantize to ~15.6ms and cap us
+    // near ~64 FPS. Uses the shared helper so it respects -notimerhacks
+    // (Use Legacy Timers) and the Win11 timer-throttling opt-out. The helper
+    // intentionally never calls timeEndPeriod; the kernel releases the request
+    // when spicecfg exits.
+    timeutils::set_timer_resolution();
+
    // determine window title
    if (cfg::CONFIGURATOR_TYPE == cfg::ConfigType::Config) {
        WINDOW_TITLE = "spice2x config (" + to_string(VERSION_STRING_CFG) + ")";
        WINDOW_SIZE_X = 800;
        WINDOW_SIZE_Y = 600;
    }
+    this->client_width = WINDOW_SIZE_X;
+    this->client_height = WINDOW_SIZE_Y;

    // open window
    this->hWnd = CreateWindowEx(
@@ -53,11 +219,23 @@ cfg::ConfiguratorWindow::ConfiguratorWindow() {

 cfg::ConfiguratorWindow::~ConfiguratorWindow() {

+    this->stop_timer();
+
    // close window
    DestroyWindow(this->hWnd);

    // unregister class
    UnregisterClass(CLASS_NAME, GetModuleHandle(NULL));
+
+    // release D3D9 resources if any
+    if (this->device) {
+        this->device->Release();
+        this->device = nullptr;
+    }
+    if (this->d3d) {
+        this->d3d->Release();
+        this->d3d = nullptr;
+    }
 }

 void cfg::ConfiguratorWindow::run() {
@@ -67,8 +245,23 @@ void cfg::ConfiguratorWindow::run() {
    ShowWindow(this->hWnd, SW_SHOWNORMAL);
    UpdateWindow(this->hWnd);

-    // draw overlay in 60 FPS
-    SetTimer(this->hWnd, 1, 1000 / 60, nullptr);
+    // SW_SHOWNORMAL usually activates a top-level window, but not always (e.g.,
+    // when the launching process doesn't have foreground rights to transfer).
+    // Force foreground+focus explicitly so WM_MOUSEWHEEL is routed to us from
+    // the very first frame; the Win32 default routes wheel events to the
+    // keyboard-focused window.
+    SetForegroundWindow(this->hWnd);
+    SetFocus(this->hWnd);
+
+    // match the render timer to the monitor refresh rate so scrolling stays smooth
+    // on 60/120/144 Hz panels. Idle CPU is bounded by overlay::sw_pixels_dirty
+    // (software path) and overlay::d3d9_frame_dirty (D3D9 path); the timer is also
+    // paused entirely when the window is minimized (see WM_SIZE handler).
+    const UINT hz = detect_monitor_refresh_hz(this->hWnd);
+    this->timer_interval_ms = std::max<UINT>(1, 1000 / hz);
+    log_info("configurator", "render timer {} ms ({} Hz)",
+        this->timer_interval_ms, hz);
+    this->start_timer();

    // window loop
    BOOL ret;
@@ -102,6 +295,72 @@ LRESULT CALLBACK cfg::ConfiguratorWindow::window_proc(HWND hWnd, UINT uMsg, WPAR

            break;
        }
+        case WM_SIZE: {
+
+            // pause/resume the render timer based on visibility
+            auto *state = get_state(hWnd);
+            if (state) {
+                if (wParam == SIZE_MINIMIZED) {
+                    state->window_minimized = true;
+                    state->stop_timer();
+                } else {
+                    if (state->window_minimized) {
+                        state->window_minimized = false;
+                        // force a full repaint on the next frame
+                        state->has_valid_draw_hash = false;
+                        state->start_timer();
+                    }
+                    const int new_w = LOWORD(lParam);
+                    const int new_h = HIWORD(lParam);
+                    if (new_w > 0 && new_h > 0
+                            && (new_w != state->client_width || new_h != state->client_height)) {
+                        state->client_width = new_w;
+                        state->client_height = new_h;
+
+                        // reset the D3D9 device with the new back-buffer size so the
+                        // hardware-accelerated path matches the window dimensions.
+                        if (state->use_d3d9 && state->device) {
+                            if (overlay::OVERLAY) {
+                                overlay::OVERLAY->reset_invalidate();
+                            }
+                            state->pp.BackBufferWidth = static_cast<UINT>(new_w);
+                            state->pp.BackBufferHeight = static_cast<UINT>(new_h);
+                            HRESULT hr = state->device->Reset(&state->pp);
+                            if (FAILED(hr)) {
+                                log_warning("configurator", "D3D9 device Reset failed, hr={:#x}",
+                                    static_cast<unsigned int>(hr));
+                            }
+                            if (overlay::OVERLAY) {
+                                overlay::OVERLAY->reset_recreate();
+                            }
+                        }
+
+                        // force a full repaint after resize
+                        state->has_valid_draw_hash = false;
+                    }
+                }
+            }
+            break;
+        }
+        case WM_DISPLAYCHANGE: {
+
+            // monitor refresh rate may have changed (or the window moved to a
+            // different monitor); re-detect and re-arm the render timer.
+            auto *state = get_state(hWnd);
+            if (state && state->timer_running) {
+                const UINT hz = detect_monitor_refresh_hz(hWnd);
+                const UINT new_interval = std::max<UINT>(1, 1000 / hz);
+                if (new_interval != state->timer_interval_ms) {
+                    state->stop_timer();
+                    state->timer_interval_ms = new_interval;
+                    state->start_timer();
+                    log_info("configurator",
+                        "WM_DISPLAYCHANGE: render timer {} ms ({} Hz)",
+                        new_interval, hz);
+                }
+            }
+            break;
+        }
        case WM_CLOSE:
        case WM_DESTROY: {

@@ -110,62 +369,192 @@ LRESULT CALLBACK cfg::ConfiguratorWindow::window_proc(HWND hWnd, UINT uMsg, WPAR
            break;
        }
        case WM_TIMER: {
+            if (wParam != RENDER_TIMER_ID) {
+                break;
+            }

-            // update overlay
+            auto *state = get_state(hWnd);
+
+            // skip rendering when the window is minimized or hidden - the timer is
+            // already paused on minimize, but defensively skip here as well.
+            if (state && (state->window_minimized || !IsWindowVisible(hWnd))) {
+                break;
+            }
+
+            const bool use_d3d9 = state && state->use_d3d9 && state->device;
+
+            // build the imgui frame (input is already buffered via WM_* messages)
            if (overlay::OVERLAY) {
                overlay::OVERLAY->update();
                overlay::OVERLAY->set_active(true);
                overlay::OVERLAY->new_frame();
-                overlay::OVERLAY->render();
            }

-            // repaint window
-            InvalidateRect(hWnd, nullptr, TRUE);
+            if (use_d3d9) {
+                const HRESULT cl = state->device->TestCooperativeLevel();
+                if (cl == D3DERR_DEVICELOST) {
+                    break;
+                }
+                if (cl == D3DERR_DEVICENOTRESET) {
+                    if (overlay::OVERLAY) {
+                        overlay::OVERLAY->reset_invalidate();
+                    }
+                    const HRESULT reset_hr = state->device->Reset(&state->pp);
+                    if (SUCCEEDED(reset_hr) && overlay::OVERLAY) {
+                        overlay::OVERLAY->reset_recreate();
+                    }
+                    break;
+                }
+                if (FAILED(cl)) {
+                    break;
+                }
+
+                if (overlay::OVERLAY) {
+                    overlay::OVERLAY->render();
+                }
+
+                // skip Clear/Present when ImGui draw data is unchanged; the last
+                // presented frame stays visible (same fast path as sw_pixels_dirty).
+                const bool dirty = overlay::OVERLAY && overlay::OVERLAY->d3d9_frame_dirty;
+                const bool force_present = state && !state->has_valid_draw_hash;
+                if (dirty || force_present) {
+                    if (state) {
+                        state->has_valid_draw_hash = true;
+                    }
+                    state->device->Clear(0, nullptr, D3DCLEAR_TARGET,
+                        D3DCOLOR_RGBA(20, 18, 18, 255), 1.0f, 0);
+                    if (SUCCEEDED(state->device->BeginScene())) {
+                        if (overlay::OVERLAY) {
+                            overlay::OVERLAY->d3d9_render_draw(force_present);
+                        }
+                        state->device->EndScene();
+                    }
+                    const HRESULT hr = state->device->Present(nullptr, nullptr, nullptr, nullptr);
+                    if (hr == D3DERR_DEVICELOST) {
+                        break;
+                    }
+                }
+            } else {
+                if (overlay::OVERLAY) {
+                    overlay::OVERLAY->render();
+                }
+                // software path: the overlay's renderer already skipped the costly
+                // paint_imgui call when the draw data was unchanged. Only invalidate
+                // the window when those pixels actually changed, or on the first
+                // frame / after a resize when we lost the previously cached state.
+                const bool dirty = overlay::OVERLAY && overlay::OVERLAY->sw_pixels_dirty;
+                const bool force_repaint = state && !state->has_valid_draw_hash;
+                if (dirty || force_repaint) {
+                    if (state) {
+                        state->has_valid_draw_hash = true;
+                    }
+                    // pass FALSE for bErase - WM_ERASEBKGND already short-circuits, so
+                    // skipping the erase region avoids one extra Win32 round trip.
+                    InvalidateRect(hWnd, nullptr, FALSE);
+                }
+            }
+
            break;
        }
        case WM_ERASEBKGND: {
            return 1;
        }
        case WM_PAINT: {
-
-            // render overlay
-            if (overlay::OVERLAY) {
-
-                // get pixel data
-                int width, height;
-                uint32_t *pixel_data = overlay::OVERLAY->sw_get_pixel_data(&width, &height);
-                if (width > 0 && height > 0) {
-
-                    // create bitmap
-                    HBITMAP bitmap = CreateBitmap(width, height, 1, 8 * sizeof(uint32_t), pixel_data);
-
-                    // prepare paint
-                    PAINTSTRUCT paint{};
-                    HDC hdc = BeginPaint(hWnd, &paint);
-                    HDC hdcMem = CreateCompatibleDC(hdc);
-                    SetBkMode(hdc, TRANSPARENT);
-
-                    // draw bitmap
-                    SelectObject(hdcMem, bitmap);
-                    BitBlt(hdc, paint.rcPaint.left, paint.rcPaint.top,
-                            paint.rcPaint.right - paint.rcPaint.left,
-                            paint.rcPaint.bottom - paint.rcPaint.top,
-                            hdcMem, paint.rcPaint.left, paint.rcPaint.top, SRCCOPY);
-
-                    // delete bitmap
-                    DeleteObject(bitmap);
-
-                    // clean up
-                    DeleteDC(hdcMem);
-                    EndPaint(hWnd, &paint);
-                } else {
-                    return DefWindowProc(hWnd, uMsg, wParam, lParam);
-                }
+            paint_software(hWnd);
+            break;
+        }
+        case WM_ACTIVATE: {
+            const WORD activation = LOWORD(wParam);
+            if (activation == WA_INACTIVE) {
+                // dropping any held mouse buttons so we don't get stuck in a
+                // "button still pressed" state when we come back.
+                auto &io = ImGui::GetIO();
+                io.AddMouseButtonEvent(ImGuiMouseButton_Left, false);
+                io.AddMouseButtonEvent(ImGuiMouseButton_Right, false);
+                io.AddMouseButtonEvent(ImGuiMouseButton_Middle, false);
            } else {
-                return DefWindowProc(hWnd, uMsg, wParam, lParam);
+                // WA_ACTIVE or WA_CLICKACTIVE: make sure the keyboard focus is
+                // actually on this window so WM_MOUSEWHEEL gets routed to us
+                // again. Without this, scrolling silently stops working after
+                // the user alt-tabs back to spicecfg.
+                SetFocus(hWnd);
            }
            break;
        }
+        case WM_KILLFOCUS: {
+            // mirror the WA_INACTIVE mouse-button drop for the keyboard -
+            // without this, a key held during alt-tab stays "down" in ImGui
+            // state until the user presses and releases it again.
+            ImGui::GetIO().ClearInputKeys();
+            break;
+        }
+        // input messages routed straight into ImGui IO. This replaces the previous
+        // per-frame 256-VK rawinput scan in ImGui_ImplSpice_NewFrame for the
+        // standalone configurator (see CONFIGURATOR_STANDALONE branches there).
+        case WM_KEYDOWN:
+        case WM_SYSKEYDOWN:
+        case WM_KEYUP:
+        case WM_SYSKEYUP: {
+            if (wParam == VK_F4) {
+                return DefWindowProc(hWnd, uMsg, wParam, lParam);
+            }
+            const bool down = (uMsg == WM_KEYDOWN) || (uMsg == WM_SYSKEYDOWN);
+            auto &io = ImGui::GetIO();
+            const ImGuiKey key = vk_to_imgui_key(wParam);
+            if (key != ImGuiKey_None) {
+                io.AddKeyEvent(key, down);
+            }
+            const ImGuiKey mod = vk_to_imgui_mod_key(wParam);
+            if (mod != ImGuiMod_None) {
+                io.AddKeyEvent(mod, down);
+            }
+            break;
+        }
+        case WM_MOUSEMOVE: {
+            auto &io = ImGui::GetIO();
+            io.AddMousePosEvent(static_cast<float>(GET_X_LPARAM(lParam)),
+                                static_cast<float>(GET_Y_LPARAM(lParam)));
+            break;
+        }
+        case WM_LBUTTONDOWN:
+        case WM_LBUTTONUP:
+        case WM_RBUTTONDOWN:
+        case WM_RBUTTONUP:
+        case WM_MBUTTONDOWN:
+        case WM_MBUTTONUP: {
+            int button = 0;
+            bool down = false;
+            switch (uMsg) {
+                case WM_LBUTTONDOWN: button = ImGuiMouseButton_Left; down = true; break;
+                case WM_LBUTTONUP: button = ImGuiMouseButton_Left; down = false; break;
+                case WM_RBUTTONDOWN: button = ImGuiMouseButton_Right; down = true; break;
+                case WM_RBUTTONUP: button = ImGuiMouseButton_Right; down = false; break;
+                case WM_MBUTTONDOWN: button = ImGuiMouseButton_Middle; down = true; break;
+                case WM_MBUTTONUP: button = ImGuiMouseButton_Middle; down = false; break;
+            }
+            auto &io = ImGui::GetIO();
+            io.AddMouseButtonEvent(button, down);
+            if (down) {
+                SetCapture(hWnd);
+            } else {
+                ReleaseCapture();
+            }
+            break;
+        }
+        case WM_MOUSEWHEEL: {
+            const float delta = static_cast<float>(GET_WHEEL_DELTA_WPARAM(wParam))
+                / static_cast<float>(WHEEL_DELTA);
+            ImGui::GetIO().AddMouseWheelEvent(0.0f, delta);
+            break;
+        }
+#if !SPICE_XP
+        case WM_MOUSEHWHEEL: {
+            const float delta = static_cast<float>(GET_WHEEL_DELTA_WPARAM(wParam))
+                / static_cast<float>(WHEEL_DELTA);
+            ImGui::GetIO().AddMouseWheelEvent(delta, 0.0f);
+            break;
+        }
+#endif
        default:
            return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
@@ -1,6 +1,9 @@
-#pragma once
+#pragma once
+
+#include <cstdint>

 #include <windows.h>
+#include <d3d9.h>

 namespace cfg {

@@ -9,11 +12,38 @@ namespace cfg {

        HWND hWnd;

+        // optional D3D9 device backing the configurator window; nullptr when running
+        // the software-rendered path. Owned by ConfiguratorWindow when set.
+        IDirect3D9 *d3d = nullptr;
+        IDirect3DDevice9 *device = nullptr;
+        D3DPRESENT_PARAMETERS pp {};
+        bool use_d3d9 = false;
+
+        // throttling / pause state. timer_interval_ms is the default until run()
+        // refines it to the actual monitor refresh rate (see detect_monitor_refresh_hz).
+        UINT timer_interval_ms = 1000 / 60;
+        bool timer_running = false;
+        bool window_minimized = false;
+
+        // tracks whether we've issued at least one InvalidateRect since window
+        // creation/resize. The overlay's per-frame "pixels changed" flag suppresses
+        // idle blits; this flag forces the very first blit on startup or after
+        // a resize so the window doesn't show garbage until the user moves the mouse.
+        bool has_valid_draw_hash = false;
+
+        // dimensions of the configurator client area (kept in sync with WM_SIZE)
+        int client_width = 0;
+        int client_height = 0;
+
        ConfiguratorWindow();
        ~ConfiguratorWindow();

        void run();

+        // start/stop the render timer based on visibility state
+        void start_timer();
+        void stop_timer();
+
        static LRESULT CALLBACK window_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
    };
 }
@@ -0,0 +1,465 @@
+#include "overlay/windows/controller_presets.h"
+
+#include <filesystem>
+
+#include "cfg/resource.h"
+#include "external/tinyxml2/tinyxml2.h"
+#include "util/fileutils.h"
+#include "util/logging.h"
+#include "util/resutils.h"
+
+namespace overlay::windows {
+
+    static std::filesystem::path get_templates_path() {
+        return fileutils::get_config_file_path("ControllerPresets", "spicetools_presets.xml");
+    }
+
+    static void write_button_entry(tinyxml2::XMLDocument &doc, tinyxml2::XMLElement *parent,
+                                   const std::string &name, const TemplateButtonEntry &entry) {
+        auto *el = doc.NewElement("button");
+        el->SetAttribute("name", name.c_str());
+        el->SetAttribute("vkey", entry.vKey);
+        el->SetAttribute("analogtype", (int)entry.analog_type);
+        el->SetAttribute("devid", entry.device_identifier.c_str());
+        el->SetAttribute("invert", entry.invert);
+        el->SetAttribute("debounce_up", entry.debounce_up);
+        el->SetAttribute("debounce_down", entry.debounce_down);
+        el->SetAttribute("bat_threshold", entry.bat_threshold);
+        el->SetAttribute("velocity_threshold", entry.velocity_threshold);
+        parent->InsertEndChild(el);
+    }
+
+    static TemplateButtonEntry read_button_entry(tinyxml2::XMLElement *el) {
+        TemplateButtonEntry entry;
+        int vkey = INVALID_VKEY;
+        el->QueryIntAttribute("vkey", &vkey);
+        entry.vKey = (unsigned short)vkey;
+
+        int atype = 0;
+        el->QueryIntAttribute("analogtype", &atype);
+        entry.analog_type = (ButtonAnalogType)atype;
+
+        const char *devid = el->Attribute("devid");
+        entry.device_identifier = devid ? devid : "";
+
+        el->QueryBoolAttribute("invert", &entry.invert);
+        el->QueryDoubleAttribute("debounce_up", &entry.debounce_up);
+        el->QueryDoubleAttribute("debounce_down", &entry.debounce_down);
+
+        int vel = 0;
+        el->QueryIntAttribute("velocity_threshold", &vel);
+        entry.velocity_threshold = (unsigned short)vel;
+
+        int bat = 0;
+        el->QueryIntAttribute("bat_threshold", &bat);
+        entry.bat_threshold = bat;
+
+        return entry;
+    }
+
+    static void write_analog(tinyxml2::XMLDocument &doc, tinyxml2::XMLElement *parent,
+                             const TemplateAnalogBinding &analog) {
+        auto *el = doc.NewElement("analog");
+        el->SetAttribute("name", analog.name.c_str());
+        el->SetAttribute("devid", analog.device_identifier.c_str());
+        el->SetAttribute("index", analog.index);
+        el->SetAttribute("sensivity", analog.sensitivity);  // keep typo for compat
+        el->SetAttribute("deadzone", analog.deadzone);
+        el->SetAttribute("deadzone_mirror", analog.deadzone_mirror);
+        el->SetAttribute("invert", analog.invert);
+        el->SetAttribute("smoothing", analog.smoothing);
+        el->SetAttribute("multiplier", analog.multiplier);
+        el->SetAttribute("relative", analog.relative_mode);
+        el->SetAttribute("delay_ms", analog.delay_ms);
+        parent->InsertEndChild(el);
+    }
+
+    static TemplateAnalogBinding read_analog(tinyxml2::XMLElement *el) {
+        TemplateAnalogBinding a;
+        const char *name = el->Attribute("name");
+        a.name = name ? name : "";
+
+        const char *devid = el->Attribute("devid");
+        a.device_identifier = devid ? devid : "";
+
+        int idx = 0xFF;
+        el->QueryIntAttribute("index", &idx);
+        a.index = (unsigned short)idx;
+
+        el->QueryFloatAttribute("sensivity", &a.sensitivity);  // keep typo
+        el->QueryFloatAttribute("deadzone", &a.deadzone);
+        el->QueryBoolAttribute("deadzone_mirror", &a.deadzone_mirror);
+        el->QueryBoolAttribute("invert", &a.invert);
+        el->QueryBoolAttribute("smoothing", &a.smoothing);
+        el->QueryIntAttribute("multiplier", &a.multiplier);
+        el->QueryBoolAttribute("relative", &a.relative_mode);
+        el->QueryUnsignedAttribute("delay_ms", &a.delay_ms);
+
+        return a;
+    }
+
+    static void write_light_entry(tinyxml2::XMLDocument &doc, tinyxml2::XMLElement *parent,
+                                  const std::string &name, const TemplateLightEntry &entry) {
+        auto *el = doc.NewElement("light");
+        el->SetAttribute("name", name.c_str());
+        el->SetAttribute("devid", entry.device_identifier.c_str());
+        el->SetAttribute("index", entry.index);
+        parent->InsertEndChild(el);
+    }
+
+    static TemplateLightEntry read_light_entry(tinyxml2::XMLElement *el) {
+        TemplateLightEntry entry;
+        const char *devid = el->Attribute("devid");
+        entry.device_identifier = devid ? devid : "";
+
+        int idx = 0;
+        el->QueryIntAttribute("index", &idx);
+        entry.index = (unsigned int)idx;
+
+        return entry;
+    }
+
+    // Parse all templates from an already-loaded XMLDocument.
+    // is_builtin controls the is_builtin flag on each returned template.
+    static std::vector<ControllerTemplate> load_templates_from_doc(
+            tinyxml2::XMLDocument &doc, bool is_builtin) {
+        std::vector<ControllerTemplate> templates;
+
+        auto *root = doc.RootElement();
+        if (!root) {
+            return templates;
+        }
+
+        auto *tmpl_el = root->FirstChildElement("template");
+        while (tmpl_el) {
+            ControllerTemplate tmpl;
+            const char *name = tmpl_el->Attribute("name");
+            const char *game = tmpl_el->Attribute("game");
+            tmpl.name = name ? name : "";
+            tmpl.game_name = game ? game : "";
+            tmpl.is_builtin = is_builtin;
+
+            // buttons
+            auto *buttons_el = tmpl_el->FirstChildElement("buttons");
+            if (buttons_el) {
+                auto *btn_el = buttons_el->FirstChildElement("button");
+                while (btn_el) {
+                    const char *btn_name = btn_el->Attribute("name");
+                    std::string btn_name_str = btn_name ? btn_name : "";
+
+                    TemplateButtonBinding *binding = nullptr;
+                    for (auto &b : tmpl.buttons) {
+                        if (b.name == btn_name_str) { binding = &b; break; }
+                    }
+                    if (!binding) {
+                        tmpl.buttons.push_back({btn_name_str, read_button_entry(btn_el), {}});
+                    } else {
+                        binding->alternatives.push_back(read_button_entry(btn_el));
+                    }
+                    btn_el = btn_el->NextSiblingElement("button");
+                }
+            }
+
+            // keypad buttons
+            auto *kp_el = tmpl_el->FirstChildElement("keypad_buttons");
+            if (kp_el) {
+                auto *btn_el = kp_el->FirstChildElement("button");
+                while (btn_el) {
+                    const char *btn_name = btn_el->Attribute("name");
+                    std::string btn_name_str = btn_name ? btn_name : "";
+
+                    TemplateButtonBinding *binding = nullptr;
+                    for (auto &b : tmpl.keypad_buttons) {
+                        if (b.name == btn_name_str) { binding = &b; break; }
+                    }
+                    if (!binding) {
+                        tmpl.keypad_buttons.push_back({btn_name_str, read_button_entry(btn_el), {}});
+                    } else {
+                        binding->alternatives.push_back(read_button_entry(btn_el));
+                    }
+                    btn_el = btn_el->NextSiblingElement("button");
+                }
+            }
+
+            // analogs
+            auto *analogs_el = tmpl_el->FirstChildElement("analogs");
+            if (analogs_el) {
+                auto *analog_el = analogs_el->FirstChildElement("analog");
+                while (analog_el) {
+                    tmpl.analogs.push_back(read_analog(analog_el));
+                    analog_el = analog_el->NextSiblingElement("analog");
+                }
+            }
+
+            // lights
+            auto *lights_el = tmpl_el->FirstChildElement("lights");
+            if (lights_el) {
+                auto *light_el = lights_el->FirstChildElement("light");
+                while (light_el) {
+                    const char *light_name = light_el->Attribute("name");
+                    std::string light_name_str = light_name ? light_name : "";
+
+                    TemplateLightBinding *binding = nullptr;
+                    for (auto &l : tmpl.lights) {
+                        if (l.name == light_name_str) { binding = &l; break; }
+                    }
+                    if (!binding) {
+                        tmpl.lights.push_back({light_name_str, read_light_entry(light_el), {}});
+                    } else {
+                        binding->alternatives.push_back(read_light_entry(light_el));
+                    }
+                    light_el = light_el->NextSiblingElement("light");
+                }
+            }
+
+            templates.push_back(std::move(tmpl));
+            tmpl_el = tmpl_el->NextSiblingElement("template");
+        }
+
+        return templates;
+    }
+
+    static std::vector<ControllerTemplate> load_builtin_templates() {
+        auto xml = resutil::load_file_string(IDR_CONTROLLER_PRESETS_BUILTIN);
+        tinyxml2::XMLDocument doc;
+        auto err = doc.Parse(xml.c_str());
+        if (err != tinyxml2::XML_SUCCESS) {
+            log_warning("templates", "failed to parse builtin templates XML: {}", (int)err);
+            return {};
+        }
+        return load_templates_from_doc(doc, true);
+    }
+
+    std::vector<ControllerTemplate> load_user_templates() {
+        std::vector<ControllerTemplate> templates;
+        auto path = get_templates_path();
+
+        tinyxml2::XMLDocument doc;
+        if (doc.LoadFile(path.c_str()) != tinyxml2::XML_SUCCESS) {
+            return templates;
+        }
+        return load_templates_from_doc(doc, false);
+    }
+
+    bool save_user_template(
+        const ControllerTemplate &tmpl,
+        const bool save_buttons,
+        const bool save_keypads,
+        const bool save_analogs,
+        const bool save_lights) {
+
+        auto path = get_templates_path();
+        auto path_tmp = path;
+        path_tmp.replace_extension(L"tmp");
+
+        tinyxml2::XMLDocument doc;
+        if (doc.LoadFile(path.c_str()) != tinyxml2::XML_SUCCESS) {
+            auto *decl = doc.NewDeclaration();
+            doc.InsertFirstChild(decl);
+            auto *root = doc.NewElement("templates");
+            doc.InsertEndChild(root);
+        }
+
+        auto *root = doc.RootElement();
+        if (!root) {
+            root = doc.NewElement("templates");
+            doc.InsertEndChild(root);
+        }
+
+        // remove existing template with same name and game
+        auto *existing = root->FirstChildElement("template");
+        while (existing) {
+            auto *next = existing->NextSiblingElement("template");
+            const char *ename = existing->Attribute("name");
+            const char *egame = existing->Attribute("game");
+            if (ename && egame &&
+                std::string(ename) == tmpl.name &&
+                std::string(egame) == tmpl.game_name) {
+                root->DeleteChild(existing);
+            }
+            existing = next;
+        }
+
+        auto *tmpl_el = doc.NewElement("template");
+        tmpl_el->SetAttribute("name", tmpl.name.c_str());
+        tmpl_el->SetAttribute("game", tmpl.game_name.c_str());
+
+        // buttons — skip unbound entries
+        auto *buttons_el = doc.NewElement("buttons");
+        if (save_buttons) {
+            for (auto &btn : tmpl.buttons) {
+                if (!btn.primary.is_unbound()) {
+                    write_button_entry(doc, buttons_el, btn.name, btn.primary);
+                }
+                for (auto &alt : btn.alternatives) {
+                    if (!alt.is_unbound()) {
+                        write_button_entry(doc, buttons_el, btn.name, alt);
+                    }
+                }
+            }
+        }
+        tmpl_el->InsertEndChild(buttons_el);
+
+        // keypad buttons — skip unbound entries
+        if (!tmpl.keypad_buttons.empty()) {
+            auto *kp_el = doc.NewElement("keypad_buttons");
+            if (save_keypads) {
+                for (auto &btn : tmpl.keypad_buttons) {
+                    if (!btn.primary.is_unbound()) {
+                        write_button_entry(doc, kp_el, btn.name, btn.primary);
+                    }
+                    for (auto &alt : btn.alternatives) {
+                        if (!alt.is_unbound()) {
+                            write_button_entry(doc, kp_el, btn.name, alt);
+                        }
+                    }
+                }
+            }
+            tmpl_el->InsertEndChild(kp_el);
+        }
+
+        // analogs — skip unbound entries
+        auto *analogs_el = doc.NewElement("analogs");
+        if (save_analogs) {
+            for (auto &a : tmpl.analogs) {
+                if (!a.is_unbound()) {
+                    write_analog(doc, analogs_el, a);
+                }
+            }
+        }
+        tmpl_el->InsertEndChild(analogs_el);
+
+        // lights — skip unbound entries
+        auto *lights_el = doc.NewElement("lights");
+        if (save_lights) {
+            for (auto &l : tmpl.lights) {
+                if (!l.primary.is_unbound()) {
+                    write_light_entry(doc, lights_el, l.name, l.primary);
+                }
+                for (auto &alt : l.alternatives) {
+                    if (!alt.is_unbound()) {
+                        write_light_entry(doc, lights_el, l.name, alt);
+                    }
+                }
+            }
+        }
+        tmpl_el->InsertEndChild(lights_el);
+
+        root->InsertEndChild(tmpl_el);
+
+        // ensure directory exists
+        if (!path.parent_path().empty() && !std::filesystem::exists(path.parent_path())) {
+            fileutils::dir_create_recursive(path.parent_path());
+        }
+
+        // save atomically via temp file
+        auto save_err = doc.SaveFile(path_tmp.c_str());
+        if (save_err != tinyxml2::XML_SUCCESS) {
+            log_warning("templates", "failed to save templates file: {}", (int)save_err);
+            return false;
+        }
+
+        std::error_code ec;
+        std::filesystem::rename(path_tmp, path, ec);
+        if (ec) {
+            log_warning("templates", "failed to rename templates file: {}", ec.message());
+            return false;
+        }
+
+        return true;
+    }
+
+    bool delete_user_template(const std::string &game_name, const std::string &template_name) {
+        auto path = get_templates_path();
+
+        tinyxml2::XMLDocument doc;
+        if (doc.LoadFile(path.c_str()) != tinyxml2::XML_SUCCESS) return false;
+
+        auto *root = doc.RootElement();
+        if (!root) return false;
+
+        bool found = false;
+        auto *tmpl_el = root->FirstChildElement("template");
+        while (tmpl_el) {
+            auto *next = tmpl_el->NextSiblingElement("template");
+            const char *ename = tmpl_el->Attribute("name");
+            const char *egame = tmpl_el->Attribute("game");
+            if (ename && egame &&
+                std::string(ename) == template_name &&
+                std::string(egame) == game_name) {
+                root->DeleteChild(tmpl_el);
+                found = true;
+            }
+            tmpl_el = next;
+        }
+
+        if (found) {
+            auto path_tmp = path;
+            path_tmp.replace_extension(L"tmp");
+            if (doc.SaveFile(path_tmp.c_str()) == tinyxml2::XML_SUCCESS) {
+                std::error_code ec;
+                std::filesystem::rename(path_tmp, path, ec);
+            }
+        }
+
+        return found;
+    }
+
+    bool rename_user_template(const std::string &game_name,
+                              const std::string &old_name, const std::string &new_name) {
+        auto path = get_templates_path();
+
+        tinyxml2::XMLDocument doc;
+        if (doc.LoadFile(path.c_str()) != tinyxml2::XML_SUCCESS) return false;
+
+        auto *root = doc.RootElement();
+        if (!root) return false;
+
+        bool found = false;
+        auto *tmpl_el = root->FirstChildElement("template");
+        while (tmpl_el) {
+            const char *ename = tmpl_el->Attribute("name");
+            const char *egame = tmpl_el->Attribute("game");
+            if (ename && egame &&
+                std::string(ename) == old_name &&
+                std::string(egame) == game_name) {
+                tmpl_el->SetAttribute("name", new_name.c_str());
+                found = true;
+                break;
+            }
+            tmpl_el = tmpl_el->NextSiblingElement("template");
+        }
+
+        if (found) {
+            auto path_tmp = path;
+            path_tmp.replace_extension(L"tmp");
+            if (doc.SaveFile(path_tmp.c_str()) == tinyxml2::XML_SUCCESS) {
+                std::error_code ec;
+                std::filesystem::rename(path_tmp, path, ec);
+            }
+        }
+
+        return found;
+    }
+
+    std::vector<ControllerTemplate> get_templates_for_game(const std::string &game_name) {
+        std::vector<ControllerTemplate> result;
+
+        log_misc("templates", "loading built-in templates for {}", game_name);
+        for (auto &t : load_builtin_templates()) {
+            if (t.game_name == game_name) {
+                result.push_back(std::move(t));
+            }
+        }
+
+        log_misc("templates", "loading user templates for {}", game_name);
+        for (auto &t : load_user_templates()) {
+            if (t.game_name == game_name) {
+                result.push_back(std::move(t));
+            }
+        }
+
+        return result;
+    }
+
+}
@@ -85,6 +85,15 @@ std::string Light::getDisplayString(rawinput::RawInputManager* manager) {

            return "Invalid SMX Dedicab Light (" + index_string + ")";
        }
+        case rawinput::XINPUT_GAMEPAD: {
+            if (index < static_cast<size_t>(xinput::XInputOutputEnum::COUNT)) {
+                return fmt::format("{} ({})",
+                    xinput::get_output_string(static_cast<xinput::XInputOutputEnum>(index)),
+                    device->desc);
+            }
+
+            return "Invalid XInput Gamepad Light (" + index_string + ")";
+        }
        case rawinput::DESTROYED:
            return "Unplugged device (" + index_string + ")";
        default:
@@ -11,8 +11,10 @@ class Light {
 private:
    std::vector<Light> alternatives;
    std::string lightName;
+    std::string lightCategory;
    std::string deviceIdentifier = "";
    unsigned int index = 0;
+    bool is_temporary = false;

 public:
    float last_state = 0.f;
@@ -22,6 +24,8 @@ public:
    float override_state = 0.f;

    explicit Light(std::string lightName) : lightName(std::move(lightName)) {};
+    explicit Light(std::string lightName, std::string lightCategory) :
+        lightName(std::move(lightName)), lightCategory(std::move(lightCategory)) {};

    std::string getDisplayString(rawinput::RawInputManager* manager);

@@ -50,6 +54,14 @@ public:
        return this->lightName;
    }

+    inline const std::string &getCategory() const {
+        return this->lightCategory;
+    }
+
+    inline void setCategory(std::string category) {
+        this->lightCategory = std::move(category);
+    }
+
    inline const std::string &getDeviceIdentifier() const {
        return this->deviceIdentifier;
    }
@@ -65,4 +77,26 @@ public:
    inline void setIndex(unsigned int index) {
        this->index = index;
    }
+
+    inline bool isTemporary() const {
+        return this->is_temporary;
+    }
+
+    inline void setTemporary(bool is_temporary) {
+        this->is_temporary = is_temporary;
+    }
+
+    inline bool isValid() {
+        // temporarily created by UI
+        if (isTemporary()) {
+            return true;
+        }
+
+        // nothing is set
+        if (getDeviceIdentifier().empty()) {
+            return false;
+        }
+
+        return true;
+    }
 };
@@ -20,10 +20,10 @@
        </dependentAssembly>
    </dependency>
    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
-            <security>
-                <requestedPrivileges>
-                    <requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>
-                </requestedPrivileges>
-            </security>
+        <security>
+            <requestedPrivileges>
+                <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
+            </requestedPrivileges>
+        </security>
    </trustInfo>
 </assembly>
@@ -13,6 +13,16 @@ enum class OptionType {
    Hex,
 };

+enum class OptionPickerType {
+    None,
+    AsioDriver,
+    EACard,
+    CpuAffinity,
+    FilePath,
+    DirectoryPath,
+    Monitor,
+};
+
 struct OptionDefinition {
    std::string title;
    // unique identifier used for flag matching but also stored in config files
@@ -32,6 +42,10 @@ struct OptionDefinition {
    bool sensitive = false;
    std::vector<std::pair<std::string, std::string>> elements = {};
    bool disabled = false;
+    OptionPickerType picker = OptionPickerType::None;
+
+    // for OptionPickerType::FilePath
+    std::string file_extension = "";
 };

 class Option {
@@ -4,3 +4,4 @@
 #define IDR_PATCHES                     132
 #define IDR_README                      133
 #define IDR_DSEGFONT                    134
+#define IDR_CONTROLLER_PRESETS_BUILTIN  135
@@ -1,9 +1,11 @@
 #include "screen_resize.h"

+#include "avs/game.h"
 #include "external/rapidjson/document.h"
 #include "external/rapidjson/pointer.h"
 #include "external/rapidjson/prettywriter.h"
 #include "misc/eamuse.h"
+#include "util/deferlog.h"
 #include "util/utils.h"
 #include "util/fileutils.h"
 #include "hooks/graphics/graphics.h"
@@ -19,7 +21,7 @@ namespace cfg {
        if (SCREEN_RESIZE_CFG_PATH_OVERRIDE.has_value()) {
            this->config_path = SCREEN_RESIZE_CFG_PATH_OVERRIDE.value();
            if (fileutils::file_exists(this->config_path)) {
-                log_info("ScreenResize", "loading config from: {}", this->config_path.string());
+                log_info("ScreenResize", "loading config from: {}", this->config_path);
                file_exists = true;
            }
        } else {
@@ -78,6 +80,10 @@ namespace cfg {
            root);

        load_bool_value(doc, root + "enable_screen_resize", this->enable_screen_resize);
+        if (this->enable_screen_resize) {
+            log_misc("ScreenResize", "enabled by config file");
+        }
+
        load_bool_value(doc, root + "enable_linear_filter", this->enable_linear_filter);
        for (size_t i = 0; i < std::size(this->scene_settings); i++) {
            auto& scene = this->scene_settings[i];
@@ -1,5 +1,6 @@
 #pragma once

+#include <atomic>
 #include <memory>
 #include <string>
 #include <optional>
@@ -51,11 +52,15 @@ namespace cfg {
        bool enable_linear_filter = true;
        fullscreen_setting scene_settings[4];

+        // state
+        std::atomic<bool> need_surface_clean = false;
+
        // windowed mode sizing
        // Windows terminology:
        //     window = rectangle including the frame
        //     client = just the content area without frames.
        bool window_always_on_top = false;
+        bool window_disable_round_corners = false;
        bool client_keep_aspect_ratio = true;
        bool enable_window_resize = false;
        int window_decoration = 0; // enum type WindowDecorationMode
@@ -69,6 +74,7 @@ namespace cfg {
        uint32_t init_client_height = 0;
        float init_client_aspect_ratio = 1.f;
        uint32_t init_window_style = 0;
+        uint32_t init_window_style_ex = 0;
        uint32_t window_deco_width = 0;
        uint32_t window_deco_height = 0;

@@ -15,3 +15,11 @@ RUN pacman --noconfirm -Syu git \
    ccache
 RUN useradd user -m && echo "ALL ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers
 RUN su user -c "cd /tmp/ && git clone https://aur.archlinux.org/yay-bin.git --depth=1 && cd yay-bin && makepkg --noconfirm -si && yay --noconfirm -S mingw-w64-cmake"
+
+RUN mkdir -p /opt/llvm-mingw-xp \
+    && curl -fsSL "https://github.com/mon/llvm-mingw-xp/releases/download/llvm-mingw-xp-22.1.0/llvm-mingw-llvm-mingw-xp-22.1.0-msvcrt-ubuntu-22.04-x86_64.tar.xz" \
+    | tar -xJ --strip-components=1 -C /opt/llvm-mingw-xp
+ENV PATH="$PATH:/opt/llvm-mingw-xp/bin"
+
+RUN curl -fsSL "https://github.com/mon/windows-dll-compat-checker/releases/download/v1.3/windows_dll_compat_checker-linux-x86_64.tar.xz" \
+    | tar -xJ -C /usr/local/bin
@@ -20,6 +20,7 @@ Usage:
 #include <memory>
 #include <string>
 #include <map>
+#include <cstdint>

 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

@@ -21,5 +21,12 @@ set(IMGUI_SOURCES
        misc/cpp/imgui_stdlib.cpp
 )

+# spice2x: DX11 backend is only built for non-XP toolchains. WinXP lacks
+# D3DCOMPILER_47.dll, and including this TU would pull in D3DCompile imports.
+if(NOT SPICE_XP)
+    list(APPEND IMGUI_HEADERS backends/imgui_impl_dx11.h)
+    list(APPEND IMGUI_SOURCES backends/imgui_impl_dx11.cpp)
+endif()
+
 add_library(imgui STATIC ${IMGUI_HEADERS} ${IMGUI_SOURCES})
 target_include_directories(imgui PRIVATE ${PROJECT_SOURCE_DIR})
@@ -1,6 +1,6 @@
 The MIT License (MIT)

-Copyright (c) 2014-2023 Omar Cornut
+Copyright (c) 2014-2026 Omar Cornut

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -0,0 +1,697 @@
+// dear imgui: Renderer Backend for DirectX11
+// This needs to be used along with a Platform Backend (e.g. Win32)
+
+// Implemented features:
+//  [X] Renderer: User texture binding. Use 'ID3D11ShaderResourceView*' as texture identifier. Read the FAQ about ImTextureID/ImTextureRef!
+//  [X] Renderer: Large meshes support (64k+ vertices) even with 16-bit indices (ImGuiBackendFlags_RendererHasVtxOffset).
+//  [X] Renderer: Texture updates support for dynamic font atlas (ImGuiBackendFlags_RendererHasTextures).
+//  [X] Renderer: Expose selected render state for draw callbacks to use. Access in '(ImGui_ImplXXXX_RenderState*)GetPlatformIO().Renderer_RenderState'.
+
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
+// - Introduction, links and more at the top of imgui.cpp
+
+// CHANGELOG
+// (minor and older changes stripped away, please see git history for details)
+//  2026-01-19: DirectX11: Added 'SamplerNearest' in ImGui_ImplDX11_RenderState. Renamed 'SamplerDefault' to 'SamplerLinear'.
+//  2025-09-18: Call platform_io.ClearRendererHandlers() on shutdown.
+//  2025-06-11: DirectX11: Added support for ImGuiBackendFlags_RendererHasTextures, for dynamic font atlas.
+//  2025-05-07: DirectX11: Honor draw_data->FramebufferScale to allow for custom backends and experiment using it (consistently with other renderer backends, even though in normal condition it is not set under Windows).
+//  2025-01-06: DirectX11: Expose VertexConstantBuffer in ImGui_ImplDX11_RenderState. Reset projection matrix in ImDrawCallback_ResetRenderState handler.
+//  2024-10-07: DirectX11: Changed default texture sampler to Clamp instead of Repeat/Wrap.
+//  2024-10-07: DirectX11: Expose selected render state in ImGui_ImplDX11_RenderState, which you can access in 'void* platform_io.Renderer_RenderState' during draw callbacks.
+//  2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
+//  2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
+//  2021-05-19: DirectX11: Replaced direct access to ImDrawCmd::TextureId with a call to ImDrawCmd::GetTexID(). (will become a requirement)
+//  2021-02-18: DirectX11: Change blending equation to preserve alpha in output buffer.
+//  2019-08-01: DirectX11: Fixed code querying the Geometry Shader state (would generally error with Debug layer enabled).
+//  2019-07-21: DirectX11: Backup, clear and restore Geometry Shader is any is bound when calling ImGui_ImplDX11_RenderDrawData. Clearing Hull/Domain/Compute shaders without backup/restore.
+//  2019-05-29: DirectX11: Added support for large mesh (64K+ vertices), enable ImGuiBackendFlags_RendererHasVtxOffset flag.
+//  2019-04-30: DirectX11: Added support for special ImDrawCallback_ResetRenderState callback to reset render state.
+//  2018-12-03: Misc: Added #pragma comment statement to automatically link with d3dcompiler.lib when using D3DCompile().
+//  2018-11-30: Misc: Setting up io.BackendRendererName so it can be displayed in the About Window.
+//  2018-08-01: DirectX11: Querying for IDXGIFactory instead of IDXGIFactory1 to increase compatibility.
+//  2018-07-13: DirectX11: Fixed unreleased resources in Init and Shutdown functions.
+//  2018-06-08: Misc: Extracted imgui_impl_dx11.cpp/.h away from the old combined DX11+Win32 example.
+//  2018-06-08: DirectX11: Use draw_data->DisplayPos and draw_data->DisplaySize to setup projection matrix and clipping rectangle.
+//  2018-02-16: Misc: Obsoleted the io.RenderDrawListsFn callback and exposed ImGui_ImplDX11_RenderDrawData() in the .h file so you can call it yourself.
+//  2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
+//  2016-05-07: DirectX11: Disabling depth-write.
+
+#include "imgui.h"
+#ifndef IMGUI_DISABLE
+#include "imgui_impl_dx11.h"
+
+// DirectX
+#include <stdio.h>
+#include <d3d11.h>
+#include <d3dcompiler.h>
+#ifdef _MSC_VER
+#pragma comment(lib, "d3dcompiler") // Automatically link with d3dcompiler.lib as we are using D3DCompile() below.
+#endif
+
+// Clang/GCC warnings with -Weverything
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wold-style-cast"         // warning: use of old-style cast                            // yes, they are more terse.
+#pragma clang diagnostic ignored "-Wsign-conversion"        // warning: implicit conversion changes signedness
+#endif
+
+// DirectX11 data
+struct ImGui_ImplDX11_Texture
+{
+    ID3D11Texture2D*            pTexture;
+    ID3D11ShaderResourceView*   pTextureView;
+};
+
+struct ImGui_ImplDX11_Data
+{
+    ID3D11Device*               pd3dDevice;
+    ID3D11DeviceContext*        pd3dDeviceContext;
+    IDXGIFactory*               pFactory;
+    ID3D11Buffer*               pVB;
+    ID3D11Buffer*               pIB;
+    ID3D11VertexShader*         pVertexShader;
+    ID3D11InputLayout*          pInputLayout;
+    ID3D11Buffer*               pVertexConstantBuffer;
+    ID3D11PixelShader*          pPixelShader;
+    ID3D11SamplerState*         pTexSamplerLinear;
+    ID3D11SamplerState*         pTexSamplerNearest;
+    ID3D11RasterizerState*      pRasterizerState;
+    ID3D11BlendState*           pBlendState;
+    ID3D11DepthStencilState*    pDepthStencilState;
+    int                         VertexBufferSize;
+    int                         IndexBufferSize;
+
+    ImGui_ImplDX11_Data()       { memset((void*)this, 0, sizeof(*this)); VertexBufferSize = 5000; IndexBufferSize = 10000; }
+};
+
+struct VERTEX_CONSTANT_BUFFER_DX11
+{
+    float   mvp[4][4];
+};
+
+// Backend data stored in io.BackendRendererUserData to allow support for multiple Dear ImGui contexts
+// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
+static ImGui_ImplDX11_Data* ImGui_ImplDX11_GetBackendData()
+{
+    return ImGui::GetCurrentContext() ? (ImGui_ImplDX11_Data*)ImGui::GetIO().BackendRendererUserData : nullptr;
+}
+
+// Functions
+static void ImGui_ImplDX11_SetupRenderState(const ImDrawData* draw_data, ID3D11DeviceContext* device_ctx)
+{
+    ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
+
+    // Setup viewport
+    D3D11_VIEWPORT vp = {};
+    vp.Width = draw_data->DisplaySize.x * draw_data->FramebufferScale.x;
+    vp.Height = draw_data->DisplaySize.y * draw_data->FramebufferScale.y;
+    vp.MinDepth = 0.0f;
+    vp.MaxDepth = 1.0f;
+    vp.TopLeftX = vp.TopLeftY = 0;
+    device_ctx->RSSetViewports(1, &vp);
+
+    // Setup orthographic projection matrix into our constant buffer
+    // Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayPos is (0,0) for single viewport apps.
+    D3D11_MAPPED_SUBRESOURCE mapped_resource;
+    if (device_ctx->Map(bd->pVertexConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_resource) == S_OK)
+    {
+        VERTEX_CONSTANT_BUFFER_DX11* constant_buffer = (VERTEX_CONSTANT_BUFFER_DX11*)mapped_resource.pData;
+        float L = draw_data->DisplayPos.x;
+        float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x;
+        float T = draw_data->DisplayPos.y;
+        float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y;
+        float mvp[4][4] =
+        {
+            { 2.0f/(R-L),   0.0f,           0.0f,       0.0f },
+            { 0.0f,         2.0f/(T-B),     0.0f,       0.0f },
+            { 0.0f,         0.0f,           0.5f,       0.0f },
+            { (R+L)/(L-R),  (T+B)/(B-T),    0.5f,       1.0f },
+        };
+        memcpy(&constant_buffer->mvp, mvp, sizeof(mvp));
+        device_ctx->Unmap(bd->pVertexConstantBuffer, 0);
+    }
+
+    // Setup shader and vertex buffers
+    unsigned int stride = sizeof(ImDrawVert);
+    unsigned int offset = 0;
+    device_ctx->IASetInputLayout(bd->pInputLayout);
+    device_ctx->IASetVertexBuffers(0, 1, &bd->pVB, &stride, &offset);
+    device_ctx->IASetIndexBuffer(bd->pIB, sizeof(ImDrawIdx) == 2 ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT, 0);
+    device_ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+    device_ctx->VSSetShader(bd->pVertexShader, nullptr, 0);
+    device_ctx->VSSetConstantBuffers(0, 1, &bd->pVertexConstantBuffer);
+    device_ctx->PSSetShader(bd->pPixelShader, nullptr, 0);
+    device_ctx->PSSetSamplers(0, 1, &bd->pTexSamplerLinear);
+    device_ctx->GSSetShader(nullptr, nullptr, 0);
+    device_ctx->HSSetShader(nullptr, nullptr, 0); // In theory we should backup and restore this as well.. very infrequently used..
+    device_ctx->DSSetShader(nullptr, nullptr, 0); // In theory we should backup and restore this as well.. very infrequently used..
+    device_ctx->CSSetShader(nullptr, nullptr, 0); // In theory we should backup and restore this as well.. very infrequently used..
+
+    // Setup render state
+    const float blend_factor[4] = { 0.f, 0.f, 0.f, 0.f };
+    device_ctx->OMSetBlendState(bd->pBlendState, blend_factor, 0xffffffff);
+    device_ctx->OMSetDepthStencilState(bd->pDepthStencilState, 0);
+    device_ctx->RSSetState(bd->pRasterizerState);
+}
+
+// Render function
+void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data)
+{
+    // Avoid rendering when minimized
+    if (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f)
+        return;
+
+    ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
+    ID3D11DeviceContext* device = bd->pd3dDeviceContext;
+
+    // Catch up with texture updates. Most of the times, the list will have 1 element with an OK status, aka nothing to do.
+    // (This almost always points to ImGui::GetPlatformIO().Textures[] but is part of ImDrawData to allow overriding or disabling texture updates).
+    if (draw_data->Textures != nullptr)
+        for (ImTextureData* tex : *draw_data->Textures)
+            if (tex->Status != ImTextureStatus_OK)
+                ImGui_ImplDX11_UpdateTexture(tex);
+
+    // Create and grow vertex/index buffers if needed
+    if (!bd->pVB || bd->VertexBufferSize < draw_data->TotalVtxCount)
+    {
+        if (bd->pVB) { bd->pVB->Release(); bd->pVB = nullptr; }
+        bd->VertexBufferSize = draw_data->TotalVtxCount + 5000;
+        D3D11_BUFFER_DESC desc = {};
+        desc.Usage = D3D11_USAGE_DYNAMIC;
+        desc.ByteWidth = bd->VertexBufferSize * sizeof(ImDrawVert);
+        desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
+        desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+        desc.MiscFlags = 0;
+        if (bd->pd3dDevice->CreateBuffer(&desc, nullptr, &bd->pVB) < 0)
+            return;
+    }
+    if (!bd->pIB || bd->IndexBufferSize < draw_data->TotalIdxCount)
+    {
+        if (bd->pIB) { bd->pIB->Release(); bd->pIB = nullptr; }
+        bd->IndexBufferSize = draw_data->TotalIdxCount + 10000;
+        D3D11_BUFFER_DESC desc = {};
+        desc.Usage = D3D11_USAGE_DYNAMIC;
+        desc.ByteWidth = bd->IndexBufferSize * sizeof(ImDrawIdx);
+        desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
+        desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+        if (bd->pd3dDevice->CreateBuffer(&desc, nullptr, &bd->pIB) < 0)
+            return;
+    }
+
+    // Upload vertex/index data into a single contiguous GPU buffer
+    D3D11_MAPPED_SUBRESOURCE vtx_resource, idx_resource;
+    if (device->Map(bd->pVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &vtx_resource) != S_OK)
+        return;
+    if (device->Map(bd->pIB, 0, D3D11_MAP_WRITE_DISCARD, 0, &idx_resource) != S_OK)
+        return;
+    ImDrawVert* vtx_dst = (ImDrawVert*)vtx_resource.pData;
+    ImDrawIdx* idx_dst = (ImDrawIdx*)idx_resource.pData;
+    for (const ImDrawList* draw_list : draw_data->CmdLists)
+    {
+        memcpy(vtx_dst, draw_list->VtxBuffer.Data, draw_list->VtxBuffer.Size * sizeof(ImDrawVert));
+        memcpy(idx_dst, draw_list->IdxBuffer.Data, draw_list->IdxBuffer.Size * sizeof(ImDrawIdx));
+        vtx_dst += draw_list->VtxBuffer.Size;
+        idx_dst += draw_list->IdxBuffer.Size;
+    }
+    device->Unmap(bd->pVB, 0);
+    device->Unmap(bd->pIB, 0);
+
+    // Backup DX state that will be modified to restore it afterwards (unfortunately this is very ugly looking and verbose. Close your eyes!)
+    struct BACKUP_DX11_STATE
+    {
+        UINT                        ScissorRectsCount, ViewportsCount;
+        D3D11_RECT                  ScissorRects[D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE];
+        D3D11_VIEWPORT              Viewports[D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE];
+        ID3D11RasterizerState*      RS;
+        ID3D11BlendState*           BlendState;
+        FLOAT                       BlendFactor[4];
+        UINT                        SampleMask;
+        UINT                        StencilRef;
+        ID3D11DepthStencilState*    DepthStencilState;
+        ID3D11ShaderResourceView*   PSShaderResource;
+        ID3D11SamplerState*         PSSampler;
+        ID3D11PixelShader*          PS;
+        ID3D11VertexShader*         VS;
+        ID3D11GeometryShader*       GS;
+        UINT                        PSInstancesCount, VSInstancesCount, GSInstancesCount;
+        ID3D11ClassInstance         *PSInstances[256], *VSInstances[256], *GSInstances[256];   // 256 is max according to PSSetShader documentation
+        D3D11_PRIMITIVE_TOPOLOGY    PrimitiveTopology;
+        ID3D11Buffer*               IndexBuffer, *VertexBuffer, *VSConstantBuffer;
+        UINT                        IndexBufferOffset, VertexBufferStride, VertexBufferOffset;
+        DXGI_FORMAT                 IndexBufferFormat;
+        ID3D11InputLayout*          InputLayout;
+    };
+    BACKUP_DX11_STATE old = {};
+    old.ScissorRectsCount = old.ViewportsCount = D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE;
+    device->RSGetScissorRects(&old.ScissorRectsCount, old.ScissorRects);
+    device->RSGetViewports(&old.ViewportsCount, old.Viewports);
+    device->RSGetState(&old.RS);
+    device->OMGetBlendState(&old.BlendState, old.BlendFactor, &old.SampleMask);
+    device->OMGetDepthStencilState(&old.DepthStencilState, &old.StencilRef);
+    device->PSGetShaderResources(0, 1, &old.PSShaderResource);
+    device->PSGetSamplers(0, 1, &old.PSSampler);
+    old.PSInstancesCount = old.VSInstancesCount = old.GSInstancesCount = 256;
+    device->PSGetShader(&old.PS, old.PSInstances, &old.PSInstancesCount);
+    device->VSGetShader(&old.VS, old.VSInstances, &old.VSInstancesCount);
+    device->VSGetConstantBuffers(0, 1, &old.VSConstantBuffer);
+    device->GSGetShader(&old.GS, old.GSInstances, &old.GSInstancesCount);
+
+    device->IAGetPrimitiveTopology(&old.PrimitiveTopology);
+    device->IAGetIndexBuffer(&old.IndexBuffer, &old.IndexBufferFormat, &old.IndexBufferOffset);
+    device->IAGetVertexBuffers(0, 1, &old.VertexBuffer, &old.VertexBufferStride, &old.VertexBufferOffset);
+    device->IAGetInputLayout(&old.InputLayout);
+
+    // Setup desired DX state
+    ImGui_ImplDX11_SetupRenderState(draw_data, device);
+
+    // Setup render state structure (for callbacks and custom texture bindings)
+    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+    ImGui_ImplDX11_RenderState render_state;
+    render_state.Device = bd->pd3dDevice;
+    render_state.DeviceContext = bd->pd3dDeviceContext;
+    render_state.SamplerLinear = bd->pTexSamplerLinear;
+    render_state.SamplerNearest = bd->pTexSamplerNearest;
+    render_state.VertexConstantBuffer = bd->pVertexConstantBuffer;
+    platform_io.Renderer_RenderState = &render_state;
+
+    // Render command lists
+    // (Because we merged all buffers into a single one, we maintain our own offset into them)
+    int global_idx_offset = 0;
+    int global_vtx_offset = 0;
+    ImVec2 clip_off = draw_data->DisplayPos;
+    ImVec2 clip_scale = draw_data->FramebufferScale;
+    for (const ImDrawList* draw_list : draw_data->CmdLists)
+    {
+        for (int cmd_i = 0; cmd_i < draw_list->CmdBuffer.Size; cmd_i++)
+        {
+            const ImDrawCmd* pcmd = &draw_list->CmdBuffer[cmd_i];
+            if (pcmd->UserCallback != nullptr)
+            {
+                // User callback, registered via ImDrawList::AddCallback()
+                // (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
+                if (pcmd->UserCallback == ImDrawCallback_ResetRenderState)
+                    ImGui_ImplDX11_SetupRenderState(draw_data, device);
+                else
+                    pcmd->UserCallback(draw_list, pcmd);
+            }
+            else
+            {
+                // Project scissor/clipping rectangles into framebuffer space
+                ImVec2 clip_min((pcmd->ClipRect.x - clip_off.x) * clip_scale.x, (pcmd->ClipRect.y - clip_off.y) * clip_scale.y);
+                ImVec2 clip_max((pcmd->ClipRect.z - clip_off.x) * clip_scale.x, (pcmd->ClipRect.w - clip_off.y) * clip_scale.y);
+                if (clip_max.x <= clip_min.x || clip_max.y <= clip_min.y)
+                    continue;
+
+                // Apply scissor/clipping rectangle
+                const D3D11_RECT r = { (LONG)clip_min.x, (LONG)clip_min.y, (LONG)clip_max.x, (LONG)clip_max.y };
+                device->RSSetScissorRects(1, &r);
+
+                // Bind texture, Draw
+                ID3D11ShaderResourceView* texture_srv = (ID3D11ShaderResourceView*)pcmd->GetTexID();
+                device->PSSetShaderResources(0, 1, &texture_srv);
+                device->DrawIndexed(pcmd->ElemCount, pcmd->IdxOffset + global_idx_offset, pcmd->VtxOffset + global_vtx_offset);
+            }
+        }
+        global_idx_offset += draw_list->IdxBuffer.Size;
+        global_vtx_offset += draw_list->VtxBuffer.Size;
+    }
+    platform_io.Renderer_RenderState = nullptr;
+
+    // Restore modified DX state
+    device->RSSetScissorRects(old.ScissorRectsCount, old.ScissorRects);
+    device->RSSetViewports(old.ViewportsCount, old.Viewports);
+    device->RSSetState(old.RS); if (old.RS) old.RS->Release();
+    device->OMSetBlendState(old.BlendState, old.BlendFactor, old.SampleMask); if (old.BlendState) old.BlendState->Release();
+    device->OMSetDepthStencilState(old.DepthStencilState, old.StencilRef); if (old.DepthStencilState) old.DepthStencilState->Release();
+    device->PSSetShaderResources(0, 1, &old.PSShaderResource); if (old.PSShaderResource) old.PSShaderResource->Release();
+    device->PSSetSamplers(0, 1, &old.PSSampler); if (old.PSSampler) old.PSSampler->Release();
+    device->PSSetShader(old.PS, old.PSInstances, old.PSInstancesCount); if (old.PS) old.PS->Release();
+    for (UINT i = 0; i < old.PSInstancesCount; i++) if (old.PSInstances[i]) old.PSInstances[i]->Release();
+    device->VSSetShader(old.VS, old.VSInstances, old.VSInstancesCount); if (old.VS) old.VS->Release();
+    device->VSSetConstantBuffers(0, 1, &old.VSConstantBuffer); if (old.VSConstantBuffer) old.VSConstantBuffer->Release();
+    device->GSSetShader(old.GS, old.GSInstances, old.GSInstancesCount); if (old.GS) old.GS->Release();
+    for (UINT i = 0; i < old.VSInstancesCount; i++) if (old.VSInstances[i]) old.VSInstances[i]->Release();
+    device->IASetPrimitiveTopology(old.PrimitiveTopology);
+    device->IASetIndexBuffer(old.IndexBuffer, old.IndexBufferFormat, old.IndexBufferOffset); if (old.IndexBuffer) old.IndexBuffer->Release();
+    device->IASetVertexBuffers(0, 1, &old.VertexBuffer, &old.VertexBufferStride, &old.VertexBufferOffset); if (old.VertexBuffer) old.VertexBuffer->Release();
+    device->IASetInputLayout(old.InputLayout); if (old.InputLayout) old.InputLayout->Release();
+}
+
+static void ImGui_ImplDX11_DestroyTexture(ImTextureData* tex)
+{
+    if (ImGui_ImplDX11_Texture* backend_tex = (ImGui_ImplDX11_Texture*)tex->BackendUserData)
+    {
+        IM_ASSERT(backend_tex->pTextureView == (ID3D11ShaderResourceView*)(intptr_t)tex->TexID);
+        backend_tex->pTextureView->Release();
+        backend_tex->pTexture->Release();
+        IM_DELETE(backend_tex);
+
+        // Clear identifiers and mark as destroyed (in order to allow e.g. calling InvalidateDeviceObjects while running)
+        tex->SetTexID(ImTextureID_Invalid);
+        tex->BackendUserData = nullptr;
+    }
+    tex->SetStatus(ImTextureStatus_Destroyed);
+}
+
+void ImGui_ImplDX11_UpdateTexture(ImTextureData* tex)
+{
+    ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
+    if (tex->Status == ImTextureStatus_WantCreate)
+    {
+        // Create and upload new texture to graphics system
+        //IMGUI_DEBUG_LOG("UpdateTexture #%03d: WantCreate %dx%d\n", tex->UniqueID, tex->Width, tex->Height);
+        IM_ASSERT(tex->TexID == ImTextureID_Invalid && tex->BackendUserData == nullptr);
+        IM_ASSERT(tex->Format == ImTextureFormat_RGBA32);
+        unsigned int* pixels = (unsigned int*)tex->GetPixels();
+        ImGui_ImplDX11_Texture* backend_tex = IM_NEW(ImGui_ImplDX11_Texture)();
+
+        // Create texture
+        D3D11_TEXTURE2D_DESC desc;
+        ZeroMemory(&desc, sizeof(desc));
+        desc.Width = (UINT)tex->Width;
+        desc.Height = (UINT)tex->Height;
+        desc.MipLevels = 1;
+        desc.ArraySize = 1;
+#ifdef IMGUI_USE_BGRA_PACKED_COLOR
+        desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+#else
+        desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+#endif
+        desc.SampleDesc.Count = 1;
+        desc.Usage = D3D11_USAGE_DEFAULT;
+        desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+        desc.CPUAccessFlags = 0;
+        D3D11_SUBRESOURCE_DATA subResource;
+        subResource.pSysMem = pixels;
+        subResource.SysMemPitch = desc.Width * 4;
+        subResource.SysMemSlicePitch = 0;
+        bd->pd3dDevice->CreateTexture2D(&desc, &subResource, &backend_tex->pTexture);
+        IM_ASSERT(backend_tex->pTexture != nullptr && "Backend failed to create texture!");
+
+        // Create texture view
+        D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
+        ZeroMemory(&srvDesc, sizeof(srvDesc));
+#ifdef IMGUI_USE_BGRA_PACKED_COLOR
+        srvDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+#else
+        srvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+#endif
+        srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
+        srvDesc.Texture2D.MipLevels = desc.MipLevels;
+        srvDesc.Texture2D.MostDetailedMip = 0;
+        bd->pd3dDevice->CreateShaderResourceView(backend_tex->pTexture, &srvDesc, &backend_tex->pTextureView);
+        IM_ASSERT(backend_tex->pTextureView != nullptr && "Backend failed to create texture!");
+
+        // Store identifiers
+        tex->SetTexID((ImTextureID)(intptr_t)backend_tex->pTextureView);
+        tex->SetStatus(ImTextureStatus_OK);
+        tex->BackendUserData = backend_tex;
+    }
+    else if (tex->Status == ImTextureStatus_WantUpdates)
+    {
+        // Update selected blocks. We only ever write to textures regions which have never been used before!
+        // This backend choose to use tex->Updates[] but you can use tex->UpdateRect to upload a single region.
+        ImGui_ImplDX11_Texture* backend_tex = (ImGui_ImplDX11_Texture*)tex->BackendUserData;
+        IM_ASSERT(backend_tex->pTextureView == (ID3D11ShaderResourceView*)(intptr_t)tex->TexID);
+        for (ImTextureRect& r : tex->Updates)
+        {
+            D3D11_BOX box = { (UINT)r.x, (UINT)r.y, (UINT)0, (UINT)(r.x + r.w), (UINT)(r.y + r .h), (UINT)1 };
+            bd->pd3dDeviceContext->UpdateSubresource(backend_tex->pTexture, 0, &box, tex->GetPixelsAt(r.x, r.y), (UINT)tex->GetPitch(), 0);
+        }
+        tex->SetStatus(ImTextureStatus_OK);
+    }
+    if (tex->Status == ImTextureStatus_WantDestroy && tex->UnusedFrames > 0)
+        ImGui_ImplDX11_DestroyTexture(tex);
+}
+
+bool    ImGui_ImplDX11_CreateDeviceObjects()
+{
+    ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
+    if (!bd->pd3dDevice)
+        return false;
+    ImGui_ImplDX11_InvalidateDeviceObjects();
+
+    // By using D3DCompile() from <d3dcompiler.h> / d3dcompiler.lib, we introduce a dependency to a given version of d3dcompiler_XX.dll (see D3DCOMPILER_DLL_A)
+    // If you would like to use this DX11 sample code but remove this dependency you can:
+    //  1) compile once, save the compiled shader blobs into a file or source code and pass them to CreateVertexShader()/CreatePixelShader() [preferred solution]
+    //  2) use code to detect any version of the DLL and grab a pointer to D3DCompile from the DLL.
+    // See https://github.com/ocornut/imgui/pull/638 for sources and details.
+
+    // Create the vertex shader
+    {
+        static const char* vertexShader =
+            "cbuffer vertexBuffer : register(b0) \
+            {\
+              float4x4 ProjectionMatrix; \
+            };\
+            struct VS_INPUT\
+            {\
+              float2 pos : POSITION;\
+              float4 col : COLOR0;\
+              float2 uv  : TEXCOORD0;\
+            };\
+            \
+            struct PS_INPUT\
+            {\
+              float4 pos : SV_POSITION;\
+              float4 col : COLOR0;\
+              float2 uv  : TEXCOORD0;\
+            };\
+            \
+            PS_INPUT main(VS_INPUT input)\
+            {\
+              PS_INPUT output;\
+              output.pos = mul( ProjectionMatrix, float4(input.pos.xy, 0.f, 1.f));\
+              output.col = input.col;\
+              output.uv  = input.uv;\
+              return output;\
+            }";
+
+        ID3DBlob* vertexShaderBlob;
+        if (FAILED(D3DCompile(vertexShader, strlen(vertexShader), nullptr, nullptr, nullptr, "main", "vs_4_0", 0, 0, &vertexShaderBlob, nullptr)))
+            return false; // NB: Pass ID3DBlob* pErrorBlob to D3DCompile() to get error showing in (const char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
+        if (bd->pd3dDevice->CreateVertexShader(vertexShaderBlob->GetBufferPointer(), vertexShaderBlob->GetBufferSize(), nullptr, &bd->pVertexShader) != S_OK)
+        {
+            vertexShaderBlob->Release();
+            return false;
+        }
+
+        // Create the input layout
+        D3D11_INPUT_ELEMENT_DESC local_layout[] =
+        {
+            { "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT,   0, (UINT)offsetof(ImDrawVert, pos), D3D11_INPUT_PER_VERTEX_DATA, 0 },
+            { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT,   0, (UINT)offsetof(ImDrawVert, uv),  D3D11_INPUT_PER_VERTEX_DATA, 0 },
+#ifdef IMGUI_USE_BGRA_PACKED_COLOR
+            { "COLOR",    0, DXGI_FORMAT_B8G8R8A8_UNORM, 0, (UINT)offsetof(ImDrawVert, col), D3D11_INPUT_PER_VERTEX_DATA, 0 },
+#else
+            { "COLOR",    0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, (UINT)offsetof(ImDrawVert, col), D3D11_INPUT_PER_VERTEX_DATA, 0 },
+#endif
+        };
+        if (bd->pd3dDevice->CreateInputLayout(local_layout, 3, vertexShaderBlob->GetBufferPointer(), vertexShaderBlob->GetBufferSize(), &bd->pInputLayout) != S_OK)
+        {
+            vertexShaderBlob->Release();
+            return false;
+        }
+        vertexShaderBlob->Release();
+
+        // Create the constant buffer
+        {
+            D3D11_BUFFER_DESC desc = {};
+            desc.ByteWidth = sizeof(VERTEX_CONSTANT_BUFFER_DX11);
+            desc.Usage = D3D11_USAGE_DYNAMIC;
+            desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+            desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+            desc.MiscFlags = 0;
+            bd->pd3dDevice->CreateBuffer(&desc, nullptr, &bd->pVertexConstantBuffer);
+        }
+    }
+
+    // Create the pixel shader
+    {
+        static const char* pixelShader =
+            "struct PS_INPUT\
+            {\
+            float4 pos : SV_POSITION;\
+            float4 col : COLOR0;\
+            float2 uv  : TEXCOORD0;\
+            };\
+            sampler sampler0;\
+            Texture2D texture0;\
+            \
+            float4 main(PS_INPUT input) : SV_Target\
+            {\
+            float4 out_col = input.col * texture0.Sample(sampler0, input.uv); \
+            return out_col; \
+            }";
+
+        ID3DBlob* pixelShaderBlob;
+        if (FAILED(D3DCompile(pixelShader, strlen(pixelShader), nullptr, nullptr, nullptr, "main", "ps_4_0", 0, 0, &pixelShaderBlob, nullptr)))
+            return false; // NB: Pass ID3DBlob* pErrorBlob to D3DCompile() to get error showing in (const char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
+        if (bd->pd3dDevice->CreatePixelShader(pixelShaderBlob->GetBufferPointer(), pixelShaderBlob->GetBufferSize(), nullptr, &bd->pPixelShader) != S_OK)
+        {
+            pixelShaderBlob->Release();
+            return false;
+        }
+        pixelShaderBlob->Release();
+    }
+
+    // Create the blending setup
+    {
+        D3D11_BLEND_DESC desc;
+        ZeroMemory(&desc, sizeof(desc));
+        desc.AlphaToCoverageEnable = false;
+        desc.RenderTarget[0].BlendEnable = true;
+        desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
+        desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
+        desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
+        desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
+        desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
+        desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
+        desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
+        bd->pd3dDevice->CreateBlendState(&desc, &bd->pBlendState);
+    }
+
+    // Create the rasterizer state
+    {
+        D3D11_RASTERIZER_DESC desc;
+        ZeroMemory(&desc, sizeof(desc));
+        desc.FillMode = D3D11_FILL_SOLID;
+        desc.CullMode = D3D11_CULL_NONE;
+        desc.ScissorEnable = true;
+        desc.DepthClipEnable = true;
+        bd->pd3dDevice->CreateRasterizerState(&desc, &bd->pRasterizerState);
+    }
+
+    // Create depth-stencil State
+    {
+        D3D11_DEPTH_STENCIL_DESC desc;
+        ZeroMemory(&desc, sizeof(desc));
+        desc.DepthEnable = false;
+        desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
+        desc.DepthFunc = D3D11_COMPARISON_ALWAYS;
+        desc.StencilEnable = false;
+        desc.FrontFace.StencilFailOp = desc.FrontFace.StencilDepthFailOp = desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
+        desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
+        desc.BackFace = desc.FrontFace;
+        bd->pd3dDevice->CreateDepthStencilState(&desc, &bd->pDepthStencilState);
+    }
+
+    // Create texture sampler
+    // (Bilinear sampling is required by default. Set 'io.Fonts->Flags |= ImFontAtlasFlags_NoBakedLines' or 'style.AntiAliasedLinesUseTex = false' to allow point/nearest sampling)
+    {
+        D3D11_SAMPLER_DESC desc;
+        ZeroMemory(&desc, sizeof(desc));
+        desc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
+        desc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
+        desc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
+        desc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
+        desc.MipLODBias = 0.f;
+        desc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
+        desc.MinLOD = 0.f;
+        desc.MaxLOD = 0.f;
+        bd->pd3dDevice->CreateSamplerState(&desc, &bd->pTexSamplerLinear);
+        desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
+        bd->pd3dDevice->CreateSamplerState(&desc, &bd->pTexSamplerNearest);
+    }
+
+    return true;
+}
+
+void    ImGui_ImplDX11_InvalidateDeviceObjects()
+{
+    ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
+    if (!bd->pd3dDevice)
+        return;
+
+    // Destroy all textures
+    for (ImTextureData* tex : ImGui::GetPlatformIO().Textures)
+        if (tex->RefCount == 1)
+            ImGui_ImplDX11_DestroyTexture(tex);
+
+    if (bd->pTexSamplerLinear)      { bd->pTexSamplerLinear->Release(); bd->pTexSamplerLinear = nullptr; }
+    if (bd->pTexSamplerNearest)     { bd->pTexSamplerNearest->Release(); bd->pTexSamplerNearest = nullptr; }
+    if (bd->pIB)                    { bd->pIB->Release(); bd->pIB = nullptr; }
+    if (bd->pVB)                    { bd->pVB->Release(); bd->pVB = nullptr; }
+    if (bd->pBlendState)            { bd->pBlendState->Release(); bd->pBlendState = nullptr; }
+    if (bd->pDepthStencilState)     { bd->pDepthStencilState->Release(); bd->pDepthStencilState = nullptr; }
+    if (bd->pRasterizerState)       { bd->pRasterizerState->Release(); bd->pRasterizerState = nullptr; }
+    if (bd->pPixelShader)           { bd->pPixelShader->Release(); bd->pPixelShader = nullptr; }
+    if (bd->pVertexConstantBuffer)  { bd->pVertexConstantBuffer->Release(); bd->pVertexConstantBuffer = nullptr; }
+    if (bd->pInputLayout)           { bd->pInputLayout->Release(); bd->pInputLayout = nullptr; }
+    if (bd->pVertexShader)          { bd->pVertexShader->Release(); bd->pVertexShader = nullptr; }
+}
+
+bool    ImGui_ImplDX11_Init(ID3D11Device* device, ID3D11DeviceContext* device_context)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    IMGUI_CHECKVERSION();
+    IM_ASSERT(io.BackendRendererUserData == nullptr && "Already initialized a renderer backend!");
+
+    // Setup backend capabilities flags
+    ImGui_ImplDX11_Data* bd = IM_NEW(ImGui_ImplDX11_Data)();
+    io.BackendRendererUserData = (void*)bd;
+    io.BackendRendererName = "imgui_impl_dx11";
+    io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset;  // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
+    io.BackendFlags |= ImGuiBackendFlags_RendererHasTextures;   // We can honor ImGuiPlatformIO::Textures[] requests during render.
+
+    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+    platform_io.Renderer_TextureMaxWidth = platform_io.Renderer_TextureMaxHeight = D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION;
+
+    // Get factory from device
+    IDXGIDevice* pDXGIDevice = nullptr;
+    IDXGIAdapter* pDXGIAdapter = nullptr;
+    IDXGIFactory* pFactory = nullptr;
+
+    if (device->QueryInterface(IID_PPV_ARGS(&pDXGIDevice)) == S_OK)
+        if (pDXGIDevice->GetParent(IID_PPV_ARGS(&pDXGIAdapter)) == S_OK)
+            if (pDXGIAdapter->GetParent(IID_PPV_ARGS(&pFactory)) == S_OK)
+            {
+                bd->pd3dDevice = device;
+                bd->pd3dDeviceContext = device_context;
+                bd->pFactory = pFactory;
+            }
+    if (pDXGIDevice) pDXGIDevice->Release();
+    if (pDXGIAdapter) pDXGIAdapter->Release();
+    bd->pd3dDevice->AddRef();
+    bd->pd3dDeviceContext->AddRef();
+
+    return true;
+}
+
+void ImGui_ImplDX11_Shutdown()
+{
+    ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
+    IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?");
+    ImGuiIO& io = ImGui::GetIO();
+    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+
+    ImGui_ImplDX11_InvalidateDeviceObjects();
+    if (bd->pFactory)             { bd->pFactory->Release(); }
+    if (bd->pd3dDevice)           { bd->pd3dDevice->Release(); }
+    if (bd->pd3dDeviceContext)    { bd->pd3dDeviceContext->Release(); }
+
+    io.BackendRendererName = nullptr;
+    io.BackendRendererUserData = nullptr;
+    io.BackendFlags &= ~(ImGuiBackendFlags_RendererHasVtxOffset | ImGuiBackendFlags_RendererHasTextures);
+    platform_io.ClearRendererHandlers();
+    IM_DELETE(bd);
+}
+
+void ImGui_ImplDX11_NewFrame()
+{
+    ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
+    IM_ASSERT(bd != nullptr && "Context or backend not initialized! Did you call ImGui_ImplDX11_Init()?");
+
+    if (!bd->pVertexShader)
+        if (!ImGui_ImplDX11_CreateDeviceObjects())
+            IM_ASSERT(0 && "ImGui_ImplDX11_CreateDeviceObjects() failed!");
+}
+
+//-----------------------------------------------------------------------------
+
+#endif // #ifndef IMGUI_DISABLE
@@ -0,0 +1,52 @@
+// dear imgui: Renderer Backend for DirectX11
+// This needs to be used along with a Platform Backend (e.g. Win32)
+
+// Implemented features:
+//  [X] Renderer: User texture binding. Use 'ID3D11ShaderResourceView*' as texture identifier. Read the FAQ about ImTextureID/ImTextureRef!
+//  [X] Renderer: Large meshes support (64k+ vertices) even with 16-bit indices (ImGuiBackendFlags_RendererHasVtxOffset).
+//  [X] Renderer: Texture updates support for dynamic font atlas (ImGuiBackendFlags_RendererHasTextures).
+//  [X] Renderer: Expose selected render state for draw callbacks to use. Access in '(ImGui_ImplXXXX_RenderState*)GetPlatformIO().Renderer_RenderState'.
+
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
+// - Introduction, links and more at the top of imgui.cpp
+
+#pragma once
+#include "imgui.h"      // IMGUI_IMPL_API
+#ifndef IMGUI_DISABLE
+
+struct ID3D11Device;
+struct ID3D11DeviceContext;
+struct ID3D11SamplerState;
+struct ID3D11Buffer;
+
+// Follow "Getting Started" link and check examples/ folder to learn about using backends!
+IMGUI_IMPL_API bool     ImGui_ImplDX11_Init(ID3D11Device* device, ID3D11DeviceContext* device_context);
+IMGUI_IMPL_API void     ImGui_ImplDX11_Shutdown();
+IMGUI_IMPL_API void     ImGui_ImplDX11_NewFrame();
+IMGUI_IMPL_API void     ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data);
+
+// Use if you want to reset your rendering device without losing Dear ImGui state.
+IMGUI_IMPL_API bool     ImGui_ImplDX11_CreateDeviceObjects();
+IMGUI_IMPL_API void     ImGui_ImplDX11_InvalidateDeviceObjects();
+
+// (Advanced) Use e.g. if you need to precisely control the timing of texture updates (e.g. for staged rendering), by setting ImDrawData::Textures = nullptr to handle this manually.
+IMGUI_IMPL_API void     ImGui_ImplDX11_UpdateTexture(ImTextureData* tex);
+
+// [BETA] Selected render state data shared with callbacks.
+// This is temporarily stored in GetPlatformIO().Renderer_RenderState during the ImGui_ImplDX11_RenderDrawData() call.
+// (Please open an issue if you feel you need access to more data)
+struct ImGui_ImplDX11_RenderState
+{
+    ID3D11Device*           Device;
+    ID3D11DeviceContext*    DeviceContext;
+    ID3D11SamplerState*     SamplerLinear;
+    ID3D11SamplerState*     SamplerNearest;
+    ID3D11Buffer*           VertexConstantBuffer;
+};
+
+#endif // #ifndef IMGUI_DISABLE
@@ -1,16 +1,37 @@
-// dear imgui: Renderer for DirectX9
-// This needs to be used along with a Platform Binding (e.g. Win32)
+// dear imgui: Renderer Backend for DirectX9
+// This needs to be used along with a Platform Backend (e.g. Win32)

 // Implemented features:
-//  [X] Renderer: User texture binding. Use 'LPDIRECT3DTEXTURE9' as ImTextureID. Read the FAQ about ImTextureID in imgui.cpp.
-//  [X] Renderer: Support for large meshes (64k+ vertices) with 16-bits indices.
+//  [X] Renderer: User texture binding. Use 'LPDIRECT3DTEXTURE9' as texture identifier. Read the FAQ about ImTextureID/ImTextureRef!
+//  [X] Renderer: Large meshes support (64k+ vertices) even with 16-bit indices (ImGuiBackendFlags_RendererHasVtxOffset).
+//  [X] Renderer: Texture updates support for dynamic font atlas (ImGuiBackendFlags_RendererHasTextures).
+//  [X] Renderer: IMGUI_USE_BGRA_PACKED_COLOR support, as this is the optimal color encoding for DirectX9.
+//  [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.

-// You can copy and use unmodified imgui_impl_* files in your project. See main.cpp for an example of using this.
-// If you are new to dear imgui, read examples/README.txt and read the documentation at the top of imgui.cpp.
-// https://github.com/ocornut/imgui
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
+// - Introduction, links and more at the top of imgui.cpp

 // CHANGELOG
 // (minor and older changes stripped away, please see git history for details)
+//  2026-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
+//  2026-03-19: Fixed issue in ImGui_ImplDX9_UpdateTexture() if ImTextureID_Invalid is defined to be != 0, which became the default since 2026-03-12. (#9295, #9310)
+//  2025-09-18: Call platform_io.ClearRendererHandlers() on shutdown.
+//  2025-06-11: DirectX9: Added support for ImGuiBackendFlags_RendererHasTextures, for dynamic font atlas.
+//  2024-10-07: DirectX9: Changed default texture sampler to Clamp instead of Repeat/Wrap.
+//  2024-02-12: DirectX9: Using RGBA format when supported by the driver to avoid CPU side conversion. (#6575)
+//  2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
+//  2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
+//  2021-06-25: DirectX9: Explicitly disable texture state stages after >= 1.
+//  2021-05-19: DirectX9: Replaced direct access to ImDrawCmd::TextureId with a call to ImDrawCmd::GetTexID(). (will become a requirement)
+//  2021-04-23: DirectX9: Explicitly setting up more graphics states to increase compatibility with unusual non-default states.
+//  2021-03-18: DirectX9: Calling IDirect3DStateBlock9::Capture() after CreateStateBlock() as a workaround for state restoring issues (see #3857).
+//  2021-03-03: DirectX9: Added support for IMGUI_USE_BGRA_PACKED_COLOR in user's imconfig file.
+//  2021-02-18: DirectX9: Change blending equation to preserve alpha in output buffer.
 //  2019-05-29: DirectX9: Added support for large mesh (64K+ vertices), enable ImGuiBackendFlags_RendererHasVtxOffset flag.
 //  2019-04-30: DirectX9: Added support for special ImDrawCallback_ResetRenderState callback to reset render state.
 //  2019-03-29: Misc: Fixed erroneous assert in ImGui_ImplDX9_InvalidateDeviceObjects().
@@ -22,160 +43,154 @@
 //  2018-02-16: Misc: Obsoleted the io.RenderDrawListsFn callback and exposed ImGui_ImplDX9_RenderDrawData() in the .h file so you can call it yourself.
 //  2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.

-#include "imgui_impl_dx9.h"
-
 #include <algorithm>
-
-// DirectX
-#include <d3d9.h>
-
 #include "imgui.h"
+#ifndef IMGUI_DISABLE
+#include "imgui_impl_dx9.h"

 // allow std::min use
 #ifdef min
 #undef min
 #endif

-// DirectX data
-static LPDIRECT3DDEVICE9 g_pd3dDevice = NULL;
-static LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL;
-static LPDIRECT3DINDEXBUFFER9 g_pIB = NULL;
-static LPDIRECT3DTEXTURE9 g_FontTexture = NULL;
-static int g_VertexBufferSize = 5000, g_IndexBufferSize = 10000;
+// DirectX
+#include <d3d9.h>

+// Clang/GCC warnings with -Weverything
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wold-style-cast"         // warning: use of old-style cast                            // yes, they are more terse.
+#pragma clang diagnostic ignored "-Wsign-conversion"        // warning: implicit conversion changes signedness
+#endif
+
+// DirectX data
+struct ImGui_ImplDX9_Data
+{
+    LPDIRECT3DDEVICE9           pd3dDevice;
+    LPDIRECT3DVERTEXBUFFER9     pVB;
+    LPDIRECT3DINDEXBUFFER9      pIB;
+    int                         VertexBufferSize;
+    int                         IndexBufferSize;
+    bool                        HasRgbaSupport;
+
+    ImGui_ImplDX9_Data()        { memset((void*)this, 0, sizeof(*this)); VertexBufferSize = 5000; IndexBufferSize = 10000; }
+};
+
+struct CUSTOMVERTEX
+{
+    float    pos[3];
+    D3DCOLOR col;
+    float    uv[2];
+};
 #define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1)

-// Render function.
-// (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop)
-void ImGui_ImplDX9_RenderDrawData(ImDrawData *draw_data) {
+#ifdef IMGUI_USE_BGRA_PACKED_COLOR
+#define IMGUI_COL_TO_DX9_ARGB(_COL)     (_COL)
+#else
+#define IMGUI_COL_TO_DX9_ARGB(_COL)     (((_COL) & 0xFF00FF00) | (((_COL) & 0xFF0000) >> 16) | (((_COL) & 0xFF) << 16))
+#endif

-    // Avoid rendering when minimized
-    if (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f)
-        return;
+// Backend data stored in io.BackendRendererUserData to allow support for multiple Dear ImGui contexts
+// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
+static ImGui_ImplDX9_Data* ImGui_ImplDX9_GetBackendData()
+{
+    return ImGui::GetCurrentContext() ? (ImGui_ImplDX9_Data*)ImGui::GetIO().BackendRendererUserData : nullptr;
+}

-    // Create and grow buffers if needed
-    if (!g_pVB || g_VertexBufferSize < draw_data->TotalVtxCount) {
-        if (g_pVB) {
-            g_pVB->Release();
-            g_pVB = NULL;
-        }
-        g_VertexBufferSize = draw_data->TotalVtxCount + 5000;
-        if (g_pd3dDevice->CreateVertexBuffer(g_VertexBufferSize * sizeof(ImDrawVert),
-                                             D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_CUSTOMVERTEX,
-                                             D3DPOOL_DEFAULT, &g_pVB, NULL) < 0)
-            return;
-    }
-    if (!g_pIB || g_IndexBufferSize < draw_data->TotalIdxCount) {
-        if (g_pIB) {
-            g_pIB->Release();
-            g_pIB = NULL;
-        }
-        g_IndexBufferSize = draw_data->TotalIdxCount + 10000;
-        if (g_pd3dDevice->CreateIndexBuffer(g_IndexBufferSize * sizeof(ImDrawIdx),
-                                            D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY,
-                                            sizeof(ImDrawIdx) == 2 ? D3DFMT_INDEX16 : D3DFMT_INDEX32,
-                                            D3DPOOL_DEFAULT, &g_pIB, NULL) < 0)
-            return;
-    }
+// Forward Declarations
+static void ImGui_ImplDX9_InitMultiViewportSupport();
+static void ImGui_ImplDX9_ShutdownMultiViewportSupport();
+static void ImGui_ImplDX9_CreateDeviceObjectsForPlatformWindows();
+static void ImGui_ImplDX9_InvalidateDeviceObjectsForPlatformWindows();

-    // Backup the DX9 state
-    IDirect3DStateBlock9 *d3d9_state_block = NULL;
-    if (g_pd3dDevice->CreateStateBlock(D3DSBT_ALL, &d3d9_state_block) < 0)
-        return;
+struct render_state_t {
+    IDirect3DSurface9 *back_buffer;
+    IDirect3DSurface9 *depth_stencil;
+    IDirect3DSurface9 *render_targets[8];
+    D3DCAPS9 caps;
+};

-    // Backup the DX9 transform (DX9 documentation suggests that it is included in the StateBlock but it doesn't appear to)
-    D3DMATRIX last_world, last_view, last_projection;
-    g_pd3dDevice->GetTransform(D3DTS_WORLD, &last_world);
-    g_pd3dDevice->GetTransform(D3DTS_VIEW, &last_view);
-    g_pd3dDevice->GetTransform(D3DTS_PROJECTION, &last_projection);
-
-    // Copy all vertices into a single contiguous buffer
-    ImDrawVert *vtx_dst;
-    ImDrawIdx *idx_dst;
-    if (g_pVB->Lock(0, (UINT) (draw_data->TotalVtxCount * sizeof(ImDrawVert)), (void **) &vtx_dst,
-                    D3DLOCK_DISCARD) < 0)
-        return;
-    if (g_pIB->Lock(0, (UINT) (draw_data->TotalIdxCount * sizeof(ImDrawIdx)), (void **) &idx_dst,
-                    D3DLOCK_DISCARD) < 0)
-        return;
-    for (int n = 0; n < draw_data->CmdListsCount; n++) {
-        const ImDrawList *cmd_list = draw_data->CmdLists[n];
-        memcpy(vtx_dst, cmd_list->VtxBuffer.Data, cmd_list->VtxBuffer.Size * sizeof(ImDrawVert));
-        memcpy(idx_dst, cmd_list->IdxBuffer.Data, cmd_list->IdxBuffer.Size * sizeof(ImDrawIdx));
-        vtx_dst += cmd_list->VtxBuffer.Size;
-        idx_dst += cmd_list->IdxBuffer.Size;
-    }
-    g_pVB->Unlock();
-    g_pIB->Unlock();
-    g_pd3dDevice->SetStreamSource(0, g_pVB, 0, sizeof(ImDrawVert));
-    g_pd3dDevice->SetIndices(g_pIB);
-    g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
+// Functions
+static void ImGui_ImplDX9_SetupRenderState(ImDrawData* draw_data, struct render_state_t *render_state)
+{
+    ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();

    // Setup viewport
    D3DVIEWPORT9 vp;
    vp.X = vp.Y = 0;
-    vp.Width = (DWORD) draw_data->DisplaySize.x;
-    vp.Height = (DWORD) draw_data->DisplaySize.y;
+    vp.Width = (DWORD)draw_data->DisplaySize.x;
+    vp.Height = (DWORD)draw_data->DisplaySize.y;
    vp.MinZ = 0.0f;
    vp.MaxZ = 1.0f;
-    g_pd3dDevice->SetViewport(&vp);

-    g_pd3dDevice->SetPixelShader(nullptr);
-    g_pd3dDevice->SetVertexShader(nullptr);
+    LPDIRECT3DDEVICE9 device = bd->pd3dDevice;
+    device->SetViewport(&vp);

-    D3DCAPS9 caps {};
-    if (FAILED(g_pd3dDevice->GetDeviceCaps(&caps))) {
-        caps.NumSimultaneousRTs = 0UL;
-    }
+    // spice ldj
+    {
+        if (FAILED(device->GetDeviceCaps(&render_state->caps))) {
+            render_state->caps.NumSimultaneousRTs = 0UL;
+        }

-    IDirect3DSurface9 *back_buffer = nullptr;
-    IDirect3DSurface9 *depth_stencil = nullptr;
-    IDirect3DSurface9 *render_targets[8];
+        // save all previous render target state
+        for (size_t target = 0; target < std::min(8UL, render_state->caps.NumSimultaneousRTs); target++) {
+            if (FAILED(device->GetRenderTarget(target, &render_state->render_targets[target]))) {
+                render_state->render_targets[target] = nullptr;
+            }
+        }

-    // save all previous render target state
-    for (size_t target = 0; target < std::min(8UL, caps.NumSimultaneousRTs); target++) {
-        if (FAILED(g_pd3dDevice->GetRenderTarget(target, &render_targets[target]))) {
-            render_targets[target] = nullptr;
+        // get the previous depth stencil
+        if (FAILED(device->GetDepthStencilSurface(&render_state->depth_stencil))) {
+            render_state->depth_stencil = nullptr;
+        }
+
+        // set the back buffer as the current render target
+        if (SUCCEEDED(device->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &render_state->back_buffer))) {
+            device->SetRenderTarget(0, render_state->back_buffer);
+            device->SetDepthStencilSurface(nullptr);
+
+            for (size_t target = 1; target < std::min(8UL, render_state->caps.NumSimultaneousRTs); target++) {
+                device->SetRenderTarget(target, nullptr);
+            }
+        } else {
+            render_state->back_buffer = nullptr;
        }
    }

-    // get the previous depth stencil
-    if (FAILED(g_pd3dDevice->GetDepthStencilSurface(&depth_stencil))) {
-        depth_stencil = nullptr;
-    }
-
-    // set the back buffer as the current render target
-    if (SUCCEEDED(g_pd3dDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &back_buffer))) {
-        g_pd3dDevice->SetRenderTarget(0, back_buffer);
-        g_pd3dDevice->SetDepthStencilSurface(nullptr);
-
-        for (size_t target = 1; target < std::min(8UL, caps.NumSimultaneousRTs); target++) {
-            g_pd3dDevice->SetRenderTarget(target, nullptr);
-        }
-    } else {
-        back_buffer = nullptr;
-    }
-
-    // Setup render state: fixed-pipeline, alpha-blending, no face culling, no depth testing, shade mode (for gradient)
-    g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
-    g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, false);
-    g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, false);
-    g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
-    g_pd3dDevice->SetRenderState(D3DRS_ALPHATESTENABLE, false);
-    g_pd3dDevice->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
-    g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
-    g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
-    g_pd3dDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, true);
-    g_pd3dDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
-    g_pd3dDevice->SetRenderState(D3DRS_FOGENABLE, false);
-    g_pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
-    g_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
-    g_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
-    g_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
-    g_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
-    g_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
-    g_pd3dDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
-    g_pd3dDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
+    // Setup render state: fixed-pipeline, alpha-blending, no face culling, no depth testing, shade mode (for gradient), bilinear sampling.
+    device->SetPixelShader(nullptr);
+    device->SetVertexShader(nullptr);
+    device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
+    device->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
+    device->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
+    device->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
+    device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
+    device->SetRenderState(D3DRS_ZENABLE, FALSE);
+    device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
+    device->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
+    device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
+    device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
+    device->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE);
+    device->SetRenderState(D3DRS_SRCBLENDALPHA, D3DBLEND_ONE);
+    device->SetRenderState(D3DRS_DESTBLENDALPHA, D3DBLEND_INVSRCALPHA);
+    device->SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE);
+    device->SetRenderState(D3DRS_FOGENABLE, FALSE);
+    device->SetRenderState(D3DRS_RANGEFOGENABLE, FALSE);
+    device->SetRenderState(D3DRS_SPECULARENABLE, FALSE);
+    device->SetRenderState(D3DRS_STENCILENABLE, FALSE);
+    device->SetRenderState(D3DRS_CLIPPING, TRUE);
+    device->SetRenderState(D3DRS_LIGHTING, FALSE);
+    device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
+    device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
+    device->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
+    device->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
+    device->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
+    device->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
+    device->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
+    device->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
+    device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
+    device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
+    device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
+    device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);

    // Setup orthographic projection matrix
    // Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayPos is (0,0) for single viewport apps.
@@ -185,176 +200,537 @@ void ImGui_ImplDX9_RenderDrawData(ImDrawData *draw_data) {
        float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x + 0.5f;
        float T = draw_data->DisplayPos.y + 0.5f;
        float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y + 0.5f;
-        D3DMATRIX mat_identity = {{{1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}}};
+        D3DMATRIX mat_identity = { { { 1.0f, 0.0f, 0.0f, 0.0f,  0.0f, 1.0f, 0.0f, 0.0f,  0.0f, 0.0f, 1.0f, 0.0f,  0.0f, 0.0f, 0.0f, 1.0f } } };
        D3DMATRIX mat_projection =
-                {{{
-                          2.0f / (R - L), 0.0f, 0.0f, 0.0f,
-                          0.0f, 2.0f / (T - B), 0.0f, 0.0f,
-                          0.0f, 0.0f, 0.5f, 0.0f,
-                          (L + R) / (L - R), (T + B) / (B - T), 0.5f, 1.0f
-                  }}};
-        g_pd3dDevice->SetTransform(D3DTS_WORLD, &mat_identity);
-        g_pd3dDevice->SetTransform(D3DTS_VIEW, &mat_identity);
-        g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &mat_projection);
+        { { {
+            2.0f/(R-L),   0.0f,         0.0f,  0.0f,
+            0.0f,         2.0f/(T-B),   0.0f,  0.0f,
+            0.0f,         0.0f,         0.5f,  0.0f,
+            (L+R)/(L-R),  (T+B)/(B-T),  0.5f,  1.0f
+        } } };
+        device->SetTransform(D3DTS_WORLD, &mat_identity);
+        device->SetTransform(D3DTS_VIEW, &mat_identity);
+        device->SetTransform(D3DTS_PROJECTION, &mat_projection);
    }
+}
+
+// Render function.
+void ImGui_ImplDX9_RenderDrawData(ImDrawData* draw_data)
+{
+    // Avoid rendering when minimized
+    if (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f)
+        return;
+
+    ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();
+    LPDIRECT3DDEVICE9 device = bd->pd3dDevice;
+
+    // Catch up with texture updates. Most of the times, the list will have 1 element with an OK status, aka nothing to do.
+    // (This almost always points to ImGui::GetPlatformIO().Textures[] but is part of ImDrawData to allow overriding or disabling texture updates).
+    if (draw_data->Textures != nullptr)
+        for (ImTextureData* tex : *draw_data->Textures)
+            if (tex->Status != ImTextureStatus_OK)
+                ImGui_ImplDX9_UpdateTexture(tex);
+
+    // Create and grow buffers if needed
+    if (!bd->pVB || bd->VertexBufferSize < draw_data->TotalVtxCount)
+    {
+        if (bd->pVB) { bd->pVB->Release(); bd->pVB = nullptr; }
+        bd->VertexBufferSize = draw_data->TotalVtxCount + 5000;
+        if (device->CreateVertexBuffer(bd->VertexBufferSize * sizeof(CUSTOMVERTEX), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &bd->pVB, nullptr) < 0)
+            return;
+    }
+    if (!bd->pIB || bd->IndexBufferSize < draw_data->TotalIdxCount)
+    {
+        if (bd->pIB) { bd->pIB->Release(); bd->pIB = nullptr; }
+        bd->IndexBufferSize = draw_data->TotalIdxCount + 10000;
+        if (device->CreateIndexBuffer(bd->IndexBufferSize * sizeof(ImDrawIdx), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, sizeof(ImDrawIdx) == 2 ? D3DFMT_INDEX16 : D3DFMT_INDEX32, D3DPOOL_DEFAULT, &bd->pIB, nullptr) < 0)
+            return;
+    }
+
+    // Backup the DX9 state
+    IDirect3DStateBlock9* state_block = nullptr;
+    if (device->CreateStateBlock(D3DSBT_ALL, &state_block) < 0)
+        return;
+    if (state_block->Capture() < 0)
+    {
+        state_block->Release();
+        return;
+    }
+
+    // Backup the DX9 transform (DX9 documentation suggests that it is included in the StateBlock but it doesn't appear to)
+    D3DMATRIX last_world, last_view, last_projection;
+    device->GetTransform(D3DTS_WORLD, &last_world);
+    device->GetTransform(D3DTS_VIEW, &last_view);
+    device->GetTransform(D3DTS_PROJECTION, &last_projection);
+
+    // Allocate buffers
+    CUSTOMVERTEX* vtx_dst;
+    ImDrawIdx* idx_dst;
+    if (bd->pVB->Lock(0, (UINT)(draw_data->TotalVtxCount * sizeof(CUSTOMVERTEX)), (void**)&vtx_dst, D3DLOCK_DISCARD) < 0)
+    {
+        state_block->Release();
+        return;
+    }
+    if (bd->pIB->Lock(0, (UINT)(draw_data->TotalIdxCount * sizeof(ImDrawIdx)), (void**)&idx_dst, D3DLOCK_DISCARD) < 0)
+    {
+        bd->pVB->Unlock();
+        state_block->Release();
+        return;
+    }
+
+    // Copy and convert all vertices into a single contiguous buffer, convert colors to DX9 default format.
+    // FIXME-OPT: This is a minor waste of resource, the ideal is to use imconfig.h and
+    //  1) to avoid repacking colors:   #define IMGUI_USE_BGRA_PACKED_COLOR
+    //  2) to avoid repacking vertices: #define IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT struct ImDrawVert { ImVec2 pos; float z; ImU32 col; ImVec2 uv; }
+    for (const ImDrawList* draw_list : draw_data->CmdLists)
+    {
+        const ImDrawVert* vtx_src = draw_list->VtxBuffer.Data;
+        for (int i = 0; i < draw_list->VtxBuffer.Size; i++)
+        {
+            vtx_dst->pos[0] = vtx_src->pos.x;
+            vtx_dst->pos[1] = vtx_src->pos.y;
+            vtx_dst->pos[2] = 0.0f;
+            vtx_dst->col = IMGUI_COL_TO_DX9_ARGB(vtx_src->col);
+            vtx_dst->uv[0] = vtx_src->uv.x;
+            vtx_dst->uv[1] = vtx_src->uv.y;
+            vtx_dst++;
+            vtx_src++;
+        }
+        memcpy(idx_dst, draw_list->IdxBuffer.Data, draw_list->IdxBuffer.Size * sizeof(ImDrawIdx));
+        idx_dst += draw_list->IdxBuffer.Size;
+    }
+    bd->pVB->Unlock();
+    bd->pIB->Unlock();
+    device->SetStreamSource(0, bd->pVB, 0, sizeof(CUSTOMVERTEX));
+    device->SetIndices(bd->pIB);
+    device->SetFVF(D3DFVF_CUSTOMVERTEX);
+
+    // Setup desired DX state
+    struct render_state_t render_state = {};
+    ImGui_ImplDX9_SetupRenderState(draw_data, &render_state);

    // Render command lists
    // (Because we merged all buffers into a single one, we maintain our own offset into them)
    int global_vtx_offset = 0;
    int global_idx_offset = 0;
    ImVec2 clip_off = draw_data->DisplayPos;
-    for (int n = 0; n < draw_data->CmdListsCount; n++) {
-        const ImDrawList *cmd_list = draw_data->CmdLists[n];
-        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++) {
-            const ImDrawCmd *pcmd = &cmd_list->CmdBuffer[cmd_i];
-            if (pcmd->UserCallback != NULL) {
-                pcmd->UserCallback(cmd_list, pcmd);
-            } else {
-                const RECT r = {(LONG) (pcmd->ClipRect.x - clip_off.x), (LONG) (pcmd->ClipRect.y - clip_off.y),
-                                (LONG) (pcmd->ClipRect.z - clip_off.x), (LONG) (pcmd->ClipRect.w - clip_off.y)};
-                auto texture = reinterpret_cast<IDirect3DBaseTexture9 *>(pcmd->TextureId);
-                g_pd3dDevice->SetTexture(0, texture);
-                g_pd3dDevice->SetScissorRect(&r);
-                g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,
-                                                   pcmd->VtxOffset + global_vtx_offset, 0,
-                                                   (UINT) cmd_list->VtxBuffer.Size,
-                                                   pcmd->IdxOffset + global_idx_offset, pcmd->ElemCount / 3);
+    for (const ImDrawList* draw_list : draw_data->CmdLists)
+    {
+        for (int cmd_i = 0; cmd_i < draw_list->CmdBuffer.Size; cmd_i++)
+        {
+            const ImDrawCmd* pcmd = &draw_list->CmdBuffer[cmd_i];
+            if (pcmd->UserCallback != nullptr)
+            {
+                // User callback, registered via ImDrawList::AddCallback()
+                // (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
+                if (pcmd->UserCallback == ImDrawCallback_ResetRenderState)
+                    ImGui_ImplDX9_SetupRenderState(draw_data, &render_state);
+                else
+                    pcmd->UserCallback(draw_list, pcmd);
+            }
+            else
+            {
+                // Project scissor/clipping rectangles into framebuffer space
+                ImVec2 clip_min(pcmd->ClipRect.x - clip_off.x, pcmd->ClipRect.y - clip_off.y);
+                ImVec2 clip_max(pcmd->ClipRect.z - clip_off.x, pcmd->ClipRect.w - clip_off.y);
+                if (clip_max.x <= clip_min.x || clip_max.y <= clip_min.y)
+                    continue;
+
+                // Apply scissor/clipping rectangle
+                const RECT r = { (LONG)clip_min.x, (LONG)clip_min.y, (LONG)clip_max.x, (LONG)clip_max.y };
+                device->SetScissorRect(&r);
+
+                // Bind texture, Draw
+                const LPDIRECT3DTEXTURE9 texture = (LPDIRECT3DTEXTURE9)pcmd->GetTexID();
+                device->SetTexture(0, texture);
+                device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, pcmd->VtxOffset + global_vtx_offset, 0, (UINT)draw_list->VtxBuffer.Size, pcmd->IdxOffset + global_idx_offset, pcmd->ElemCount / 3);
            }
        }
-        global_idx_offset += cmd_list->IdxBuffer.Size;
-        global_vtx_offset += cmd_list->VtxBuffer.Size;
+        global_idx_offset += draw_list->IdxBuffer.Size;
+        global_vtx_offset += draw_list->VtxBuffer.Size;
    }

-    if (back_buffer) {
-        back_buffer->Release();
-        back_buffer = nullptr;
-    }
+    // When using multi-viewports, it appears that there's an odd logic in DirectX9 which prevent subsequent windows
+    // from rendering until the first window submits at least one draw call, even once. That's our workaround. (see #2560)
+    if (global_vtx_offset == 0)
+        bd->pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 0, 0, 0);

-    // restore previous depth stencil
-    if (depth_stencil) {
-        g_pd3dDevice->SetDepthStencilSurface(depth_stencil);
-        depth_stencil->Release();
-        depth_stencil = nullptr;
-    }
+    // spice ldj
+    {
+        if (render_state.back_buffer) {
+            render_state.back_buffer->Release();
+            render_state.back_buffer = nullptr;
+        }
+        // restore previous depth stencil
+        if (render_state.depth_stencil) {
+            device->SetDepthStencilSurface(render_state.depth_stencil);
+            render_state.depth_stencil->Release();
+            render_state.depth_stencil = nullptr;
+        }
+        // restore all render target state
+        for (size_t target = 0; target < std::min(8UL, render_state.caps.NumSimultaneousRTs); target++) {
+            auto render_target = render_state.render_targets[target];

-    // restore all render target state
-    for (size_t target = 0; target < std::min(8UL, caps.NumSimultaneousRTs); target++) {
-        auto render_target = render_targets[target];
-
-        if (render_target) {
-            g_pd3dDevice->SetRenderTarget(target, render_target);
-            render_target->Release();
+            if (render_target) {
+                device->SetRenderTarget(target, render_target);
+                render_target->Release();
+            }
        }
    }

-    // restore the DX9 transform
-    g_pd3dDevice->SetTransform(D3DTS_WORLD, &last_world);
-    g_pd3dDevice->SetTransform(D3DTS_VIEW, &last_view);
-    g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &last_projection);
+    // Restore the DX9 transform
+    device->SetTransform(D3DTS_WORLD, &last_world);
+    device->SetTransform(D3DTS_VIEW, &last_view);
+    device->SetTransform(D3DTS_PROJECTION, &last_projection);

-    // restore the DX9 state
-    d3d9_state_block->Apply();
-    d3d9_state_block->Release();
+    // Restore the DX9 state
+    state_block->Apply();
+    state_block->Release();
 }

-bool ImGui_ImplDX9_Init(IDirect3DDevice9 *device) {
+static bool ImGui_ImplDX9_CheckFormatSupport(LPDIRECT3DDEVICE9 pDevice, D3DFORMAT format)
+{
+    LPDIRECT3D9 pd3d = nullptr;
+    if (pDevice->GetDirect3D(&pd3d) != D3D_OK)
+        return false;
+    D3DDEVICE_CREATION_PARAMETERS param = {};
+    D3DDISPLAYMODE mode = {};
+    if (pDevice->GetCreationParameters(&param) != D3D_OK || pDevice->GetDisplayMode(0, &mode) != D3D_OK)
+    {
+        pd3d->Release();
+        return false;
+    }
+    // Font texture should support linear filter, color blend and write to render-target
+    bool support = (pd3d->CheckDeviceFormat(param.AdapterOrdinal, param.DeviceType, mode.Format, D3DUSAGE_DYNAMIC | D3DUSAGE_QUERY_FILTER | D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING, D3DRTYPE_TEXTURE, format)) == D3D_OK;
+    pd3d->Release();
+    return support;
+}

-    // Setup back-end capabilities flags
-    auto &io = ImGui::GetIO();
+bool ImGui_ImplDX9_Init(IDirect3DDevice9* device)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    IMGUI_CHECKVERSION();
+    IM_ASSERT(io.BackendRendererUserData == nullptr && "Already initialized a renderer backend!");
+
+    // Setup backend capabilities flags
+    ImGui_ImplDX9_Data* bd = IM_NEW(ImGui_ImplDX9_Data)();
+    io.BackendRendererUserData = (void*)bd;
    io.BackendRendererName = "imgui_impl_dx9";
+    io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset;  // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
+    io.BackendFlags |= ImGuiBackendFlags_RendererHasTextures;   // We can honor ImGuiPlatformIO::Textures[] requests during render.
+    io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports;  // We can create multi-viewports on the Renderer side (optional)

-    // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
-    io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset;
+    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+    platform_io.Renderer_TextureMaxWidth = platform_io.Renderer_TextureMaxHeight = 4096;
+
+    bd->pd3dDevice = device;
+    bd->pd3dDevice->AddRef();
+    bd->HasRgbaSupport = ImGui_ImplDX9_CheckFormatSupport(bd->pd3dDevice, D3DFMT_A8B8G8R8);
+
+    ImGui_ImplDX9_InitMultiViewportSupport();

-    g_pd3dDevice = device;
-    g_pd3dDevice->AddRef();
    return true;
 }

-void ImGui_ImplDX9_Shutdown() {
+void ImGui_ImplDX9_Shutdown()
+{
+    ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();
+    IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?");
+    ImGuiIO& io = ImGui::GetIO();
+    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+
+    ImGui_ImplDX9_ShutdownMultiViewportSupport();
    ImGui_ImplDX9_InvalidateDeviceObjects();
+    if (bd->pd3dDevice) { bd->pd3dDevice->Release(); }

-    if (g_pd3dDevice) {
-        g_pd3dDevice->Release();
-        g_pd3dDevice = NULL;
+    io.BackendRendererName = nullptr;
+    io.BackendRendererUserData = nullptr;
+    io.BackendFlags &= ~(ImGuiBackendFlags_RendererHasVtxOffset | ImGuiBackendFlags_RendererHasTextures | ImGuiBackendFlags_RendererHasViewports);
+    platform_io.ClearRendererHandlers();
+    IM_DELETE(bd);
+}
+
+// Convert RGBA32 to BGRA32 (because RGBA32 is not well supported by DX9 devices)
+static void ImGui_ImplDX9_CopyTextureRegion(bool tex_use_colors, const ImU32* src, int src_pitch, ImU32* dst, int dst_pitch, int w, int h)
+{
+#ifndef IMGUI_USE_BGRA_PACKED_COLOR
+    ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();
+    const bool convert_rgba_to_bgra = (!bd->HasRgbaSupport && tex_use_colors);
+#else
+    const bool convert_rgba_to_bgra = false;
+    IM_UNUSED(tex_use_colors);
+#endif
+    for (int y = 0; y < h; y++)
+    {
+        const ImU32* src_p = (const ImU32*)(const void*)((const unsigned char*)src + src_pitch * y);
+        ImU32* dst_p = (ImU32*)(void*)((unsigned char*)dst + dst_pitch * y);
+        if (convert_rgba_to_bgra)
+            for (int x = w; x > 0; x--, src_p++, dst_p++) // Convert copy
+                *dst_p = IMGUI_COL_TO_DX9_ARGB(*src_p);
+        else
+            memcpy(dst_p, src_p, w * 4); // Raw copy
    }
 }

-static bool ImGui_ImplDX9_CreateFontsTexture() {
-    // Build texture atlas
-    ImGuiIO &io = ImGui::GetIO();
-    unsigned char *pixels;
-    int width, height, bytes_per_pixel;
-    io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height, &bytes_per_pixel);
+void ImGui_ImplDX9_UpdateTexture(ImTextureData* tex)
+{
+    ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();

-    // Upload texture to graphics system
-    g_FontTexture = NULL;
-    if (g_pd3dDevice->CreateTexture(width, height, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8,
-                                    D3DPOOL_DEFAULT, &g_FontTexture, NULL) < 0)
-        return false;
-    D3DLOCKED_RECT tex_locked_rect;
-    if (g_FontTexture->LockRect(0, &tex_locked_rect, NULL, 0) != D3D_OK)
-        return false;
-    for (int y = 0; y < height; y++)
-        memcpy((unsigned char *) tex_locked_rect.pBits + tex_locked_rect.Pitch * y,
-               pixels + (width * bytes_per_pixel) * y, (width * bytes_per_pixel));
-    g_FontTexture->UnlockRect(0);
-
-    // Store our identifier
-    io.Fonts->TexID = (ImTextureID) g_FontTexture;
-
-    return true;
-}
-
-bool ImGui_ImplDX9_CreateDeviceObjects() {
-    if (!g_pd3dDevice) {
-        return false;
-    }
-    return ImGui_ImplDX9_CreateFontsTexture();
-}
-
-void ImGui_ImplDX9_InvalidateDeviceObjects() {
-    if (!g_pd3dDevice)
-        return;
-    if (g_pVB) {
-        g_pVB->Release();
-        g_pVB = NULL;
-    }
-    if (g_pIB) {
-        g_pIB->Release();
-        g_pIB = NULL;
-    }
-    if (g_FontTexture) {
-        g_FontTexture->Release();
-        g_FontTexture = NULL;
-        ImGui::GetIO().Fonts->TexID = 0;
-    } // We copied g_pFontTextureView to io.Fonts->TexID so let's clear that as well.
-}
-
-void ImGui_ImplDX9_NewFrame() {
-    if (!g_FontTexture) {
-        ImGui_ImplDX9_CreateDeviceObjects();
-    }
-
-    IDirect3DSwapChain9 *swap_chain = nullptr;
-    if (SUCCEEDED(g_pd3dDevice->GetSwapChain(0, &swap_chain))) {
-        auto &io = ImGui::GetIO();
-
-        D3DPRESENT_PARAMETERS present_params {};
-
-        if (SUCCEEDED(swap_chain->GetPresentParameters(&present_params))) {
-            if (present_params.BackBufferWidth != 0 && present_params.BackBufferHeight != 0) {
-                io.DisplaySize.x = static_cast<float>(present_params.BackBufferWidth);
-                io.DisplaySize.y = static_cast<float>(present_params.BackBufferHeight);
-            } else {
-                RECT rect {};
-                GetClientRect(present_params.hDeviceWindow, &rect);
-
-                io.DisplaySize.x = static_cast<float>(rect.right - rect.left);
-                io.DisplaySize.y = static_cast<float>(rect.bottom - rect.top);
-            }
+    if (tex->Status == ImTextureStatus_WantCreate)
+    {
+        // Create and upload new texture to graphics system
+        //IMGUI_DEBUG_LOG("UpdateTexture #%03d: WantCreate %dx%d\n", tex->UniqueID, tex->Width, tex->Height);
+        IM_ASSERT(tex->TexID == ImTextureID_Invalid && tex->BackendUserData == nullptr);
+        IM_ASSERT(tex->Format == ImTextureFormat_RGBA32);
+        LPDIRECT3DTEXTURE9 dx_tex = nullptr;
+        HRESULT hr = bd->pd3dDevice->CreateTexture(tex->Width, tex->Height, 1, D3DUSAGE_DYNAMIC, bd->HasRgbaSupport ? D3DFMT_A8B8G8R8 : D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &dx_tex, nullptr);
+        if (hr < 0)
+        {
+            IM_ASSERT(hr >= 0 && "Backend failed to create texture!");
+            return;
        }

-        swap_chain->Release();
+        D3DLOCKED_RECT locked_rect;
+        if (dx_tex->LockRect(0, &locked_rect, nullptr, 0) == D3D_OK)
+        {
+            ImGui_ImplDX9_CopyTextureRegion(tex->UseColors, (ImU32*)tex->GetPixels(), tex->Width * 4, (ImU32*)locked_rect.pBits, (ImU32)locked_rect.Pitch, tex->Width, tex->Height);
+            dx_tex->UnlockRect(0);
+        }
+
+        // Store identifiers
+        tex->SetTexID((ImTextureID)(intptr_t)dx_tex);
+        tex->SetStatus(ImTextureStatus_OK);
+    }
+    else if (tex->Status == ImTextureStatus_WantUpdates)
+    {
+        // Update selected blocks. We only ever write to textures regions which have never been used before!
+        // This backend choose to use tex->Updates[] but you can use tex->UpdateRect to upload a single region.
+        LPDIRECT3DTEXTURE9 backend_tex = (LPDIRECT3DTEXTURE9)(intptr_t)tex->TexID;
+        RECT update_rect = { (LONG)tex->UpdateRect.x, (LONG)tex->UpdateRect.y, (LONG)(tex->UpdateRect.x + tex->UpdateRect.w), (LONG)(tex->UpdateRect.y + tex->UpdateRect.h) };
+        D3DLOCKED_RECT locked_rect;
+        if (backend_tex->LockRect(0, &locked_rect, &update_rect, 0) == D3D_OK)
+            for (ImTextureRect& r : tex->Updates)
+                ImGui_ImplDX9_CopyTextureRegion(tex->UseColors, (ImU32*)tex->GetPixelsAt(r.x, r.y), tex->Width * 4,
+                    (ImU32*)locked_rect.pBits + (r.x - update_rect.left) + (r.y - update_rect.top) * (locked_rect.Pitch / 4), (int)locked_rect.Pitch, r.w, r.h);
+        backend_tex->UnlockRect(0);
+        tex->SetStatus(ImTextureStatus_OK);
+    }
+    else if (tex->Status == ImTextureStatus_WantDestroy)
+    {
+        if (tex->TexID != ImTextureID_Invalid)
+            if (LPDIRECT3DTEXTURE9 backend_tex = (LPDIRECT3DTEXTURE9)tex->TexID)
+            {
+                IM_ASSERT(tex->TexID == (ImTextureID)(intptr_t)backend_tex);
+                backend_tex->Release();
+
+                // Clear identifiers and mark as destroyed (in order to allow e.g. calling InvalidateDeviceObjects while running)
+                tex->SetTexID(ImTextureID_Invalid);
+            }
+        tex->SetStatus(ImTextureStatus_Destroyed);
    }
 }
+
+bool ImGui_ImplDX9_CreateDeviceObjects()
+{
+    ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();
+    if (!bd || !bd->pd3dDevice)
+        return false;
+    ImGui_ImplDX9_CreateDeviceObjectsForPlatformWindows();
+    return true;
+}
+
+void ImGui_ImplDX9_InvalidateDeviceObjects()
+{
+    ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();
+    if (!bd || !bd->pd3dDevice)
+        return;
+
+    // Destroy all textures
+    for (ImTextureData* tex : ImGui::GetPlatformIO().Textures)
+        if (tex->RefCount == 1)
+        {
+            tex->SetStatus(ImTextureStatus_WantDestroy);
+            ImGui_ImplDX9_UpdateTexture(tex);
+        }
+    if (bd->pVB) { bd->pVB->Release(); bd->pVB = nullptr; }
+    if (bd->pIB) { bd->pIB->Release(); bd->pIB = nullptr; }
+    ImGui_ImplDX9_InvalidateDeviceObjectsForPlatformWindows();
+}
+
+void ImGui_ImplDX9_NewFrame()
+{
+    ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();
+    IM_ASSERT(bd != nullptr && "Context or backend not initialized! Did you call ImGui_ImplDX9_Init()?");
+    // IM_UNUSED(bd);
+
+    // spice ldj
+    {
+        IDirect3DSwapChain9 *swap_chain = nullptr;
+        if (SUCCEEDED(bd->pd3dDevice->GetSwapChain(0, &swap_chain))) {
+            auto &io = ImGui::GetIO();
+
+            D3DPRESENT_PARAMETERS present_params {};
+
+            if (SUCCEEDED(swap_chain->GetPresentParameters(&present_params))) {
+                if (present_params.BackBufferWidth != 0 && present_params.BackBufferHeight != 0) {
+                    io.DisplaySize.x = static_cast<float>(present_params.BackBufferWidth);
+                    io.DisplaySize.y = static_cast<float>(present_params.BackBufferHeight);
+                } else {
+                    RECT rect {};
+                    GetClientRect(present_params.hDeviceWindow, &rect);
+
+                    io.DisplaySize.x = static_cast<float>(rect.right - rect.left);
+                    io.DisplaySize.y = static_cast<float>(rect.bottom - rect.top);
+                }
+            }
+
+            swap_chain->Release();
+        }
+    }
+}
+
+//--------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
+// If you are new to dear imgui or creating a new binding for dear imgui, it is recommended that you completely ignore this section first..
+//--------------------------------------------------------------------------------------------------------
+
+// Helper structure we store in the void* RendererUserData field of each ImGuiViewport to easily retrieve our backend data.
+struct ImGui_ImplDX9_ViewportData
+{
+    IDirect3DSwapChain9*    SwapChain;
+    D3DPRESENT_PARAMETERS   d3dpp;
+
+    ImGui_ImplDX9_ViewportData()  { SwapChain = nullptr; ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS)); }
+    ~ImGui_ImplDX9_ViewportData() { IM_ASSERT(SwapChain == nullptr); }
+};
+
+static void ImGui_ImplDX9_CreateWindow(ImGuiViewport* viewport)
+{
+    ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();
+    ImGui_ImplDX9_ViewportData* vd = IM_NEW(ImGui_ImplDX9_ViewportData)();
+    viewport->RendererUserData = vd;
+
+    // PlatformHandleRaw should always be a HWND, whereas PlatformHandle might be a higher-level handle (e.g. GLFWWindow*, SDL's WindowID).
+    // Some backends will leave PlatformHandleRaw == 0, in which case we assume PlatformHandle will contain the HWND.
+    HWND hwnd = viewport->PlatformHandleRaw ? (HWND)viewport->PlatformHandleRaw : (HWND)viewport->PlatformHandle;
+    IM_ASSERT(hwnd != 0);
+
+    ZeroMemory(&vd->d3dpp, sizeof(D3DPRESENT_PARAMETERS));
+    vd->d3dpp.Windowed = TRUE;
+    vd->d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
+    vd->d3dpp.BackBufferWidth = (UINT)viewport->Size.x;
+    vd->d3dpp.BackBufferHeight = (UINT)viewport->Size.y;
+    vd->d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
+    vd->d3dpp.hDeviceWindow = hwnd;
+    vd->d3dpp.EnableAutoDepthStencil = FALSE;
+    vd->d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
+    vd->d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;   // Present without vsync
+
+    HRESULT hr = bd->pd3dDevice->CreateAdditionalSwapChain(&vd->d3dpp, &vd->SwapChain); IM_UNUSED(hr);
+    IM_ASSERT(hr == D3D_OK);
+    IM_ASSERT(vd->SwapChain != nullptr);
+}
+
+static void ImGui_ImplDX9_DestroyWindow(ImGuiViewport* viewport)
+{
+    // The main viewport (owned by the application) will always have RendererUserData == 0 since we didn't create the data for it.
+    if (ImGui_ImplDX9_ViewportData* vd = (ImGui_ImplDX9_ViewportData*)viewport->RendererUserData)
+    {
+        if (vd->SwapChain)
+            vd->SwapChain->Release();
+        vd->SwapChain = nullptr;
+        ZeroMemory(&vd->d3dpp, sizeof(D3DPRESENT_PARAMETERS));
+        IM_DELETE(vd);
+    }
+    viewport->RendererUserData = nullptr;
+}
+
+static void ImGui_ImplDX9_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
+{
+    ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();
+    ImGui_ImplDX9_ViewportData* vd = (ImGui_ImplDX9_ViewportData*)viewport->RendererUserData;
+    if (vd->SwapChain)
+    {
+        vd->SwapChain->Release();
+        vd->SwapChain = nullptr;
+        vd->d3dpp.BackBufferWidth = (UINT)size.x;
+        vd->d3dpp.BackBufferHeight = (UINT)size.y;
+        HRESULT hr = bd->pd3dDevice->CreateAdditionalSwapChain(&vd->d3dpp, &vd->SwapChain); IM_UNUSED(hr);
+        IM_ASSERT(hr == D3D_OK);
+    }
+}
+
+static void ImGui_ImplDX9_RenderWindow(ImGuiViewport* viewport, void*)
+{
+    ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();
+    ImGui_ImplDX9_ViewportData* vd = (ImGui_ImplDX9_ViewportData*)viewport->RendererUserData;
+    ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f);
+
+    LPDIRECT3DSURFACE9 render_target = nullptr;
+    LPDIRECT3DSURFACE9 last_render_target = nullptr;
+    LPDIRECT3DSURFACE9 last_depth_stencil = nullptr;
+    vd->SwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &render_target);
+    bd->pd3dDevice->GetRenderTarget(0, &last_render_target);
+    bd->pd3dDevice->GetDepthStencilSurface(&last_depth_stencil);
+    bd->pd3dDevice->SetRenderTarget(0, render_target);
+    bd->pd3dDevice->SetDepthStencilSurface(nullptr);
+
+    if (!(viewport->Flags & ImGuiViewportFlags_NoRendererClear))
+    {
+        D3DCOLOR clear_col_dx = D3DCOLOR_RGBA((int)(clear_color.x*255.0f), (int)(clear_color.y*255.0f), (int)(clear_color.z*255.0f), (int)(clear_color.w*255.0f));
+        bd->pd3dDevice->Clear(0, nullptr, D3DCLEAR_TARGET, clear_col_dx, 1.0f, 0);
+    }
+
+    ImGui_ImplDX9_RenderDrawData(viewport->DrawData);
+
+    // Restore render target
+    bd->pd3dDevice->SetRenderTarget(0, last_render_target);
+    bd->pd3dDevice->SetDepthStencilSurface(last_depth_stencil);
+    render_target->Release();
+    last_render_target->Release();
+    if (last_depth_stencil) last_depth_stencil->Release();
+}
+
+static void ImGui_ImplDX9_SwapBuffers(ImGuiViewport* viewport, void*)
+{
+    ImGui_ImplDX9_ViewportData* vd = (ImGui_ImplDX9_ViewportData*)viewport->RendererUserData;
+    HRESULT hr = vd->SwapChain->Present(nullptr, nullptr, vd->d3dpp.hDeviceWindow, nullptr, 0);
+    // Let main application handle D3DERR_DEVICELOST by resetting the device.
+    IM_ASSERT(SUCCEEDED(hr) || hr == D3DERR_DEVICELOST);
+}
+
+static void ImGui_ImplDX9_InitMultiViewportSupport()
+{
+    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+    platform_io.Renderer_CreateWindow = ImGui_ImplDX9_CreateWindow;
+    platform_io.Renderer_DestroyWindow = ImGui_ImplDX9_DestroyWindow;
+    platform_io.Renderer_SetWindowSize = ImGui_ImplDX9_SetWindowSize;
+    platform_io.Renderer_RenderWindow = ImGui_ImplDX9_RenderWindow;
+    platform_io.Renderer_SwapBuffers = ImGui_ImplDX9_SwapBuffers;
+}
+
+static void ImGui_ImplDX9_ShutdownMultiViewportSupport()
+{
+    ImGui::DestroyPlatformWindows();
+}
+
+static void ImGui_ImplDX9_CreateDeviceObjectsForPlatformWindows()
+{
+    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+    for (int i = 1; i < platform_io.Viewports.Size; i++)
+        if (!platform_io.Viewports[i]->RendererUserData)
+            ImGui_ImplDX9_CreateWindow(platform_io.Viewports[i]);
+}
+
+static void ImGui_ImplDX9_InvalidateDeviceObjectsForPlatformWindows()
+{
+    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+    for (int i = 1; i < platform_io.Viewports.Size; i++)
+        if (platform_io.Viewports[i]->RendererUserData)
+            ImGui_ImplDX9_DestroyWindow(platform_io.Viewports[i]);
+}
+
+//-----------------------------------------------------------------------------
+
+#endif // #ifndef IMGUI_DISABLE
@@ -1,25 +1,38 @@
-// dear imgui: Renderer for DirectX9
-// This needs to be used along with a Platform Binding (e.g. Win32)
+// dear imgui: Renderer Backend for DirectX9
+// This needs to be used along with a Platform Backend (e.g. Win32)

 // Implemented features:
-//  [X] Renderer: User texture binding. Use 'LPDIRECT3DTEXTURE9' as ImTextureID. Read the FAQ about ImTextureID in imgui.cpp.
-//  [X] Renderer: Support for large meshes (64k+ vertices) with 16-bits indices.
+//  [X] Renderer: User texture binding. Use 'LPDIRECT3DTEXTURE9' as texture identifier. Read the FAQ about ImTextureID/ImTextureRef!
+//  [X] Renderer: Large meshes support (64k+ vertices) even with 16-bit indices (ImGuiBackendFlags_RendererHasVtxOffset).
+//  [X] Renderer: Texture updates support for dynamic font atlas (ImGuiBackendFlags_RendererHasTextures).
+//  [X] Renderer: IMGUI_USE_BGRA_PACKED_COLOR support, as this is the optimal color encoding for DirectX9.
+//  [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.

-// You can copy and use unmodified imgui_impl_* files in your project. See main.cpp for an example of using this.
-// If you are new to dear imgui, read examples/README.txt and read the documentation at the top of imgui.cpp.
-// https://github.com/ocornut/imgui
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
+// - Introduction, links and more at the top of imgui.cpp

 #pragma once
-
-#include "imgui.h"
+#include "imgui.h"      // IMGUI_IMPL_API
+#ifndef IMGUI_DISABLE

 struct IDirect3DDevice9;

-IMGUI_IMPL_API bool     ImGui_ImplDX9_Init(IDirect3DDevice9 *device);
+// Follow "Getting Started" link and check examples/ folder to learn about using backends!
+IMGUI_IMPL_API bool     ImGui_ImplDX9_Init(IDirect3DDevice9* device);
 IMGUI_IMPL_API void     ImGui_ImplDX9_Shutdown();
 IMGUI_IMPL_API void     ImGui_ImplDX9_NewFrame();
-IMGUI_IMPL_API void     ImGui_ImplDX9_RenderDrawData(ImDrawData *draw_data);
+IMGUI_IMPL_API void     ImGui_ImplDX9_RenderDrawData(ImDrawData* draw_data);

-// Use if you want to reset your rendering device without losing ImGui state.
+// Use if you want to reset your rendering device without losing Dear ImGui state.
 IMGUI_IMPL_API bool     ImGui_ImplDX9_CreateDeviceObjects();
 IMGUI_IMPL_API void     ImGui_ImplDX9_InvalidateDeviceObjects();
+
+// (Advanced) Use e.g. if you need to precisely control the timing of texture updates (e.g. for staged rendering), by setting ImDrawData::Textures = nullptr to handle this manually.
+IMGUI_IMPL_API void     ImGui_ImplDX9_UpdateTexture(ImTextureData* tex);
+
+#endif // #ifndef IMGUI_DISABLE
@@ -15,7 +15,8 @@
 #pragma once

 //---- Define assertion handler. Defaults to calling assert().
-// If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single statement.
+// - If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single statement.
+// - Compiling with NDEBUG will usually strip out assert() to nothing, which is NOT recommended because we use asserts to notify of programmer mistakes.
 //#define IM_ASSERT(_EXPR)  MyAssert(_EXPR)
 #define IM_ASSERT(_EXPR)  ((void)(_EXPR))     // Disable asserts

@@ -29,7 +30,6 @@

 //---- Don't define obsolete functions/enums/behaviors. Consider enabling from time to time after updating to clean your code of obsolete function/names.
 //#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
-//#define IMGUI_DISABLE_OBSOLETE_KEYIO                      // 1.87+ disable legacy io.KeyMap[]+io.KeysDown[] in favor io.AddKeyEvent(). This is automatically done by IMGUI_DISABLE_OBSOLETE_FUNCTIONS.

 //---- Disable all of Dear ImGui or don't implement standard windows/tools.
 // It is very strongly recommended to NOT disable the demo windows and debug tool during development. They are extremely useful in day to day work. Please read comments in imgui_demo.cpp.
@@ -49,6 +49,7 @@
 //#define IMGUI_DISABLE_FILE_FUNCTIONS                      // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle at all (replace them with dummies)
 //#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS              // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function.
 #define IMGUI_DISABLE_DEFAULT_ALLOCATORS                  // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions().
+//#define IMGUI_DISABLE_DEFAULT_FONT                        // Disable default embedded fonts (ProggyClean/ProggyForever), remove ~9 KB + ~14 KB from output binary. AddFontDefaultXXX() functions will assert.
 //#define IMGUI_DISABLE_SSE                                 // Disable use of SSE intrinsics even if available

 //---- Enable Test Engine / Automation features.
@@ -59,12 +60,15 @@
 //#define IMGUI_INCLUDE_IMGUI_USER_H
 //#define IMGUI_USER_H_FILENAME         "my_folder/my_imgui_user.h"

-//---- Pack colors to BGRA8 instead of RGBA8 (to avoid converting from one to another)
+//---- Pack vertex colors as BGRA8 instead of RGBA8 (to avoid converting from one to another). Need dedicated backend support.
 #define IMGUI_USE_BGRA_PACKED_COLOR

 //---- Performance optimization for DX9
 #define IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT struct ImDrawVert { ImVec2 pos; float z; ImU32 col; ImVec2 uv; }

+//---- Use legacy CRC32-adler tables (used before 1.91.6), in order to preserve old .ini data that you cannot afford to invalidate.
+//#define IMGUI_USE_LEGACY_CRC32_ADLER
+
 //---- Use 32-bit for ImWchar (default is 16-bit) to support Unicode planes 1-16. (e.g. point beyond 0xFFFF like emoticons, dingbats, symbols, shapes, ancient languages, etc...)
 //#define IMGUI_USE_WCHAR32

@@ -83,13 +87,13 @@

 //---- Use FreeType to build and rasterize the font atlas (instead of stb_truetype which is embedded by default in Dear ImGui)
 // Requires FreeType headers to be available in the include path. Requires program to be compiled with 'misc/freetype/imgui_freetype.cpp' (in this repository) + the FreeType library (not provided).
+// Note that imgui_freetype.cpp may be used _without_ this define, if you manually call ImFontAtlas::SetFontLoader(). The define is simply a convenience.
 // On Windows you may use vcpkg with 'vcpkg install freetype --triplet=x64-windows' + 'vcpkg integrate install'.
 //#define IMGUI_ENABLE_FREETYPE

 //---- Use FreeType + plutosvg or lunasvg to render OpenType SVG fonts (SVGinOT)
 // Only works in combination with IMGUI_ENABLE_FREETYPE.
-// - lunasvg is currently easier to acquire/install, as e.g. it is part of vcpkg.
-// - plutosvg will support more fonts and may load them faster. It currently requires to be built manually but it is fairly easy. See misc/freetype/README for instructions.
+// - plutosvg is currently easier to install, as e.g. it is part of vcpkg. It will support more fonts and may load them faster. See misc/freetype/README for instructions.
 // - Both require headers to be available in the include path + program to be linked with the library code (not provided).
 // - (note: lunasvg implementation is based on Freetype's rsvg-port.c which is licensed under CeCILL-C Free Software License Agreement)
 //#define IMGUI_ENABLE_FREETYPE_PLUTOSVG
@@ -130,6 +134,10 @@
 //#define IM_DEBUG_BREAK  IM_ASSERT(0)
 //#define IM_DEBUG_BREAK  __debugbreak()

+//---- Debug Tools: Enable highlight ID conflicts _before_ hovering items. When io.ConfigDebugHighlightIdConflicts is set.
+// (THIS WILL SLOW DOWN DEAR IMGUI. Only use occasionally and disable after use)
+//#define IMGUI_DEBUG_HIGHLIGHT_ALL_ID_CONFLICTS
+
 //---- Debug Tools: Enable slower asserts
 //#define IMGUI_DEBUG_PARANOID

@@ -1,6 +1,7 @@
 // Mini memory editor for Dear ImGui (to embed in your game/tools)
 // Get latest version at http://www.github.com/ocornut/imgui_club
-//
+// Licensed under The MIT License (MIT)
+
 // Right-click anywhere to access the Options menu!
 // You can adjust the keyboard repeat delay/rate in ImGuiIO.
 // The code assume a mono-space font for simplicity!
@@ -39,10 +40,22 @@
 // - v0.43 (2021/03/12): added OptFooterExtraHeight to allow for custom drawing at the bottom of the editor [@leiradel]
 // - v0.44 (2021/03/12): use ImGuiInputTextFlags_AlwaysOverwrite in 1.82 + fix hardcoded width.
 // - v0.50 (2021/11/12): various fixes for recent dear imgui versions (fixed misuse of clipper, relying on SetKeyboardFocusHere() handling scrolling from 1.85). added default size.
+// - v0.51 (2024/02/22): fix for layout change in 1.89 when using IMGUI_DISABLE_OBSOLETE_FUNCTIONS. (#34)
+// - v0.52 (2024/03/08): removed unnecessary GetKeyIndex() calls, they are a no-op since 1.87.
+// - v0.53 (2024/05/27): fixed right-click popup from not appearing when using DrawContents(). warning fixes. (#35)
+// - v0.54 (2024/07/29): allow ReadOnly mode to still select and preview data. (#46) [@DeltaGW2])
+// - v0.55 (2024/08/19): added BgColorFn to allow setting background colors independently from highlighted selection. (#27) [@StrikerX3]
+//                       added MouseHoveredAddr public readable field. (#47, #27) [@StrikerX3]
+//                       fixed a data preview crash with 1.91.0 WIP. fixed contiguous highlight color when using data preview.
+//                       *BREAKING* added UserData field passed to all optional function handlers: ReadFn, WriteFn, HighlightFn, BgColorFn. (#50) [@silverweed]
+// - v0.56 (2024/11/04): fixed MouseHovered, MouseHoveredAddr not being set when hovering a byte being edited. (#54)
+// - v0.57 (2025/03/26): fixed warnings. using ImGui's ImSXX/ImUXX types instead of e.g. int32_t/uint32_t. (#56)
+// - v0.58 (2025/03/31): fixed extraneous footer spacing (added in 0.51) breaking vertical auto-resize. (#53)
+// - v0.59 (2025/04/08): fixed GotoAddrAndHighlight() not working if OptShowOptions is disabled.
 //
-// Todo/Bugs:
+// TODO:
 // - This is generally old/crappy code, it should work but isn't very good.. to be rewritten some day.
-// - PageUp/PageDown are supported because we use _NoNav. This is a good test scenario for working out idioms of how to mix natural nav and our own...
+// - PageUp/PageDown are not supported because we use _NoNav. This is a good test scenario for working out idioms of how to mix natural nav and our own...
 // - Arrows are being sent to the InputText() about to disappear which for LeftArrow makes the text cursor appear at position 1 for one frame.
 // - Using InputText() is awkward and maybe overkill here, consider implementing something custom.

@@ -51,15 +64,18 @@
 #include <stdio.h>      // sprintf, scanf
 #include <stdint.h>     // uint8_t, etc.

-#ifdef _MSC_VER
-#define _PRISizeT   "I"
+#if defined(_MSC_VER) && !defined(snprintf)
 #define ImSnprintf  _snprintf
 #else
-#define _PRISizeT   "z"
 #define ImSnprintf  snprintf
 #endif
+#if defined(_MSC_VER) && !defined(__clang__)
+#define _PRISizeT   "I"
+#else
+#define _PRISizeT   "z"
+#endif

-#ifdef _MSC_VER
+#if defined(_MSC_VER) || defined(_UCRT)
 #pragma warning (push)
 #pragma warning (disable: 4996) // warning C4996: 'sprintf': This function or variable may be unsafe.
 #endif
@@ -88,9 +104,17 @@ struct MemoryEditor
    int             OptAddrDigitsCount;                         // = 0      // number of addr digits to display (default calculated based on maximum displayed addr).
    float           OptFooterExtraHeight;                       // = 0      // space to reserve at the bottom of the widget to add custom widgets
    ImU32           HighlightColor;                             //          // background color of highlighted bytes.
-    ImU8            (*ReadFn)(const ImU8* data, size_t off);    // = 0      // optional handler to read bytes.
-    void            (*WriteFn)(ImU8* data, size_t off, ImU8 d); // = 0      // optional handler to write bytes.
-    bool            (*HighlightFn)(const ImU8* data, size_t off);//= 0      // optional handler to return Highlight property (to support non-contiguous highlighting).
+
+    // Function handlers
+    ImU8            (*ReadFn)(const ImU8* mem, size_t off, void* user_data);      // = 0      // optional handler to read bytes.
+    void            (*WriteFn)(ImU8* mem, size_t off, ImU8 d, void* user_data);   // = 0      // optional handler to write bytes.
+    bool            (*HighlightFn)(const ImU8* mem, size_t off, void* user_data); // = 0      // optional handler to return Highlight property (to support non-contiguous highlighting).
+    ImU32           (*BgColorFn)(const ImU8* mem, size_t off, void* user_data);   // = 0      // optional handler to return custom background color of individual bytes.
+    void*           UserData;                                                     // = NULL   // user data forwarded to the function handlers
+
+    // Public read-only data
+    bool            MouseHovered;                               // set when mouse is hovering a value.
+    size_t          MouseHoveredAddr;                           // the address currently being hovered if MouseHovered is set.

    // [Internal State]
    bool            ContentsWidthChanged;
@@ -101,7 +125,7 @@ struct MemoryEditor
    char            AddrInputBuf[32];
    size_t          GotoAddr;
    size_t          HighlightMin, HighlightMax;
-    int             PreviewEndianess;
+    int             PreviewEndianness;
    ImGuiDataType   PreviewDataType;

    MemoryEditor()
@@ -120,9 +144,11 @@ struct MemoryEditor
        OptAddrDigitsCount = 0;
        OptFooterExtraHeight = 0.0f;
        HighlightColor = IM_COL32(255, 255, 255, 50);
-        ReadFn = NULL;
-        WriteFn = NULL;
-        HighlightFn = NULL;
+        ReadFn = nullptr;
+        WriteFn = nullptr;
+        HighlightFn = nullptr;
+        BgColorFn = nullptr;
+        UserData = nullptr;

        // State/Internals
        ContentsWidthChanged = false;
@@ -131,8 +157,10 @@ struct MemoryEditor
        memset(DataInputBuf, 0, sizeof(DataInputBuf));
        memset(AddrInputBuf, 0, sizeof(AddrInputBuf));
        GotoAddr = (size_t)-1;
+        MouseHovered = false;
+        MouseHoveredAddr = 0;
        HighlightMin = HighlightMax = (size_t)-1;
-        PreviewEndianess = 0;
+        PreviewEndianness = 0;
        PreviewDataType = ImGuiDataType_S32;
    }

@@ -145,16 +173,16 @@ struct MemoryEditor

    struct Sizes
    {
-        int     AddrDigitsCount;
-        float   LineHeight;
-        float   GlyphWidth;
-        float   HexCellWidth;
-        float   SpacingBetweenMidCols;
-        float   PosHexStart;
-        float   PosHexEnd;
-        float   PosAsciiStart;
-        float   PosAsciiEnd;
-        float   WindowWidth;
+        int     AddrDigitsCount;            // Number of digits required to represent maximum address.
+        float   LineHeight;                 // Height of each line (no spacing).
+        float   GlyphWidth;                 // Glyph width (assume mono-space).
+        float   HexCellWidth;               // Width of a hex edit cell ~2.5f * GlypHWidth.
+        float   SpacingBetweenMidCols;      // Spacing between each columns section (OptMidColsCount).
+        float   OffsetHexMinX;
+        float   OffsetHexMaxX;
+        float   OffsetAsciiMinX;
+        float   OffsetAsciiMaxX;
+        float   WindowWidth;                // Ideal window width.

        Sizes() { memset(this, 0, sizeof(*this)); }
    };
@@ -170,17 +198,17 @@ struct MemoryEditor
        s.GlyphWidth = ImGui::CalcTextSize("F").x + 1;                  // We assume the font is mono-space
        s.HexCellWidth = (float)(int)(s.GlyphWidth * 2.5f);             // "FF " we include trailing space in the width to easily catch clicks everywhere
        s.SpacingBetweenMidCols = (float)(int)(s.HexCellWidth * 0.25f); // Every OptMidColsCount columns we add a bit of extra spacing
-        s.PosHexStart = (s.AddrDigitsCount + 2) * s.GlyphWidth;
-        s.PosHexEnd = s.PosHexStart + (s.HexCellWidth * Cols);
-        s.PosAsciiStart = s.PosAsciiEnd = s.PosHexEnd;
+        s.OffsetHexMinX = (s.AddrDigitsCount + 2) * s.GlyphWidth;
+        s.OffsetHexMaxX = s.OffsetHexMinX + (s.HexCellWidth * Cols);
+        s.OffsetAsciiMinX = s.OffsetAsciiMaxX = s.OffsetHexMaxX;
        if (OptShowAscii)
        {
-            s.PosAsciiStart = s.PosHexEnd + s.GlyphWidth * 1;
+            s.OffsetAsciiMinX = s.OffsetHexMaxX + s.GlyphWidth * 1;
            if (OptMidColsCount > 0)
-                s.PosAsciiStart += (float)((Cols + OptMidColsCount - 1) / OptMidColsCount) * s.SpacingBetweenMidCols;
-            s.PosAsciiEnd = s.PosAsciiStart + Cols * s.GlyphWidth;
+                s.OffsetAsciiMinX += (float)((Cols + OptMidColsCount - 1) / OptMidColsCount) * s.SpacingBetweenMidCols;
+            s.OffsetAsciiMaxX = s.OffsetAsciiMinX + Cols * s.GlyphWidth;
        }
-        s.WindowWidth = s.PosAsciiEnd + style.ScrollbarSize + style.WindowPadding.x * 2 + s.GlyphWidth;
+        s.WindowWidth = s.OffsetAsciiMaxX + style.ScrollbarSize + style.WindowPadding.x * 2 + s.GlyphWidth;
    }

    // Standalone Memory Editor window
@@ -194,8 +222,6 @@ struct MemoryEditor
        Open = true;
        if (ImGui::Begin(title, &Open, ImGuiWindowFlags_NoScrollbar))
        {
-            if (ImGui::IsWindowHovered(ImGuiHoveredFlags_RootAndChildWindows) && ImGui::IsMouseReleased(ImGuiMouseButton_Right))
-                ImGui::OpenPopup("context");
            DrawContents(mem_data, mem_size, base_display_addr);
            if (ContentsWidthChanged)
            {
@@ -217,6 +243,8 @@ struct MemoryEditor
        CalcSizes(s, mem_size, base_display_addr);
        ImGuiStyle& style = ImGui::GetStyle();

+        const ImVec2 contents_pos_start = ImGui::GetCursorScreenPos();
+
        // We begin into our scrolling region with the 'ImGuiWindowFlags_NoMove' in order to prevent click from moving the window.
        // This is used as a facility since our main click detection code doesn't assign an ActiveId so the click would normally be caught as a window-move.
        const float height_separator = style.ItemSpacing.y;
@@ -225,20 +253,21 @@ struct MemoryEditor
            footer_height += height_separator + ImGui::GetFrameHeightWithSpacing() * 1;
        if (OptShowDataPreview)
            footer_height += height_separator + ImGui::GetFrameHeightWithSpacing() * 1 + ImGui::GetTextLineHeightWithSpacing() * 3;
-        ImGui::BeginChild("##scrolling", ImVec2(0, -footer_height), false, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoNav);
+        ImGui::BeginChild("##scrolling", ImVec2(-FLT_MIN, -footer_height), ImGuiChildFlags_None, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoNav);
        ImDrawList* draw_list = ImGui::GetWindowDrawList();

        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));

        // We are not really using the clipper API correctly here, because we rely on visible_start_addr/visible_end_addr for our scrolling function.
+        const ImVec2 avail_size = ImGui::GetContentRegionAvail();
        const int line_total_count = (int)((mem_size + Cols - 1) / Cols);
        ImGuiListClipper clipper;
        clipper.Begin(line_total_count, s.LineHeight);

        bool data_next = false;

-        if (ReadOnly || DataEditingAddr >= mem_size)
+        if (DataEditingAddr >= mem_size)
            DataEditingAddr = (size_t)-1;
        if (DataPreviewAddr >= mem_size)
            DataPreviewAddr = (size_t)-1;
@@ -249,16 +278,16 @@ struct MemoryEditor
        if (DataEditingAddr != (size_t)-1)
        {
            // Move cursor but only apply on next frame so scrolling with be synchronized (because currently we can't change the scrolling while the window is being rendered)
-            if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_UpArrow)) && (ptrdiff_t)DataEditingAddr >= (ptrdiff_t)Cols)                     { data_editing_addr_next = DataEditingAddr - Cols; }
-            else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_DownArrow)) && (ptrdiff_t)DataEditingAddr < (ptrdiff_t)mem_size - Cols)    { data_editing_addr_next = DataEditingAddr + Cols; }
-            else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_LeftArrow)) && (ptrdiff_t)DataEditingAddr > (ptrdiff_t)0)                  { data_editing_addr_next = DataEditingAddr - 1; }
-            else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_RightArrow)) && (ptrdiff_t)DataEditingAddr < (ptrdiff_t)mem_size - 1)      { data_editing_addr_next = DataEditingAddr + 1; }
+            if (ImGui::IsKeyPressed(ImGuiKey_UpArrow) && (ptrdiff_t)DataEditingAddr >= (ptrdiff_t)Cols)                 { data_editing_addr_next = DataEditingAddr - Cols; }
+            else if (ImGui::IsKeyPressed(ImGuiKey_DownArrow) && (ptrdiff_t)DataEditingAddr < (ptrdiff_t)mem_size - Cols){ data_editing_addr_next = DataEditingAddr + Cols; }
+            else if (ImGui::IsKeyPressed(ImGuiKey_LeftArrow) && (ptrdiff_t)DataEditingAddr > (ptrdiff_t)0)              { data_editing_addr_next = DataEditingAddr - 1; }
+            else if (ImGui::IsKeyPressed(ImGuiKey_RightArrow) && (ptrdiff_t)DataEditingAddr < (ptrdiff_t)mem_size - 1)  { data_editing_addr_next = DataEditingAddr + 1; }
        }

        // Draw vertical separator
        ImVec2 window_pos = ImGui::GetWindowPos();
        if (OptShowAscii)
-            draw_list->AddLine(ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y), ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y + 9999), ImGui::GetColorU32(ImGuiCol_Border));
+            draw_list->AddLine(ImVec2(window_pos.x + s.OffsetAsciiMinX - s.GlyphWidth, window_pos.y), ImVec2(window_pos.x + s.OffsetAsciiMinX - s.GlyphWidth, window_pos.y + 9999), ImGui::GetColorU32(ImGuiCol_Border));

        const ImU32 color_text = ImGui::GetColorU32(ImGuiCol_Text);
        const ImU32 color_disabled = OptGreyOutZeroes ? ImGui::GetColorU32(ImGuiCol_TextDisabled) : color_text;
@@ -268,36 +297,51 @@ struct MemoryEditor
        const char* format_byte = OptUpperCaseHex ? "%02X" : "%02x";
        const char* format_byte_space = OptUpperCaseHex ? "%02X " : "%02x ";

+        MouseHovered = false;
+        MouseHoveredAddr = 0;
+
        while (clipper.Step())
            for (int line_i = clipper.DisplayStart; line_i < clipper.DisplayEnd; line_i++) // display only visible lines
            {
-                size_t addr = (size_t)(line_i * Cols);
+                size_t addr = (size_t)line_i * Cols;
                ImGui::Text(format_address, s.AddrDigitsCount, base_display_addr + addr);

                // Draw Hexadecimal
                for (int n = 0; n < Cols && addr < mem_size; n++, addr++)
                {
-                    float byte_pos_x = s.PosHexStart + s.HexCellWidth * n;
+                    float byte_pos_x = s.OffsetHexMinX + s.HexCellWidth * n;
                    if (OptMidColsCount > 0)
                        byte_pos_x += (float)(n / OptMidColsCount) * s.SpacingBetweenMidCols;
                    ImGui::SameLine(byte_pos_x);

-                    // Draw highlight
-                    bool is_highlight_from_user_range = (addr >= HighlightMin && addr < HighlightMax);
-                    bool is_highlight_from_user_func = (HighlightFn && HighlightFn(mem_data, addr));
-                    bool is_highlight_from_preview = (addr >= DataPreviewAddr && addr < DataPreviewAddr + preview_data_type_size);
+                    // Draw highlight or custom background color
+                    const bool is_highlight_from_user_range = (addr >= HighlightMin && addr < HighlightMax);
+                    const bool is_highlight_from_user_func = (HighlightFn && HighlightFn(mem_data, addr, UserData));
+                    const bool is_highlight_from_preview = (addr >= DataPreviewAddr && addr < DataPreviewAddr + preview_data_type_size);
+
+                    ImU32 bg_color = 0;
+                    bool is_next_byte_highlighted = false;
                    if (is_highlight_from_user_range || is_highlight_from_user_func || is_highlight_from_preview)
                    {
-                        ImVec2 pos = ImGui::GetCursorScreenPos();
-                        float highlight_width = s.GlyphWidth * 2;
-                        bool is_next_byte_highlighted = (addr + 1 < mem_size) && ((HighlightMax != (size_t)-1 && addr + 1 < HighlightMax) || (HighlightFn && HighlightFn(mem_data, addr + 1)));
+                        is_next_byte_highlighted = (addr + 1 < mem_size) && ((HighlightMax != (size_t)-1 && addr + 1 < HighlightMax) || (HighlightFn && HighlightFn(mem_data, addr + 1, UserData)) || (addr + 1 < DataPreviewAddr + preview_data_type_size));
+                        bg_color = HighlightColor;
+                    }
+                    else if (BgColorFn != nullptr)
+                    {
+                        is_next_byte_highlighted = (addr + 1 < mem_size) && ((BgColorFn(mem_data, addr + 1, UserData) & IM_COL32_A_MASK) != 0);
+                        bg_color = BgColorFn(mem_data, addr, UserData);
+                    }
+                    if (bg_color != 0)
+                    {
+                        float bg_width = s.GlyphWidth * 2;
                        if (is_next_byte_highlighted || (n + 1 == Cols))
                        {
-                            highlight_width = s.HexCellWidth;
+                            bg_width = s.HexCellWidth;
                            if (OptMidColsCount > 0 && n > 0 && (n + 1) < Cols && ((n + 1) % OptMidColsCount) == 0)
-                                highlight_width += s.SpacingBetweenMidCols;
+                                bg_width += s.SpacingBetweenMidCols;
                        }
-                        draw_list->AddRectFilled(pos, ImVec2(pos.x + highlight_width, pos.y + s.LineHeight), HighlightColor);
+                        ImVec2 pos = ImGui::GetCursorScreenPos();
+                        draw_list->AddRectFilled(pos, ImVec2(pos.x + bg_width, pos.y + s.LineHeight), bg_color);
                    }

                    if (DataEditingAddr == addr)
@@ -308,17 +352,21 @@ struct MemoryEditor
                        if (DataEditingTakeFocus)
                        {
                            ImGui::SetKeyboardFocusHere(0);
-                            sprintf(AddrInputBuf, format_data, s.AddrDigitsCount, base_display_addr + addr);
-                            sprintf(DataInputBuf, format_byte, ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]);
+                            ImSnprintf(AddrInputBuf, 32, format_data, s.AddrDigitsCount, base_display_addr + addr);
+                            ImSnprintf(DataInputBuf, 32, format_byte, ReadFn ? ReadFn(mem_data, addr, UserData) : mem_data[addr]);
                        }
-                        struct UserData
+                        struct InputTextUserData
                        {
                            // FIXME: We should have a way to retrieve the text edit cursor position more easily in the API, this is rather tedious. This is such a ugly mess we may be better off not using InputText() at all here.
                            static int Callback(ImGuiInputTextCallbackData* data)
                            {
-                                UserData* user_data = (UserData*)data->UserData;
+                                InputTextUserData* user_data = (InputTextUserData*)data->UserData;
                                if (!data->HasSelection())
                                    user_data->CursorPos = data->CursorPos;
+#if IMGUI_VERSION_NUM < 19102
+                                if (data->Flags & ImGuiInputTextFlags_ReadOnly)
+                                    return 0;
+#endif
                                if (data->SelectionStart == 0 && data->SelectionEnd == data->BufTextLen)
                                {
                                    // When not editing a byte, always refresh its InputText content pulled from underlying memory data
@@ -334,39 +382,42 @@ struct MemoryEditor
                            char   CurrentBufOverwrite[3];  // Input
                            int    CursorPos;               // Output
                        };
-                        UserData user_data;
-                        user_data.CursorPos = -1;
-                        sprintf(user_data.CurrentBufOverwrite, format_byte, ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]);
+                        InputTextUserData input_text_user_data;
+                        input_text_user_data.CursorPos = -1;
+                        ImSnprintf(input_text_user_data.CurrentBufOverwrite, 3, format_byte, ReadFn ? ReadFn(mem_data, addr, UserData) : mem_data[addr]);
                        ImGuiInputTextFlags flags = ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_NoHorizontalScroll | ImGuiInputTextFlags_CallbackAlways;
-#if IMGUI_VERSION_NUM >= 18104
-                        flags |= ImGuiInputTextFlags_AlwaysOverwrite;
-#else
-                        flags |= ImGuiInputTextFlags_AlwaysInsertMode;
-#endif
+                        if (ReadOnly)
+                            flags |= ImGuiInputTextFlags_ReadOnly;
+                        flags |= ImGuiInputTextFlags_AlwaysOverwrite; // was ImGuiInputTextFlags_AlwaysInsertMode
                        ImGui::SetNextItemWidth(s.GlyphWidth * 2);
-                        if (ImGui::InputText("##data", DataInputBuf, IM_ARRAYSIZE(DataInputBuf), flags, UserData::Callback, &user_data))
+                        if (ImGui::InputText("##data", DataInputBuf, IM_ARRAYSIZE(DataInputBuf), flags, InputTextUserData::Callback, &input_text_user_data))
                            data_write = data_next = true;
                        else if (!DataEditingTakeFocus && !ImGui::IsItemActive())
                            DataEditingAddr = data_editing_addr_next = (size_t)-1;
                        DataEditingTakeFocus = false;
-                        if (user_data.CursorPos >= 2)
+                        if (input_text_user_data.CursorPos >= 2)
                            data_write = data_next = true;
                        if (data_editing_addr_next != (size_t)-1)
                            data_write = data_next = false;
                        unsigned int data_input_value = 0;
-                        if (data_write && sscanf(DataInputBuf, "%X", &data_input_value) == 1)
+                        if (!ReadOnly && data_write && sscanf(DataInputBuf, "%X", &data_input_value) == 1)
                        {
                            if (WriteFn)
-                                WriteFn(mem_data, addr, (ImU8)data_input_value);
+                                WriteFn(mem_data, addr, (ImU8)data_input_value, UserData);
                            else
                                mem_data[addr] = (ImU8)data_input_value;
                        }
+                        if (ImGui::IsItemHovered())
+                        {
+                            MouseHovered = true;
+                            MouseHoveredAddr = addr;
+                        }
                        ImGui::PopID();
                    }
                    else
                    {
                        // NB: The trailing space is not visible but ensure there's no gap that the mouse cannot click on.
-                        ImU8 b = ReadFn ? ReadFn(mem_data, addr) : mem_data[addr];
+                        ImU8 b = ReadFn ? ReadFn(mem_data, addr, UserData) : mem_data[addr];

                        if (OptShowHexII)
                        {
@@ -386,10 +437,15 @@ struct MemoryEditor
                            else
                                ImGui::Text(format_byte_space, b);
                        }
-                        if (!ReadOnly && ImGui::IsItemHovered() && ImGui::IsMouseClicked(0))
+                        if (ImGui::IsItemHovered())
                        {
-                            DataEditingTakeFocus = true;
-                            data_editing_addr_next = addr;
+                            MouseHovered = true;
+                            MouseHoveredAddr = addr;
+                            if (ImGui::IsMouseClicked(0))
+                            {
+                                DataEditingTakeFocus = true;
+                                data_editing_addr_next = addr;
+                            }
                        }
                    }
                }
@@ -397,15 +453,24 @@ struct MemoryEditor
                if (OptShowAscii)
                {
                    // Draw ASCII values
-                    ImGui::SameLine(s.PosAsciiStart);
+                    ImGui::SameLine(s.OffsetAsciiMinX);
                    ImVec2 pos = ImGui::GetCursorScreenPos();
-                    addr = line_i * Cols;
+                    addr = (size_t)line_i * Cols;
+
+                    const float mouse_off_x = ImGui::GetIO().MousePos.x - pos.x;
+                    const size_t mouse_addr = (mouse_off_x >= 0.0f && mouse_off_x < s.OffsetAsciiMaxX - s.OffsetAsciiMinX) ? addr + (size_t)(mouse_off_x / s.GlyphWidth) : (size_t)-1;
+
                    ImGui::PushID(line_i);
-                    if (ImGui::InvisibleButton("ascii", ImVec2(s.PosAsciiEnd - s.PosAsciiStart, s.LineHeight)))
+                    if (ImGui::InvisibleButton("ascii", ImVec2(s.OffsetAsciiMaxX - s.OffsetAsciiMinX, s.LineHeight)))
                    {
-                        DataEditingAddr = DataPreviewAddr = addr + (size_t)((ImGui::GetIO().MousePos.x - pos.x) / s.GlyphWidth);
+                        DataEditingAddr = DataPreviewAddr = mouse_addr;
                        DataEditingTakeFocus = true;
                    }
+                    if (ImGui::IsItemHovered())
+                    {
+                        MouseHovered = true;
+                        MouseHoveredAddr = mouse_addr;
+                    }
                    ImGui::PopID();
                    for (int n = 0; n < Cols && addr < mem_size; n++, addr++)
                    {
@@ -414,7 +479,11 @@ struct MemoryEditor
                            draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_FrameBg));
                            draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_TextSelectedBg));
                        }
-                        unsigned char c = ReadFn ? ReadFn(mem_data, addr) : mem_data[addr];
+                        else if (BgColorFn)
+                        {
+                            draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), BgColorFn(mem_data, addr, UserData));
+                        }
+                        unsigned char c = ReadFn ? ReadFn(mem_data, addr, UserData) : mem_data[addr];
                        char display_c = (c < 32 || c >= 128) ? '.' : c;
                        draw_list->AddText(pos, (display_c == c) ? color_text : color_disabled, &display_c, &display_c + 1);
                        pos.x += s.GlyphWidth;
@@ -422,10 +491,14 @@ struct MemoryEditor
                }
            }
        ImGui::PopStyleVar(2);
+        const float child_width = ImGui::GetWindowSize().x;
        ImGui::EndChild();

        // Notify the main window of our ideal child content size (FIXME: we are missing an API to get the contents size from the child)
+        ImVec2 backup_pos = ImGui::GetCursorScreenPos();
        ImGui::SetCursorPosX(s.WindowWidth);
+        ImGui::Dummy(ImVec2(0.0f, 0.0f));
+        ImGui::SetCursorScreenPos(backup_pos);

        if (data_next && DataEditingAddr + 1 < mem_size)
        {
@@ -450,18 +523,28 @@ struct MemoryEditor
            ImGui::Separator();
            DrawPreviewLine(s, mem_data, mem_size, base_display_addr);
        }
-    }

-    void DrawOptionsLine(const Sizes& s, void* mem_data, size_t mem_size, size_t base_display_addr)
-    {
-        IM_UNUSED(mem_data);
-        ImGuiStyle& style = ImGui::GetStyle();
-        const char* format_range = OptUpperCaseHex ? "Range %0*" _PRISizeT "X..%0*" _PRISizeT "X" : "Range %0*" _PRISizeT "x..%0*" _PRISizeT "x";
+        if (GotoAddr != (size_t)-1)
+        {
+            if (GotoAddr < mem_size)
+            {
+                ImGui::BeginChild("##scrolling");
+                ImGui::SetScrollY((GotoAddr / Cols) * ImGui::GetTextLineHeight() - avail_size.y * 0.5f);
+                ImGui::EndChild();
+                DataEditingAddr = DataPreviewAddr = GotoAddr;
+                DataEditingTakeFocus = true;
+            }
+            GotoAddr = (size_t)-1;
+        }

-        // Options menu
-        if (ImGui::Button("Options"))
-            ImGui::OpenPopup("context");
-        if (ImGui::BeginPopup("context"))
+        const ImVec2 contents_pos_end(contents_pos_start.x + child_width, ImGui::GetCursorScreenPos().y);
+        //ImGui::GetForegroundDrawList()->AddRect(contents_pos_start, contents_pos_end, IM_COL32(255, 0, 0, 255));
+        if (OptShowOptions)
+            if (ImGui::IsMouseHoveringRect(contents_pos_start, contents_pos_end))
+                if (ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows) && ImGui::IsMouseReleased(ImGuiMouseButton_Right))
+                    ImGui::OpenPopup("OptionsPopup");
+
+        if (ImGui::BeginPopup("OptionsPopup"))
        {
            ImGui::SetNextItemWidth(s.GlyphWidth * 7 + style.FramePadding.x * 2.0f);
            if (ImGui::DragInt("##cols", &Cols, 0.2f, 4, 32, "%d cols")) { ContentsWidthChanged = true; if (Cols < 1) Cols = 1; }
@@ -473,6 +556,17 @@ struct MemoryEditor

            ImGui::EndPopup();
        }
+    }
+
+    void DrawOptionsLine(const Sizes& s, void* mem_data, size_t mem_size, size_t base_display_addr)
+    {
+        IM_UNUSED(mem_data);
+        ImGuiStyle& style = ImGui::GetStyle();
+        const char* format_range = OptUpperCaseHex ? "Range %0*" _PRISizeT "X..%0*" _PRISizeT "X" : "Range %0*" _PRISizeT "x..%0*" _PRISizeT "x";
+
+        // Options menu
+        if (ImGui::Button("Options"))
+            ImGui::OpenPopup("OptionsPopup");

        ImGui::SameLine();
        ImGui::Text(format_range, s.AddrDigitsCount, base_display_addr, s.AddrDigitsCount, base_display_addr + mem_size - 1);
@@ -488,18 +582,11 @@ struct MemoryEditor
            }
        }

-        if (GotoAddr != (size_t)-1)
-        {
-            if (GotoAddr < mem_size)
-            {
-                ImGui::BeginChild("##scrolling");
-                ImGui::SetScrollFromPosY(ImGui::GetCursorStartPos().y + (GotoAddr / Cols) * ImGui::GetTextLineHeight());
-                ImGui::EndChild();
-                DataEditingAddr = DataPreviewAddr = GotoAddr;
-                DataEditingTakeFocus = true;
-            }
-            GotoAddr = (size_t)-1;
-        }
+        //if (MouseHovered)
+        //{
+        //    ImGui::SameLine();
+        //    ImGui::Text("Hovered: %p", MouseHoveredAddr);
+        //}
    }

    void DrawPreviewLine(const Sizes& s, void* mem_data_void, size_t mem_size, size_t base_display_addr)
@@ -511,16 +598,21 @@ struct MemoryEditor
        ImGui::Text("Preview as:");
        ImGui::SameLine();
        ImGui::SetNextItemWidth((s.GlyphWidth * 10.0f) + style.FramePadding.x * 2.0f + style.ItemInnerSpacing.x);
+
+        static const ImGuiDataType supported_data_types[] = { ImGuiDataType_S8, ImGuiDataType_U8, ImGuiDataType_S16, ImGuiDataType_U16, ImGuiDataType_S32, ImGuiDataType_U32, ImGuiDataType_S64, ImGuiDataType_U64, ImGuiDataType_Float, ImGuiDataType_Double };
        if (ImGui::BeginCombo("##combo_type", DataTypeGetDesc(PreviewDataType), ImGuiComboFlags_HeightLargest))
        {
-            for (int n = 0; n < ImGuiDataType_COUNT; n++)
-                if (ImGui::Selectable(DataTypeGetDesc((ImGuiDataType)n), PreviewDataType == n))
-                    PreviewDataType = (ImGuiDataType)n;
+            for (int n = 0; n < IM_ARRAYSIZE(supported_data_types); n++)
+            {
+                ImGuiDataType data_type = supported_data_types[n];
+                if (ImGui::Selectable(DataTypeGetDesc(data_type), PreviewDataType == data_type))
+                    PreviewDataType = data_type;
+            }
            ImGui::EndCombo();
        }
        ImGui::SameLine();
        ImGui::SetNextItemWidth((s.GlyphWidth * 6.0f) + style.FramePadding.x * 2.0f + style.ItemInnerSpacing.x);
-        ImGui::Combo("##combo_endianess", &PreviewEndianess, "LE\0BE\0\0");
+        ImGui::Combo("##combo_endianness", &PreviewEndianness, "LE\0BE\0\0");

        char buf[128] = "";
        float x = s.GlyphWidth * 6.0f;
@@ -537,18 +629,19 @@ struct MemoryEditor
        ImGui::Text("Bin"); ImGui::SameLine(x); ImGui::TextUnformatted(has_value ? buf : "N/A");
    }

-    // Utilities for Data Preview
+    // Utilities for Data Preview (since we don't access imgui_internal.h)
+    // FIXME: This technically depends on ImGuiDataType order.
    const char* DataTypeGetDesc(ImGuiDataType data_type) const
    {
        const char* descs[] = { "Int8", "Uint8", "Int16", "Uint16", "Int32", "Uint32", "Int64", "Uint64", "Float", "Double" };
-        IM_ASSERT(data_type >= 0 && data_type < ImGuiDataType_COUNT);
+        IM_ASSERT(data_type >= 0 && data_type < IM_ARRAYSIZE(descs));
        return descs[data_type];
    }

    size_t DataTypeGetSize(ImGuiDataType data_type) const
    {
        const size_t sizes[] = { 1, 1, 2, 2, 4, 4, 8, 8, sizeof(float), sizeof(double) };
-        IM_ASSERT(data_type >= 0 && data_type < ImGuiDataType_COUNT);
+        IM_ASSERT(data_type >= 0 && data_type < IM_ARRAYSIZE(sizes));
        return sizes[data_type];
    }

@@ -561,18 +654,18 @@ struct MemoryEditor

    bool IsBigEndian() const
    {
-        uint16_t x = 1;
+        ImU16 x = 1;
        char c[2];
        memcpy(c, &x, 2);
        return c[0] != 0;
    }

-    static void* EndianessCopyBigEndian(void* _dst, void* _src, size_t s, int is_little_endian)
+    static void* EndiannessCopyBigEndian(void* _dst, void* _src, size_t s, int is_little_endian)
    {
        if (is_little_endian)
        {
-            uint8_t* dst = (uint8_t*)_dst;
-            uint8_t* src = (uint8_t*)_src + s - 1;
+            ImU8* dst = (ImU8*)_dst;
+            ImU8* src = (ImU8*)_src + s - 1;
            for (int i = 0, n = (int)s; i < n; ++i)
                memcpy(dst++, src--, 1);
            return _dst;
@@ -583,7 +676,7 @@ struct MemoryEditor
        }
    }

-    static void* EndianessCopyLittleEndian(void* _dst, void* _src, size_t s, int is_little_endian)
+    static void* EndiannessCopyLittleEndian(void* _dst, void* _src, size_t s, int is_little_endian)
    {
        if (is_little_endian)
        {
@@ -591,23 +684,23 @@ struct MemoryEditor
        }
        else
        {
-            uint8_t* dst = (uint8_t*)_dst;
-            uint8_t* src = (uint8_t*)_src + s - 1;
+            ImU8* dst = (ImU8*)_dst;
+            ImU8* src = (ImU8*)_src + s - 1;
            for (int i = 0, n = (int)s; i < n; ++i)
                memcpy(dst++, src--, 1);
            return _dst;
        }
    }

-    void* EndianessCopy(void* dst, void* src, size_t size) const
+    void* EndiannessCopy(void* dst, void* src, size_t size) const
    {
-        static void* (*fp)(void*, void*, size_t, int) = NULL;
-        if (fp == NULL)
-            fp = IsBigEndian() ? EndianessCopyBigEndian : EndianessCopyLittleEndian;
-        return fp(dst, src, size, PreviewEndianess);
+        static void* (*fp)(void*, void*, size_t, int) = nullptr;
+        if (fp == nullptr)
+            fp = IsBigEndian() ? EndiannessCopyBigEndian : EndiannessCopyLittleEndian;
+        return fp(dst, src, size, PreviewEndianness);
    }

-    const char* FormatBinary(const uint8_t* buf, int width) const
+    const char* FormatBinary(const ImU8* buf, int width) const
    {
        IM_ASSERT(width <= 64);
        size_t out_n = 0;
@@ -627,19 +720,19 @@ struct MemoryEditor
    // [Internal]
    void DrawPreviewData(size_t addr, const ImU8* mem_data, size_t mem_size, ImGuiDataType data_type, DataFormat data_format, char* out_buf, size_t out_buf_size) const
    {
-        uint8_t buf[8];
+        ImU8 buf[8];
        size_t elem_size = DataTypeGetSize(data_type);
        size_t size = addr + elem_size > mem_size ? mem_size - addr : elem_size;
        if (ReadFn)
            for (int i = 0, n = (int)size; i < n; ++i)
-                buf[i] = ReadFn(mem_data, addr + i);
+                buf[i] = ReadFn(mem_data, addr + i, UserData);
        else
            memcpy(buf, mem_data + addr, size);

        if (data_format == DataFormat_Bin)
        {
-            uint8_t binbuf[8];
-            EndianessCopy(binbuf, buf, size);
+            ImU8 binbuf[8];
+            EndiannessCopy(binbuf, buf, size);
            ImSnprintf(out_buf, out_buf_size, "%s", FormatBinary(binbuf, (int)size * 8));
            return;
        }
@@ -649,84 +742,85 @@ struct MemoryEditor
        {
        case ImGuiDataType_S8:
        {
-            int8_t int8 = 0;
-            EndianessCopy(&int8, buf, size);
-            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%hhd", int8); return; }
-            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%02x", int8 & 0xFF); return; }
+            ImS8 data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%hhd", data); return; }
+            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%02x", data & 0xFF); return; }
            break;
        }
        case ImGuiDataType_U8:
        {
-            uint8_t uint8 = 0;
-            EndianessCopy(&uint8, buf, size);
-            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%hhu", uint8); return; }
-            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%02x", uint8 & 0XFF); return; }
+            ImU8 data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%hhu", data); return; }
+            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%02x", data & 0XFF); return; }
            break;
        }
        case ImGuiDataType_S16:
        {
-            int16_t int16 = 0;
-            EndianessCopy(&int16, buf, size);
-            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%hd", int16); return; }
-            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%04x", int16 & 0xFFFF); return; }
+            ImS16 data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%hd", data); return; }
+            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%04x", data & 0xFFFF); return; }
            break;
        }
        case ImGuiDataType_U16:
        {
-            uint16_t uint16 = 0;
-            EndianessCopy(&uint16, buf, size);
-            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%hu", uint16); return; }
-            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%04x", uint16 & 0xFFFF); return; }
+            ImU16 data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%hu", data); return; }
+            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%04x", data & 0xFFFF); return; }
            break;
        }
        case ImGuiDataType_S32:
        {
-            int32_t int32 = 0;
-            EndianessCopy(&int32, buf, size);
-            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%d", int32); return; }
-            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%08x", int32); return; }
+            ImS32 data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%d", data); return; }
+            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%08x", data); return; }
            break;
        }
        case ImGuiDataType_U32:
        {
-            uint32_t uint32 = 0;
-            EndianessCopy(&uint32, buf, size);
-            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%u", uint32); return; }
-            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%08x", uint32); return; }
+            ImU32 data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%u", data); return; }
+            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%08x", data); return; }
            break;
        }
        case ImGuiDataType_S64:
        {
-            int64_t int64 = 0;
-            EndianessCopy(&int64, buf, size);
-            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%lld", (long long)int64); return; }
-            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%016llx", (long long)int64); return; }
+            ImS64 data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%lld", (long long)data); return; }
+            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%016llx", (long long)data); return; }
            break;
        }
        case ImGuiDataType_U64:
        {
-            uint64_t uint64 = 0;
-            EndianessCopy(&uint64, buf, size);
-            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%llu", (long long)uint64); return; }
-            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%016llx", (long long)uint64); return; }
+            ImU64 data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%llu", (long long)data); return; }
+            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%016llx", (long long)data); return; }
            break;
        }
        case ImGuiDataType_Float:
        {
-            float float32 = 0.0f;
-            EndianessCopy(&float32, buf, size);
-            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%f", float32); return; }
-            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "%a", float32); return; }
+            float data = 0.0f;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%f", data); return; }
+            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "%a", data); return; }
            break;
        }
        case ImGuiDataType_Double:
        {
-            double float64 = 0.0;
-            EndianessCopy(&float64, buf, size);
-            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%f", float64); return; }
-            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "%a", float64); return; }
+            double data = 0.0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%f", data); return; }
+            if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "%a", data); return; }
            break;
        }
+        default:
        case ImGuiDataType_COUNT:
            break;
        } // Switch
@@ -315,7 +315,7 @@ static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0
      if (node->y > min_y) {
         // raise min_y higher.
         // we've accounted for all waste up to min_y,
-         // but we'll now add more waste for everything we've visted
+         // but we'll now add more waste for everything we've visited
         waste_area += visited_width * (node->y - min_y);
         min_y = node->y;
         // the first time through, visited_width might be reduced
@@ -470,7 +470,7 @@ static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, i

   // insert the new node into the right starting point, and
   // let 'cur' point to the remaining nodes needing to be
-   // stiched back in
+   // stitched back in

   cur = *res.prev_link;
   if (cur->x < res.x) {
@@ -5,7 +5,8 @@
 // - Fix in stb_textedit_find_charpos to handle last line (see https://github.com/ocornut/imgui/issues/6000 + #6783)
 // - Added name to struct or it may be forward declared in our code.
 // - Added UTF-8 support (see https://github.com/nothings/stb/issues/188 + https://github.com/ocornut/imgui/pull/7925)
-// Grep for [DEAR IMGUI] to find the changes.
+// - Changed STB_TEXTEDIT_INSERTCHARS() to return inserted count (instead of 0/1 bool), allowing partial insertion.
+// Grep for [DEAR IMGUI] to find some changes.
 // - Also renamed macros used or defined outside of IMSTB_TEXTEDIT_IMPLEMENTATION block from STB_TEXTEDIT_* to IMSTB_TEXTEDIT_*

 // stb_textedit.h - v1.14  - public domain - Sean Barrett
@@ -39,6 +40,7 @@
 //
 // VERSION HISTORY
 //
+//   !!!! (2025-10-23) changed STB_TEXTEDIT_INSERTCHARS() to return inserted count (instead of 0/1 bool), allowing partial insertion.
 //   1.14 (2021-07-11) page up/down, various fixes
 //   1.13 (2019-02-07) fix bug in undo size management
 //   1.12 (2018-01-29) user can change STB_TEXTEDIT_KEYTYPE, fix redo to avoid crash
@@ -141,12 +143,14 @@
 //                                        with previous char)
 //    STB_TEXTEDIT_KEYTOTEXT(k)         maps a keyboard input to an insertable character
 //                                        (return type is int, -1 means not valid to insert)
+//                                        (not supported if you want to use UTF-8, see below)
 //    STB_TEXTEDIT_GETCHAR(obj,i)       returns the i'th character of obj, 0-based
 //    STB_TEXTEDIT_NEWLINE              the character returned by _GETCHAR() we recognize
 //                                        as manually wordwrapping for end-of-line positioning
 //
 //    STB_TEXTEDIT_DELETECHARS(obj,i,n)      delete n characters starting at i
-//    STB_TEXTEDIT_INSERTCHARS(obj,i,c*,n)   insert n characters at i (pointed to by STB_TEXTEDIT_CHARTYPE*)
+//    STB_TEXTEDIT_INSERTCHARS(obj,i,c*,n)   try to insert n characters at i (pointed to by STB_TEXTEDIT_CHARTYPE*)
+//                                           returns number of characters actually inserted. [DEAR IMGUI]
 //
 //    STB_TEXTEDIT_K_SHIFT       a power of two that is or'd in to a keyboard input to represent the shift key
 //
@@ -178,6 +182,13 @@
 //    STB_TEXTEDIT_K_TEXTSTART2          secondary keyboard input to move cursor to start of text
 //    STB_TEXTEDIT_K_TEXTEND2            secondary keyboard input to move cursor to end of text
 //
+// To support UTF-8:
+//
+//    STB_TEXTEDIT_GETPREVCHARINDEX      returns index of previous character
+//    STB_TEXTEDIT_GETNEXTCHARINDEX      returns index of next character
+//    Do NOT define STB_TEXTEDIT_KEYTOTEXT.
+//    Instead, call stb_textedit_text() directly for text contents.
+//
 // Keyboard input must be encoded as a single integer value; e.g. a character code
 // and some bitflags that represent shift states. to simplify the interface, SHIFT must
 // be a bitflag, so we can test the shifted state of cursor movements to allow selection,
@@ -250,8 +261,10 @@
 //          if the STB_TEXTEDIT_KEYTOTEXT function is defined, selected keys are
 //          transformed into text and stb_textedit_text() is automatically called.
 //
-//      text: [DEAR IMGUI] added 2024-09
-//          call this to text inputs sent to the textfield.
+//      text: (added 2025)
+//          call this to directly send text input the textfield, which is required
+//          for UTF-8 support, because stb_textedit_key() + STB_TEXTEDIT_KEYTOTEXT()
+//          cannot infer text length.
 //
 //
 //   When rendering, you can read the cursor position and selection state from
@@ -400,6 +413,16 @@ typedef struct
 #define IMSTB_TEXTEDIT_memmove memmove
 #endif

+// [DEAR IMGUI]
+// Functions must be implemented for UTF8 support
+// Code in this file that uses those functions is modified for [DEAR IMGUI] and deviates from the original stb_textedit.
+// There is not necessarily a '[DEAR IMGUI]' at the usage sites.
+#ifndef IMSTB_TEXTEDIT_GETPREVCHARINDEX
+#define IMSTB_TEXTEDIT_GETPREVCHARINDEX(OBJ, IDX) ((IDX) - 1)
+#endif
+#ifndef IMSTB_TEXTEDIT_GETNEXTCHARINDEX
+#define IMSTB_TEXTEDIT_GETNEXTCHARINDEX(OBJ, IDX) ((IDX) + 1)
+#endif

 /////////////////////////////////////////////////////////////////////////////
 //
@@ -407,7 +430,7 @@ typedef struct
 //

 // traverse the layout to locate the nearest character to a display position
-static int stb_text_locate_coord(IMSTB_TEXTEDIT_STRING *str, float x, float y)
+static int stb_text_locate_coord(IMSTB_TEXTEDIT_STRING *str, float x, float y, int* out_side_on_line)
 {
   StbTexteditRow r;
   int n = STB_TEXTEDIT_STRINGLEN(str);
@@ -417,6 +440,7 @@ static int stb_text_locate_coord(IMSTB_TEXTEDIT_STRING *str, float x, float y)
   r.x0 = r.x1 = 0;
   r.ymin = r.ymax = 0;
   r.num_chars = 0;
+   *out_side_on_line = 0;

   // search rows to find one that straddles 'y'
   while (i < n) {
@@ -436,7 +460,10 @@ static int stb_text_locate_coord(IMSTB_TEXTEDIT_STRING *str, float x, float y)

   // below all text, return 'after' last character
   if (i >= n)
+   {
+      *out_side_on_line = 1;
      return n;
+   }

   // check if it's before the beginning of the line
   if (x < r.x0)
@@ -449,6 +476,7 @@ static int stb_text_locate_coord(IMSTB_TEXTEDIT_STRING *str, float x, float y)
      for (k=0; k < r.num_chars; k = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(str, i + k) - i) {
         float w = STB_TEXTEDIT_GETWIDTH(str, i, k);
         if (x < prev_x+w) {
+            *out_side_on_line = (k == 0) ? 0 : 1;
            if (x < prev_x+w/2)
               return k+i;
            else
@@ -460,6 +488,7 @@ static int stb_text_locate_coord(IMSTB_TEXTEDIT_STRING *str, float x, float y)
   }

   // if the last character is a newline, return that. otherwise return 'after' the last character
+   *out_side_on_line = 1;
   if (STB_TEXTEDIT_GETCHAR(str, i+r.num_chars-1) == STB_TEXTEDIT_NEWLINE)
      return i+r.num_chars-1;
   else
@@ -471,6 +500,7 @@ static void stb_textedit_click(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *st
 {
   // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse
   // goes off the top or bottom of the text
+   int side_on_line;
   if( state->single_line )
   {
      StbTexteditRow r;
@@ -478,16 +508,18 @@ static void stb_textedit_click(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *st
      y = r.ymin;
   }

-   state->cursor = stb_text_locate_coord(str, x, y);
+   state->cursor = stb_text_locate_coord(str, x, y, &side_on_line);
   state->select_start = state->cursor;
   state->select_end = state->cursor;
   state->has_preferred_x = 0;
+   str->LastMoveDirectionLR = (ImS8)(side_on_line ? ImGuiDir_Right : ImGuiDir_Left);
 }

 // API drag: on mouse drag, move the cursor and selection endpoint to the clicked location
 static void stb_textedit_drag(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
 {
   int p = 0;
+   int side_on_line;

   // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse
   // goes off the top or bottom of the text
@@ -501,8 +533,9 @@ static void stb_textedit_drag(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *sta
   if (state->select_start == state->select_end)
      state->select_start = state->cursor;

-   p = stb_text_locate_coord(str, x, y);
+   p = stb_text_locate_coord(str, x, y, &side_on_line);
   state->cursor = state->select_end = p;
+   str->LastMoveDirectionLR = (ImS8)(side_on_line ? ImGuiDir_Right : ImGuiDir_Left);
 }

 /////////////////////////////////////////////////////////////////////////////
@@ -552,6 +585,8 @@ static void stb_textedit_find_charpos(StbFindState *find, IMSTB_TEXTEDIT_STRING
      STB_TEXTEDIT_LAYOUTROW(&r, str, i);
      if (n < i + r.num_chars)
         break;
+      if (str->LastMoveDirectionLR == ImGuiDir_Right && str->Stb->cursor > 0 && str->Stb->cursor == i + r.num_chars && STB_TEXTEDIT_GETCHAR(str, i + r.num_chars - 1) != STB_TEXTEDIT_NEWLINE) // [DEAR IMGUI] Wrapping point handling
+         break;
      if (i + r.num_chars == z && z > 0 && STB_TEXTEDIT_GETCHAR(str, z - 1) != STB_TEXTEDIT_NEWLINE)  // [DEAR IMGUI] special handling for last line
         break;   // [DEAR IMGUI]
      prev_start = i;
@@ -648,15 +683,33 @@ static void stb_textedit_move_to_last(IMSTB_TEXTEDIT_STRING *str, STB_TexteditSt
   }
 }

-// [DEAR IMGUI]
-// Functions must be implemented for UTF8 support
-// Code in this file that uses those functions is modified for [DEAR IMGUI] and deviates from the original stb_textedit.
-// There is not necessarily a '[DEAR IMGUI]' at the usage sites.
-#ifndef IMSTB_TEXTEDIT_GETPREVCHARINDEX
-#define IMSTB_TEXTEDIT_GETPREVCHARINDEX(obj, idx) (idx - 1)
+// [DEAR IMGUI] Extracted this function so we can more easily add support for word-wrapping.
+#ifndef STB_TEXTEDIT_MOVELINESTART
+static int stb_textedit_move_line_start(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state, int cursor)
+{
+   if (state->single_line)
+      return 0;
+   while (cursor > 0) {
+      int prev = IMSTB_TEXTEDIT_GETPREVCHARINDEX(str, cursor);
+      if (STB_TEXTEDIT_GETCHAR(str, prev) == STB_TEXTEDIT_NEWLINE)
+         break;
+      cursor = prev;
+   }
+   return cursor;
+}
+#define STB_TEXTEDIT_MOVELINESTART stb_textedit_move_line_start
 #endif
-#ifndef IMSTB_TEXTEDIT_GETNEXTCHARINDEX
-#define IMSTB_TEXTEDIT_GETNEXTCHARINDEX(obj, idx) (idx + 1)
+#ifndef STB_TEXTEDIT_MOVELINEEND
+static int stb_textedit_move_line_end(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state, int cursor)
+{
+   int n = STB_TEXTEDIT_STRINGLEN(str);
+   if (state->single_line)
+      return n;
+   while (cursor < n && STB_TEXTEDIT_GETCHAR(str, cursor) != STB_TEXTEDIT_NEWLINE)
+      cursor = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(str, cursor);
+   return cursor;
+}
+#define STB_TEXTEDIT_MOVELINEEND stb_textedit_move_line_end
 #endif

 #ifdef STB_TEXTEDIT_IS_SPACE
@@ -668,9 +721,9 @@ static int is_word_boundary( IMSTB_TEXTEDIT_STRING *str, int idx )
 #ifndef STB_TEXTEDIT_MOVEWORDLEFT
 static int stb_textedit_move_to_word_previous( IMSTB_TEXTEDIT_STRING *str, int c )
 {
-   --c; // always move at least one character
-   while( c >= 0 && !is_word_boundary( str, c ) )
-      --c;
+   c = IMSTB_TEXTEDIT_GETPREVCHARINDEX( str, c ); // always move at least one character
+   while (c >= 0 && !is_word_boundary(str, c))
+      c = IMSTB_TEXTEDIT_GETPREVCHARINDEX(str, c);

   if( c < 0 )
      c = 0;
@@ -684,9 +737,9 @@ static int stb_textedit_move_to_word_previous( IMSTB_TEXTEDIT_STRING *str, int c
 static int stb_textedit_move_to_word_next( IMSTB_TEXTEDIT_STRING *str, int c )
 {
   const int len = STB_TEXTEDIT_STRINGLEN(str);
-   ++c; // always move at least one character
+   c = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(str, c); // always move at least one character
   while( c < len && !is_word_boundary( str, c ) )
-      ++c;
+      c = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(str, c);

   if( c > len )
      c = len;
@@ -725,7 +778,8 @@ static int stb_textedit_paste_internal(IMSTB_TEXTEDIT_STRING *str, STB_TexteditS
   stb_textedit_clamp(str, state);
   stb_textedit_delete_selection(str,state);
   // try to insert the characters
-   if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, text, len)) {
+   len = STB_TEXTEDIT_INSERTCHARS(str, state->cursor, text, len);
+   if (len) {
      stb_text_makeundo_insert(state, state->cursor, len);
      state->cursor += len;
      state->has_preferred_x = 0;
@@ -739,6 +793,7 @@ static int stb_textedit_paste_internal(IMSTB_TEXTEDIT_STRING *str, STB_TexteditS
 #define STB_TEXTEDIT_KEYTYPE int
 #endif

+// API key: process text input
 // [DEAR IMGUI] Added stb_textedit_text(), extracted out and called by stb_textedit_key() for backward compatibility.
 static void stb_textedit_text(IMSTB_TEXTEDIT_STRING* str, STB_TexteditState* state, const IMSTB_TEXTEDIT_CHARTYPE* text, int text_len)
 {
@@ -749,14 +804,15 @@ static void stb_textedit_text(IMSTB_TEXTEDIT_STRING* str, STB_TexteditState* sta
   if (state->insert_mode && !STB_TEXT_HAS_SELECTION(state) && state->cursor < STB_TEXTEDIT_STRINGLEN(str)) {
      stb_text_makeundo_replace(str, state, state->cursor, 1, 1);
      STB_TEXTEDIT_DELETECHARS(str, state->cursor, 1);
-      if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, text, text_len)) {
+      text_len = STB_TEXTEDIT_INSERTCHARS(str, state->cursor, text, text_len);
+      if (text_len) {
         state->cursor += text_len;
         state->has_preferred_x = 0;
      }
-   }
-   else {
+   } else {
      stb_textedit_delete_selection(str, state); // implicitly clamps
-      if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, text, text_len)) {
+      text_len = STB_TEXTEDIT_INSERTCHARS(str, state->cursor, text, text_len);
+      if (text_len) {
         stb_text_makeundo_insert(state, state->cursor, text_len);
         state->cursor += text_len;
         state->has_preferred_x = 0;
@@ -771,6 +827,7 @@ retry:
   switch (key) {
      default: {
 #ifdef STB_TEXTEDIT_KEYTOTEXT
+         // This is not suitable for UTF-8 support.
         int c = STB_TEXTEDIT_KEYTOTEXT(key);
         if (c > 0) {
            IMSTB_TEXTEDIT_CHARTYPE ch = (IMSTB_TEXTEDIT_CHARTYPE)c;
@@ -911,15 +968,16 @@ retry:

            // [DEAR IMGUI]
            // going down while being on the last line shouldn't bring us to that line end
-            if (STB_TEXTEDIT_GETCHAR(str, find.first_char + find.length - 1) != STB_TEXTEDIT_NEWLINE)
-               break;
+            //if (STB_TEXTEDIT_GETCHAR(str, find.first_char + find.length - 1) != STB_TEXTEDIT_NEWLINE)
+            //   break;

            // now find character position down a row
            state->cursor = start;
            STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor);
            x = row.x0;
-            for (i=0; i < row.num_chars; ++i) {
+            for (i=0; i < row.num_chars; ) {
               float dx = STB_TEXTEDIT_GETWIDTH(str, start, i);
+               int next = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(str, state->cursor);
               #ifdef IMSTB_TEXTEDIT_GETWIDTH_NEWLINE
               if (dx == IMSTB_TEXTEDIT_GETWIDTH_NEWLINE)
                  break;
@@ -927,10 +985,13 @@ retry:
               x += dx;
               if (x > goal_x)
                  break;
-               state->cursor = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(str, state->cursor);
+               i += next - state->cursor;
+               state->cursor = next;
            }
            stb_textedit_clamp(str, state);

+            if (state->cursor == find.first_char + find.length)
+               str->LastMoveDirectionLR = ImGuiDir_Left;
            state->has_preferred_x = 1;
            state->preferred_x = goal_x;

@@ -980,8 +1041,9 @@ retry:
            state->cursor = find.prev_first;
            STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor);
            x = row.x0;
-            for (i=0; i < row.num_chars; ++i) {
+            for (i=0; i < row.num_chars; ) {
               float dx = STB_TEXTEDIT_GETWIDTH(str, find.prev_first, i);
+               int next = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(str, state->cursor);
               #ifdef IMSTB_TEXTEDIT_GETWIDTH_NEWLINE
               if (dx == IMSTB_TEXTEDIT_GETWIDTH_NEWLINE)
                  break;
@@ -989,10 +1051,15 @@ retry:
               x += dx;
               if (x > goal_x)
                  break;
-               state->cursor = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(str, state->cursor);
+               i += next - state->cursor;
+               state->cursor = next;
            }
            stb_textedit_clamp(str, state);

+            if (state->cursor == find.first_char)
+               str->LastMoveDirectionLR = ImGuiDir_Right;
+            else if (state->cursor == find.prev_first)
+               str->LastMoveDirectionLR = ImGuiDir_Left;
            state->has_preferred_x = 1;
            state->preferred_x = goal_x;

@@ -1002,10 +1069,15 @@ retry:
            // go to previous line
            // (we need to scan previous line the hard way. maybe we could expose this as a new API function?)
            prev_scan = find.prev_first > 0 ? find.prev_first - 1 : 0;
-            while (prev_scan > 0 && STB_TEXTEDIT_GETCHAR(str, prev_scan - 1) != STB_TEXTEDIT_NEWLINE)
-               --prev_scan;
+            while (prev_scan > 0)
+            {
+               int prev = IMSTB_TEXTEDIT_GETPREVCHARINDEX(str, prev_scan);
+               if (STB_TEXTEDIT_GETCHAR(str, prev) == STB_TEXTEDIT_NEWLINE)
+                  break;
+               prev_scan = prev;
+            }
            find.first_char = find.prev_first;
-            find.prev_first = prev_scan;
+            find.prev_first = STB_TEXTEDIT_MOVELINESTART(str, state, prev_scan);
         }
         break;
      }
@@ -1079,10 +1151,7 @@ retry:
      case STB_TEXTEDIT_K_LINESTART:
         stb_textedit_clamp(str, state);
         stb_textedit_move_to_first(state);
-         if (state->single_line)
-            state->cursor = 0;
-         else while (state->cursor > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) != STB_TEXTEDIT_NEWLINE)
-            --state->cursor;
+         state->cursor = STB_TEXTEDIT_MOVELINESTART(str, state, state->cursor);
         state->has_preferred_x = 0;
         break;

@@ -1090,13 +1159,9 @@ retry:
      case STB_TEXTEDIT_K_LINEEND2:
 #endif
      case STB_TEXTEDIT_K_LINEEND: {
-         int n = STB_TEXTEDIT_STRINGLEN(str);
         stb_textedit_clamp(str, state);
-         stb_textedit_move_to_first(state);
-         if (state->single_line)
-             state->cursor = n;
-         else while (state->cursor < n && STB_TEXTEDIT_GETCHAR(str, state->cursor) != STB_TEXTEDIT_NEWLINE)
-             ++state->cursor;
+         stb_textedit_move_to_last(str, state);
+         state->cursor = STB_TEXTEDIT_MOVELINEEND(str, state, state->cursor);
         state->has_preferred_x = 0;
         break;
      }
@@ -1107,10 +1172,7 @@ retry:
      case STB_TEXTEDIT_K_LINESTART | STB_TEXTEDIT_K_SHIFT:
         stb_textedit_clamp(str, state);
         stb_textedit_prep_selection_at_cursor(state);
-         if (state->single_line)
-            state->cursor = 0;
-         else while (state->cursor > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) != STB_TEXTEDIT_NEWLINE)
-            --state->cursor;
+         state->cursor = STB_TEXTEDIT_MOVELINESTART(str, state, state->cursor);
         state->select_end = state->cursor;
         state->has_preferred_x = 0;
         break;
@@ -1119,13 +1181,9 @@ retry:
      case STB_TEXTEDIT_K_LINEEND2 | STB_TEXTEDIT_K_SHIFT:
 #endif
      case STB_TEXTEDIT_K_LINEEND | STB_TEXTEDIT_K_SHIFT: {
-         int n = STB_TEXTEDIT_STRINGLEN(str);
         stb_textedit_clamp(str, state);
         stb_textedit_prep_selection_at_cursor(state);
-         if (state->single_line)
-             state->cursor = n;
-         else while (state->cursor < n && STB_TEXTEDIT_GETCHAR(str, state->cursor) != STB_TEXTEDIT_NEWLINE)
-            ++state->cursor;
+         state->cursor = STB_TEXTEDIT_MOVELINEEND(str, state, state->cursor);
         state->select_end = state->cursor;
         state->has_preferred_x = 0;
         break;
@@ -1300,7 +1358,7 @@ static void stb_text_undo(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state)
   // check type of recorded action:
   if (u.insert_length) {
      // easy case: was a deletion, so we need to insert n characters
-      STB_TEXTEDIT_INSERTCHARS(str, u.where, &s->undo_char[u.char_storage], u.insert_length);
+      u.insert_length = STB_TEXTEDIT_INSERTCHARS(str, u.where, &s->undo_char[u.char_storage], u.insert_length);
      s->undo_char_point -= u.insert_length;
   }

@@ -1351,7 +1409,7 @@ static void stb_text_redo(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState *state)

   if (r.insert_length) {
      // easy case: need to insert n characters
-      STB_TEXTEDIT_INSERTCHARS(str, r.where, &s->undo_char[r.char_storage], r.insert_length);
+      r.insert_length = STB_TEXTEDIT_INSERTCHARS(str, r.where, &s->undo_char[r.char_storage], r.insert_length);
      s->redo_char_point += r.insert_length;
   }

@@ -886,7 +886,7 @@ STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, fl
 // xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap

 STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff);
-// the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel
+// the same as stbtt_GetCodepointBitmap, but you can specify a subpixel
 // shift for the character

 STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint);
@@ -4516,8 +4516,8 @@ static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex
            q2[0] = (float)x2;
            q2[1] = (float)y2;
            if (equal(q0,q1) || equal(q1,q2)) {
-               x0 = (int)verts[i-1].x;
-               y0 = (int)verts[i-1].y;
+               x0 = (int)verts[i-1].x; //-V1048
+               y0 = (int)verts[i-1].y; //-V1048
               x1 = (int)verts[i  ].x;
               y1 = (int)verts[i  ].y;
               if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) {
@@ -39,6 +39,7 @@
 #define ROBIN_HOOD_VERSION_PATCH 2  // for backwards-compatible bug fixes

 #include <algorithm>
+#include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <functional>
@@ -38,11 +38,12 @@ std::vector<Analog> &games::bc::get_analogs() {
    if (analogs.empty()) {
        analogs = GameAPI::Analogs::getAnalogs("Busou Shinki: Armored Princess Battle Conductor");

-        GameAPI::Analogs::sortAnalogs(
-                &analogs,
-                "Stick X",
-                "Stick Y"
-        );
+        using GameAPI::Analogs::AnalogType;
+
+        GameAPI::Analogs::sortAnalogsWithType(&analogs, {
+            { "Stick X", AnalogType::LinearCentered },
+            { "Stick Y", AnalogType::LinearCentered }
+        });
    }

    return analogs;
@@ -1,5 +1,7 @@
 #include "bi2x_hook.h"

+#if SPICE64
+
 #include <cstdint>
 #include "util/detour.h"
 #include "util/logging.h"
@@ -16,15 +18,19 @@ namespace games::ccj {
     */

    struct AIO_SCI_COMM {
+        uint8_t data[0xf8];
    };

    struct AIO_NMGR_IOB2 {
+        uint8_t data[0xe30];
    };

    struct AIO_IOB2_BI2X_TBS {
+        uint8_t data[0x4680];
    };

    struct AIO_IOB2_BI2X_WRFIRM {
+        uint8_t data[0x20f48];
    };

    struct AIO_NMGR_IOB__NODEINFO {
@@ -72,6 +78,12 @@ namespace games::ccj {
        AIO_IOB2_BI2X_AC1__OUTPUTDATA OutputData;
    };

+    // checked with UJK-001-2024060400
+    static_assert(sizeof(AIO_SCI_COMM) == 0xf8);
+    static_assert(sizeof(AIO_NMGR_IOB2) == 0xe30);
+    static_assert(sizeof(AIO_IOB2_BI2X_TBS) == 0x4680);
+    static_assert(sizeof(AIO_IOB2_BI2X_WRFIRM) == 0x20f48);
+
    static void write_iccr_led(Lights::ccj_lights_t light, uint8_t value);

    /*
@@ -622,3 +634,5 @@ namespace games::ccj {
                               aioNodeCtl_IsError, &aioNodeCtl_IsError_orig);
    }
 }
+
+#endif
@@ -1,5 +1,9 @@
 #pragma once

+#if SPICE64
+
 namespace games::ccj {
    void bi2x_hook_init();
 }
+
+#endif
@@ -65,12 +65,20 @@ namespace games::ccj {
        libutils::load_library("libaio-iob2_video.dll");
        libutils::load_library("win10actlog.dll");

+        // we do this to prevent this unexpectedly being unloaded
+        // which leads to D3D10Warp.dll_unloaded crash
+        libutils::load_library("d3d10warp.dll");
+
        detour::trampoline_try("execexe.dll", MAKEINTRESOURCE(11),
                               (void*)execexe_CreateFileW_hook,(void**)&execexe_CreateFileW_orig);

+#if SPICE64
+
        // insert BI2X hooks
        bi2x_hook_init();

+#endif
+
        // insert trackball hooks
        trackball_hook_init();

@@ -45,13 +45,14 @@ std::vector<Analog> &games::ccj::get_analogs() {
    if (analogs.empty()) {
        analogs = GameAPI::Analogs::getAnalogs("Chase Chase Jokers");

-        GameAPI::Analogs::sortAnalogs(
-                &analogs,
-                "Joystick X",
-                "Joystick Y",
-                "Trackball DX",
-                "Trackball DY"
-        );
+        using GameAPI::Analogs::AnalogType;
+
+        GameAPI::Analogs::sortAnalogsWithType(&analogs, {
+            { "Joystick X", AnalogType::LinearCentered },
+            { "Joystick Y", AnalogType::LinearCentered },
+            { "Trackball DX", AnalogType::LinearCentered },
+            { "Trackball DY", AnalogType::LinearCentered }
+        });
    }

    return analogs;
@@ -6,6 +6,7 @@
 #include "util/logging.h"
 #include "rawinput/rawinput.h"
 #include "games/io.h"
+#include "util/precise_timer.h"
 #include "util/utils.h"
 #include "io.h"

@@ -112,7 +113,7 @@ namespace games::ccj {
                static std::chrono::time_point<std::chrono::steady_clock> lastModified = std::chrono::steady_clock::now();
                static std::chrono::milliseconds debounceDuration(100);
                auto currentTime = std::chrono::steady_clock::now();
-                bool pressed = get_async_secondary_mouse() & 0x8000;
+                bool pressed = get_async_secondary_mouse();
                bool focused = GetForegroundWindow() == hWnd;

                if (focused && MOUSE_TRACKBALL_USE_TOGGLE && pressed && (currentTime - lastModified > debounceDuration)) {
@@ -243,6 +244,7 @@ namespace games::ccj {
        log_info("trackball", "thread start, use mouse: {}, toggle: {}", MOUSE_TRACKBALL, MOUSE_TRACKBALL_USE_TOGGLE);

        tbThread = new std::thread([&] {
+            timeutils::PreciseSleepTimer timer;
            while (tbThreadRunning) {
                if (hWnd && wndProc) {
                    wndProc(hWnd, WM_INPUT, RIM_INPUT, (LPARAM)fakeHandle);
@@ -251,7 +253,7 @@ namespace games::ccj {
                if (!tbThreadRunning)
                    break;

-                std::this_thread::sleep_for(10ms);
+                timer.sleep(10);
            }
        });
    }
@@ -8,6 +8,7 @@
 #include "hooks/setupapihook.h"
 #include "hooks/sleephook.h"
 #include "hooks/input/dinput8/hook.h"
+#include "util/deferlog.h"
 #include "util/utils.h"
 #include "util/libutils.h"
 #include "util/fileutils.h"
@@ -22,6 +23,7 @@
 #include "p3io/usbmem.h"

 #include "p4io/p4io.h"
+#include <cstring>

 using namespace acioemu;

@@ -52,9 +54,9 @@ namespace games::ddr {
        return SendMessage_real(hWnd, Msg, wParam, lParam);
    }

-    bool contains_only_ascii(const std::string& str) {
+    bool contains_only_ascii(const std::wstring& str) {
        for (auto c: str) {
-            if (static_cast<unsigned char>(c) > 127) {
+            if (c > 127) {
                return false;
            }
        }
@@ -79,24 +81,24 @@ namespace games::ddr {
        }

        if (fileutils::dir_exists(dir)) {
-            log_info("ddr", "looking for codecs in this directory: {}", dir.string());
+            log_info("ddr", "looking for codecs in this directory: {}", dir);
        } else {
-            log_info("ddr", "codecs directory not found: {}", dir.string());
+            log_info("ddr", "codecs directory not found: {}", dir);
            return;
        }

        for (const auto &file : std::filesystem::directory_iterator(dir)) {
            const auto &filename = file.path().filename();
-            const auto extension = strtolower(filename.extension().string());
+            const auto extension = filename.extension().wstring();

-            if (extension != ".dll") {
+            if (wcsicmp(extension.c_str(), L".dll") != 0) {
                continue;
            }

-            log_info("ddr", "found DLL: {}, size: {} bytes", filename.string(), file.file_size());
-            if (filename == "k-clvsd.dll" || filename.string().find("xactengine") == 0) {
+            log_info("ddr", "found DLL: {}, size: {} bytes", filename, file.file_size());
+            if (filename == "k-clvsd.dll" || filename.wstring().find(L"xactengine") == 0) {
                const std::wstring wcmd = L"regsvr32.exe /s \"" + file.path().wstring() + L"\"";
-                const std::string cmd = "regsvr32.exe /s \"" + file.path().string() + "\"";
+                const std::string cmd = fmt::format("regsvr32.exe /s \"{}\"", file.path());

                int result = 0;
                std::thread t([wcmd, &result]() {
@@ -108,18 +110,32 @@ namespace games::ddr {
                    log_info("ddr", "`{}` returned {}", cmd, result);
                } else {
                    log_warning("ddr", "`{}` failed, returned {}", cmd, result);
+                    deferredlogs::defer_error_messages({
+                        "DDR codec registration failure",
+                        fmt::format("    {} failed to register with error {}", filename, result)});
                }

-                if (!contains_only_ascii(file.path().string())) {
-                    log_warning(
-                        "ddr",
-                        "BAD PATH ERROR\n\n\n"
-                        "!!!                                                          !!!\n"
-                        "!!! filesystem path to codec contains non-ASCII characters!  !!!\n"
-                        "!!! this may cause the game to crash!                        !!!\n"
-                        "!!!                                                          !!!\n"
-                        );
-                }
+                static std::once_flag printed;
+                std::call_once(printed, [file]() {
+                    if (!contains_only_ascii(file.path().wstring())) {
+                        log_warning(
+                            "ddr",
+                            "BAD PATH ERROR\n\n"
+                            "!!!                                                          !!!\n"
+                            "!!! filesystem path to codec contains non-ASCII characters!  !!!\n"
+                            "!!! this may cause failures when loading codecs, and         !!!\n"
+                            "!!! potentially leading the game to crash!                   !!!\n"
+                            "!!!                                                          !!!\n"
+                            );
+
+                        deferredlogs::defer_error_messages({
+                            "path to DDR codecs contain non-Latin characters",
+                            "    this may lead to movies not playing, white screen issue,",
+                            "    game hanging, or potentially a crash",
+                            "    move the game to a directory that does not contain non-Latin characters",
+                            "    if you encountered any issues"});
+                    }
+                });
            }
        }
    }
@@ -275,4 +291,50 @@ namespace games::ddr {
        // dispose device hook
        devicehook_dispose();
    }
+
+    static void get_analog_xy_axis(Analog &analog, bool &less, bool &more) {
+        if (!analog.isSet()) {
+            return;
+        }
+        const auto value = GameAPI::Analogs::getState(RI_MGR, analog);
+
+        // stepmania linux source:
+        // https://github.com/stepmania/stepmania/blob/d55acb1ba26f1c5b5e3048d6d6c0bd116625216f/src/arch/InputHandler/InputHandler_Linux_Event.cpp#L410
+
+        // for example, value cap with range [0, 255]:
+        // 127 = 0.498, neutral
+        // 128 = 0.502, both
+        // apparently some adapters report values like above; this obviously makes a lot of
+        // assumptions about bit width of the HID value cap and how the adapter reports
+        // neutral/both values, but this is good enough for parity with stepmania and its many forks
+        if (0.5001f < value && value < 0.75f) {
+            less |= true;
+            more |= true;
+
+        } else if (value <= 0.25f) {
+            less |= true;
+        } else if (value >= 0.75f) {
+            more |= true;
+        }
+    }
+
+    void get_analog_x_axis(int player, bool &left, bool &right) {
+        if (player != 1 && player != 2) {
+            log_fatal("ddr", "invalid player number: {}, expected 1 or 2", player);
+            return;
+        }
+
+        auto &analog = get_analogs().at(player == 1 ? Analogs::P1_LEFT_RIGHT : Analogs::P2_LEFT_RIGHT);
+        get_analog_xy_axis(analog, left, right);
+    }
+
+    void get_analog_y_axis(int player, bool &up, bool &down) {
+        if (player != 1 && player != 2) {
+            log_fatal("ddr", "invalid player number: {}, expected 1 or 2", player);
+            return;
+        }
+
+        auto &analog = get_analogs().at(player == 1 ? Analogs::P1_UP_DOWN : Analogs::P2_UP_DOWN);
+        get_analog_xy_axis(analog, up, down);
+    }
 }
@@ -23,4 +23,7 @@ namespace games::ddr {
    private:
        void register_codecs();
    };
+
+    void get_analog_x_axis(int player, bool &left, bool &right);
+    void get_analog_y_axis(int player, bool &up, bool &down);
 }
@@ -35,142 +35,190 @@ std::vector<Button> &games::ddr::get_buttons() {
    return analogs;
 }

+
+std::string games::ddr::get_buttons_help() {
+    // keep to max 100 characters wide
+    return
+        "For DDR pad arrows, double check that simultaneous Left+Right and Up+Down can be detected.\n"
+        "You should boot the game, enter test menu, and use Foot Panel Check.\n\n"
+        "When mapping arrows, try the following in order:\n\n"
+        "  1. If your controller uses face buttons (A/B/X/Y), bind them here.\n"
+        "  2. If your controller supports XInput, use that.\n"
+        "  3. If your controller uses analog axis for arrows, try Analogs tab.\n"
+        "  4. Otherwise, you will need to use remapping software or get a better adapter."
+        ;
+}
+
+std::vector<Analog> &games::ddr::get_analogs() {
+    static std::vector<Analog> analogs;
+
+    if (analogs.empty()) {
+        analogs = GameAPI::Analogs::getAnalogs("Dance Dance Revolution");
+
+        using namespace GameAPI::Analogs;
+
+        GameAPI::Analogs::sortAnalogsWithType(&analogs, {
+            { "P1 Left-Right (Axis Fix)", AnalogType::LinearCentered },
+            { "P1 Up-Down (Axis Fix)", AnalogType::LinearCentered },
+            { "P2 Left-Right (Axis Fix)", AnalogType::LinearCentered },
+            { "P2 Up-Down (Axis Fix)", AnalogType::LinearCentered }
+        });
+    }
+    return analogs;
+}
+
+std::string games::ddr::get_analogs_help() {
+    // keep to max 100 characters wide
+    return
+        "Only use this if your DDR pad outputs analog axis for arrows.\n\n"
+        "If the pad uses face buttons (A/B/X/Y), use Buttons tab instead.\n\n"
+        "Spice will treat values <=25% as Left, >=75% as Right, ~=50% as neutral,\n"
+        "and value between 50% and 75% as both arrows.\n\n"
+        "This is the classic Stepmania \"Axis Fix\" which may or may not work with\n"
+        "your dance pad or your adapter."
+        ;
+}
+
 std::vector<Light> &games::ddr::get_lights() {
    static std::vector<Light> lights;

    if (lights.empty()) {
        lights = GameAPI::Lights::getLights("Dance Dance Revolution");

-        GameAPI::Lights::sortLights(
-                &lights,
-                "P1 Foot Left",
-                "P1 Foot Up",
-                "P1 Foot Right",
-                "P1 Foot Down",
-                "P2 Foot Left",
-                "P2 Foot Up",
-                "P2 Foot Right",
-                "P2 Foot Down",
-                "Spot Red",
-                "Spot Blue",
-                "Top Spot Red",
-                "Top Spot Blue",
-                "P1 Halogen Upper",
-                "P1 Halogen Lower",
-                "P2 Halogen Upper",
-                "P2 Halogen Lower",
-                "P1 Button",
-                "P2 Button",
-                "Neon",
-                "HD P1 Start",
-                "HD P1 Menu Left-Right",
-                "HD P1 Menu Up-Down",
-                "HD P2 Start",
-                "HD P2 Menu Left-Right",
-                "HD P2 Menu Up-Down",
-                "HD P1 Speaker F R",
-                "HD P1 Speaker F G",
-                "HD P1 Speaker F B",
-                "HD P1 Speaker W R",
-                "HD P1 Speaker W G",
-                "HD P1 Speaker W B",
-                "HD P2 Speaker F R",
-                "HD P2 Speaker F G",
-                "HD P2 Speaker F B",
-                "HD P2 Speaker W R",
-                "HD P2 Speaker W G",
-                "HD P2 Speaker W B",
+        GameAPI::Lights::sortLightsWithCategory(
+            &lights,
+            {
+                {"General", "P1 Foot Left"},
+                {"General", "P1 Foot Up"},
+                {"General", "P1 Foot Right"},
+                {"General", "P1 Foot Down"},
+                {"General", "P2 Foot Left"},
+                {"General", "P2 Foot Up"},
+                {"General", "P2 Foot Right"},
+                {"General", "P2 Foot Down"},

-                "WHITE Speaker Top R",
-                "WHITE Speaker Top G",
-                "WHITE Speaker Top B",
-                "WHITE Speaker Bottom R",
-                "WHITE Speaker Bottom G",
-                "WHITE Speaker Bottom B",
-                "WHITE Woofer R",
-                "WHITE Woofer G",
-                "WHITE Woofer B",
+                {"SD", "Spot Red"},
+                {"SD", "Spot Blue"},
+                {"SD", "Top Spot Red"},
+                {"SD", "Top Spot Blue"},
+                {"SD", "P1 Halogen Upper"},
+                {"SD", "P1 Halogen Lower"},
+                {"SD", "P2 Halogen Upper"},
+                {"SD", "P2 Halogen Lower"},
+                {"SD", "P1 Button"},
+                {"SD", "P2 Button"},
+                {"SD", "Neon"},

-                "GOLD P1 Menu Start",
-                "GOLD P1 Menu Up",
-                "GOLD P1 Menu Down",
-                "GOLD P1 Menu Left",
-                "GOLD P1 Menu Right",
+                {"HD", "HD P1 Start"},
+                {"HD", "HD P1 Menu Left-Right"},
+                {"HD", "HD P1 Menu Up-Down"},
+                {"HD", "HD P2 Start"},
+                {"HD", "HD P2 Menu Left-Right"},
+                {"HD", "HD P2 Menu Up-Down"},
+                {"HD", "HD P1 Speaker F R"},
+                {"HD", "HD P1 Speaker F G"},
+                {"HD", "HD P1 Speaker F B"},
+                {"HD", "HD P1 Speaker W R"},
+                {"HD", "HD P1 Speaker W G"},
+                {"HD", "HD P1 Speaker W B"},
+                {"HD", "HD P2 Speaker F R"},
+                {"HD", "HD P2 Speaker F G"},
+                {"HD", "HD P2 Speaker F B"},
+                {"HD", "HD P2 Speaker W R"},
+                {"HD", "HD P2 Speaker W G"},
+                {"HD", "HD P2 Speaker W B"},

-                "GOLD P2 Menu Start",
-                "GOLD P2 Menu Up",
-                "GOLD P2 Menu Down",
-                "GOLD P2 Menu Left",
-                "GOLD P2 Menu Right",
+                {"WHITE", "WHITE Speaker Top R"},
+                {"WHITE", "WHITE Speaker Top G"},
+                {"WHITE", "WHITE Speaker Top B"},
+                {"WHITE", "WHITE Speaker Bottom R"},
+                {"WHITE", "WHITE Speaker Bottom G"},
+                {"WHITE", "WHITE Speaker Bottom B"},
+                {"WHITE", "WHITE Woofer R"},
+                {"WHITE", "WHITE Woofer G"},
+                {"WHITE", "WHITE Woofer B"},

-                "GOLD Title Panel Left",
-                "GOLD Title Panel Center",
-                "GOLD Title Panel Right",
+                {"GOLD", "GOLD P1 Menu Start"},
+                {"GOLD", "GOLD P1 Menu Up"},
+                {"GOLD", "GOLD P1 Menu Down"},
+                {"GOLD", "GOLD P1 Menu Left"},
+                {"GOLD", "GOLD P1 Menu Right"},

-                "GOLD P1 Woofer Corner",
-                "GOLD P2 Woofer Corner",
+                {"GOLD", "GOLD P2 Menu Start"},
+                {"GOLD", "GOLD P2 Menu Up"},
+                {"GOLD", "GOLD P2 Menu Down"},
+                {"GOLD", "GOLD P2 Menu Left"},
+                {"GOLD", "GOLD P2 Menu Right"},

-                "GOLD P1 Card Unit R",
-                "GOLD P1 Card Unit G",
-                "GOLD P1 Card Unit B",
+                {"GOLD", "GOLD Title Panel Left"},
+                {"GOLD", "GOLD Title Panel Center"},
+                {"GOLD", "GOLD Title Panel Right"},

-                "GOLD P2 Card Unit R",
-                "GOLD P2 Card Unit G",
-                "GOLD P2 Card Unit B",
+                {"GOLD", "GOLD P1 Woofer Corner"},
+                {"GOLD", "GOLD P2 Woofer Corner"},

-                "GOLD Top Panel Avg R",
-                "GOLD Top Panel Avg G",
-                "GOLD Top Panel Avg B",
+                {"GOLD", "GOLD P1 Card Unit R"},
+                {"GOLD", "GOLD P1 Card Unit G"},
+                {"GOLD", "GOLD P1 Card Unit B"},

-                "GOLD Monitor Side Left Avg R",
-                "GOLD Monitor Side Left Avg G",
-                "GOLD Monitor Side Left Avg B",
+                {"GOLD", "GOLD P2 Card Unit R"},
+                {"GOLD", "GOLD P2 Card Unit G"},
+                {"GOLD", "GOLD P2 Card Unit B"},

-                "GOLD Monitor Side Right Avg R",
-                "GOLD Monitor Side Right Avg G",
-                "GOLD Monitor Side Right Avg B",
+                {"GOLD", "GOLD Top Panel Avg R"},
+                {"GOLD", "GOLD Top Panel Avg G"},
+                {"GOLD", "GOLD Top Panel Avg B"},

-                "GOLD P1 Foot Up Avg R",
-                "GOLD P1 Foot Up Avg G",
-                "GOLD P1 Foot Up Avg B",
+                {"GOLD", "GOLD Monitor Side Left Avg R"},
+                {"GOLD", "GOLD Monitor Side Left Avg G"},
+                {"GOLD", "GOLD Monitor Side Left Avg B"},

-                "GOLD P1 Foot Down Avg R",
-                "GOLD P1 Foot Down Avg G",
-                "GOLD P1 Foot Down Avg B",
+                {"GOLD", "GOLD Monitor Side Right Avg R"},
+                {"GOLD", "GOLD Monitor Side Right Avg G"},
+                {"GOLD", "GOLD Monitor Side Right Avg B"},

-                "GOLD P1 Foot Left Avg R",
-                "GOLD P1 Foot Left Avg G",
-                "GOLD P1 Foot Left Avg B",
+                {"GOLD", "GOLD P1 Foot Up Avg R"},
+                {"GOLD", "GOLD P1 Foot Up Avg G"},
+                {"GOLD", "GOLD P1 Foot Up Avg B"},

-                "GOLD P1 Foot Right Avg R",
-                "GOLD P1 Foot Right Avg G",
-                "GOLD P1 Foot Right Avg B",
+                {"GOLD", "GOLD P1 Foot Down Avg R"},
+                {"GOLD", "GOLD P1 Foot Down Avg G"},
+                {"GOLD", "GOLD P1 Foot Down Avg B"},

-                "GOLD P2 Foot Up Avg R",
-                "GOLD P2 Foot Up Avg G",
-                "GOLD P2 Foot Up Avg B",
+                {"GOLD", "GOLD P1 Foot Left Avg R"},
+                {"GOLD", "GOLD P1 Foot Left Avg G"},
+                {"GOLD", "GOLD P1 Foot Left Avg B"},

-                "GOLD P2 Foot Down Avg R",
-                "GOLD P2 Foot Down Avg G",
-                "GOLD P2 Foot Down Avg B",
+                {"GOLD", "GOLD P1 Foot Right Avg R"},
+                {"GOLD", "GOLD P1 Foot Right Avg G"},
+                {"GOLD", "GOLD P1 Foot Right Avg B"},

-                "GOLD P2 Foot Left Avg R",
-                "GOLD P2 Foot Left Avg G",
-                "GOLD P2 Foot Left Avg B",
+                {"GOLD", "GOLD P2 Foot Up Avg R"},
+                {"GOLD", "GOLD P2 Foot Up Avg G"},
+                {"GOLD", "GOLD P2 Foot Up Avg B"},

-                "GOLD P2 Foot Right Avg R",
-                "GOLD P2 Foot Right Avg G",
-                "GOLD P2 Foot Right Avg B",
+                {"GOLD", "GOLD P2 Foot Down Avg R"},
+                {"GOLD", "GOLD P2 Foot Down Avg G"},
+                {"GOLD", "GOLD P2 Foot Down Avg B"},

-                "GOLD P1 Stage Corner Up-Left",
-                "GOLD P1 Stage Corner Up-Right",
-                "GOLD P1 Stage Corner Down-Left",
-                "GOLD P1 Stage Corner Down-Right",
+                {"GOLD", "GOLD P2 Foot Left Avg R"},
+                {"GOLD", "GOLD P2 Foot Left Avg G"},
+                {"GOLD", "GOLD P2 Foot Left Avg B"},

-                "GOLD P2 Stage Corner Up-Left",
-                "GOLD P2 Stage Corner Up-Right",
-                "GOLD P2 Stage Corner Down-Left",
-                "GOLD P2 Stage Corner Down-Right"
+                {"GOLD", "GOLD P2 Foot Right Avg R"},
+                {"GOLD", "GOLD P2 Foot Right Avg G"},
+                {"GOLD", "GOLD P2 Foot Right Avg B"},
+
+                {"GOLD", "GOLD P1 Stage Corner Up-Left"},
+                {"GOLD", "GOLD P1 Stage Corner Up-Right"},
+                {"GOLD", "GOLD P1 Stage Corner Down-Left"},
+                {"GOLD", "GOLD P1 Stage Corner Down-Right"},
+
+                {"GOLD", "GOLD P2 Stage Corner Up-Left"},
+                {"GOLD", "GOLD P2 Stage Corner Up-Right"},
+                {"GOLD", "GOLD P2 Stage Corner Down-Left"},
+                {"GOLD", "GOLD P2 Stage Corner Down-Right"}
+            }
        );
    }

@@ -33,6 +33,16 @@ namespace games::ddr {
        };
    }

+    // all analogs in correct order
+    namespace Analogs {
+        enum {
+            P1_LEFT_RIGHT,
+            P1_UP_DOWN,
+            P2_LEFT_RIGHT,
+            P2_UP_DOWN
+        };
+    }
+
    // all lights in correct order
    namespace Lights {
        enum {
@@ -177,5 +187,8 @@ namespace games::ddr {

    // getters
    std::vector<Button> &get_buttons();
+    std::string get_buttons_help();
+    std::string get_analogs_help();
+    std::vector<Analog> &get_analogs();
    std::vector<Light> &get_lights();
 }
@@ -3,6 +3,7 @@
 #include "cfg/api.h"
 #include "rawinput/rawinput.h"
 #include "util/logging.h"
+#include "util/precise_timer.h"
 #include "util/utils.h"

 #include "../ddr.h"
@@ -282,7 +283,7 @@ int games::ddr::DDRP3IOHandle::write(LPCVOID lpBuffer, DWORD nNumberOfBytesToWri
                }

                // use both sat spots for a neon pulse
-                float value_neon = (light_bits & hd_mapping_bits[0] && hd_mapping_bits[1]) ? 1.f : 0.f;
+                float value_neon = (light_bits & hd_mapping_bits[0] && light_bits & hd_mapping_bits[1]) ? 1.f : 0.f;
                GameAPI::Lights::writeLight(RI_MGR, lights[Lights::NEON], value_neon);
            }

@@ -459,7 +460,8 @@ int games::ddr::DDRP3IOHandle::device_io(
    if (nOutBufferSize >= 4) {

        // cool down
-        Sleep(1);
+        static thread_local timeutils::PreciseSleepTimer timer;
+        timer.sleep(1);

        // get controls as single variable (4 bytes)
        auto &controls = *(uint32_t*) lpOutBuffer;
@@ -498,32 +500,80 @@ int games::ddr::DDRP3IOHandle::device_io(

        // shift table
        static size_t shift_table[] = {
-                30, 28, 29, 8, 9, 10, 11, 12, 24, 25, 14, 15, 16, 17, 18, 19, 20, 26, 27, 22, 23
+                30, 28, 29,     // service, test, coin
+                8,              // p1 start
+                9, 10, 11, 12,  // p1 panel
+                24, 25, 14, 15, // p1 menu
+                16,             // p2 start
+                17, 18, 19, 20, // p2 panel
+                26, 27, 22, 23  // p2 menu 
        };
        static size_t button_table[] = {
                Buttons::SERVICE,
                Buttons::TEST,
                Buttons::COIN_MECH,
+
                Buttons::P1_START,
+
                Buttons::P1_PANEL_UP,
                Buttons::P1_PANEL_DOWN,
                Buttons::P1_PANEL_LEFT,
                Buttons::P1_PANEL_RIGHT,
+
                Buttons::P1_MENU_UP,
                Buttons::P1_MENU_DOWN,
                Buttons::P1_MENU_LEFT,
                Buttons::P1_MENU_RIGHT,
+
                Buttons::P2_START,
+
                Buttons::P2_PANEL_UP,
                Buttons::P2_PANEL_DOWN,
                Buttons::P2_PANEL_LEFT,
                Buttons::P2_PANEL_RIGHT,
+
                Buttons::P2_MENU_UP,
                Buttons::P2_MENU_DOWN,
                Buttons::P2_MENU_LEFT,
                Buttons::P2_MENU_RIGHT,
        };

+        // get analogs
+        struct {
+            bool up;
+            bool down;
+            bool left;
+            bool right;
+        } analog_values[2] = {};
+        games::ddr::get_analog_x_axis(1, analog_values[0].left, analog_values[0].right);
+        games::ddr::get_analog_y_axis(1, analog_values[0].up, analog_values[0].down);
+        games::ddr::get_analog_x_axis(2, analog_values[1].left, analog_values[1].right);
+        games::ddr::get_analog_y_axis(2, analog_values[1].up, analog_values[1].down);
+        if (analog_values[0].up) {
+            controls |= 1 << 9;
+        }
+        if (analog_values[0].down) {
+            controls |= 1 << 10;
+        }
+        if (analog_values[0].left) {
+            controls |= 1 << 11;
+        }
+        if (analog_values[0].right) {
+            controls |= 1 << 12;
+        }
+        if (analog_values[1].up) {
+            controls |= 1 << 17;
+        }
+        if (analog_values[1].down) {
+            controls |= 1 << 18;
+        }
+        if (analog_values[1].left) {
+            controls |= 1 << 19;
+        }
+        if (analog_values[1].right) {
+            controls |= 1 << 20;
+        }
+
        // update states
        auto &buttons = get_buttons();
        size_t count = 0;
@@ -2,6 +2,7 @@

 #include "rawinput/rawinput.h"
 #include "util/logging.h"
+#include "util/precise_timer.h"
 #include "util/utils.h"

 #include "../io.h"
@@ -253,28 +254,26 @@ namespace games::ddr {
        if(((dwIoControlCode>>16)&0xFFFF) == FILE_DEVICE_UNKNOWN) {
            switch((dwIoControlCode>>2)&0x3FFF) {
                case P4IO_IOCTL_GET_INPUTS: {
+                    
+                    // Prevents this function from being called at its normal 2000-2500 kHz cadence and overloading the CPU, instead reduces it to 250 Hz
+                    static thread_local timeutils::PreciseSleepTimer timer;
+                    timer.sleep(4);
+                    
                    memset(lpOutBuffer, 0, 16);
                    auto controls = (uint32_t*) lpOutBuffer;

                    const std::pair<size_t, uint8_t> buttonMapping[] =
                    {
+                        // Panel input comes from MDXF Control Status Buffer functions
                        {Buttons::SERVICE, 25}, //Good
                        {Buttons::TEST, 28}, //Good
                        {Buttons::COIN_MECH, 24}, //Good
                        {Buttons::P1_START, 0}, //Good
-                        {Buttons::P1_PANEL_UP, 5}, //Good
-                        {Buttons::P1_PANEL_DOWN, 6}, //Good
-                        {Buttons::P1_PANEL_LEFT, 7}, //Goood
-                        {Buttons::P1_PANEL_RIGHT, 16}, //Good
                        {Buttons::P1_MENU_UP, 1}, //Good
                        {Buttons::P1_MENU_DOWN, 2}, //Good
                        {Buttons::P1_MENU_LEFT, 3}, //Good
                        {Buttons::P1_MENU_RIGHT, 4}, //Good
                        {Buttons::P2_START, 8}, //Good
-                        {Buttons::P2_PANEL_UP, 13}, //Good
-                        {Buttons::P2_PANEL_DOWN, 14}, //Good
-                        {Buttons::P2_PANEL_LEFT, 15}, //Good
-                        {Buttons::P2_PANEL_RIGHT, 20}, //Good
                        {Buttons::P2_MENU_UP, 9}, //Good
                        {Buttons::P2_MENU_DOWN, 10}, //Good
                        {Buttons::P2_MENU_LEFT, 11}, //Good
@@ -7,7 +7,9 @@
 #include "games/game.h"
 #include "util/detour.h"
 #include "util/logging.h"
+#include "util/precise_timer.h"
 #include "util/memutils.h"
+#include "rgb_cam.h"

 #pragma pack(push)

@@ -150,6 +152,7 @@ namespace games::drs {
    char DRS_TAPELED[DRS_TAPELED_COLS_TOTAL][3] {};
    bool DISABLE_TOUCH = false;
    bool TRANSPOSE_TOUCH = false;
+    bool RGB_CAMERA_HOOK = false;

    std::vector<TouchEvent> TOUCH_EVENTS;

@@ -219,10 +222,11 @@ namespace games::drs {
    void start_touch() {
        std::thread t([] {
            log_info("drs", "starting touch input thread");
+            timeutils::PreciseSleepTimer timer;

            // main loop
            while (TRUE) {
-                std::this_thread::sleep_for(std::chrono::milliseconds(1));
+                timer.sleep(1);

                TOUCH_EVENTS.clear();
                touch_get_events(TOUCH_EVENTS);
@@ -313,6 +317,10 @@ namespace games::drs {
        } else {
            log_info("drs", "no native input method detected");
        }
+
+        if (RGB_CAMERA_HOOK) {
+            init_rgb_camera_hook();
+        }
    }

    void DRSGame::detach() {
@@ -31,6 +31,7 @@ namespace games::drs {
    extern std::vector<TouchEvent> TOUCH_EVENTS;
    extern bool DISABLE_TOUCH;
    extern bool TRANSPOSE_TOUCH;
+    extern bool RGB_CAMERA_HOOK;

    void fire_touches(drs_touch_t *events, size_t event_count);
    void start_touch();
@@ -0,0 +1,170 @@
+#include "games/drs/rgb_cam.h"
+
+// set version to Windows 7 to enable Media Foundation functions
+#ifdef _WIN32_WINNT
+#undef _WIN32_WINNT
+#endif
+#define _WIN32_WINNT 0x0601
+
+// turn on C-style COM objects
+#define CINTERFACE
+
+#include <mfobjects.h>
+#include <mfidl.h>
+#include <string>
+
+#include "avs/game.h"
+#include "cfg/configurator.h"
+#include "hooks/cfgmgr32hook.h"
+#include "util/detour.h"
+#include "util/memutils.h"
+#include "util/logging.h"
+#include "util/utils.h"
+
+static VTBL_TYPE(IMFActivate, GetAllocatedString) GetAllocatedString_orig = nullptr;
+static decltype(MFEnumDeviceSources) *MFEnumDeviceSources_orig = nullptr;
+
+namespace games::drs {
+
+    /*
+     * Camera related stuff
+     */
+    static std::wstring CAMERA0_ID;
+
+    static HRESULT WINAPI GetAllocatedString_hook(IMFActivate* This, REFGUID guidKey, LPWSTR *ppwszValue,
+                                                  UINT32 *pcchLength)
+    {
+        // call the original
+        HRESULT result = GetAllocatedString_orig(This, guidKey, ppwszValue, pcchLength);
+
+        // log the cam name
+        log_misc("drs::rgbcam", "obtained {}", ws2s(*ppwszValue));
+
+        // try first camera
+        wchar_t *pwc = nullptr;
+        if (CAMERA0_ID.length() == 23) {
+            pwc = wcsstr(*ppwszValue, CAMERA0_ID.c_str());
+        }
+
+        // check if camera could be identified
+        if (pwc) {
+
+            // fake the USB IDs
+            pwc[4] = L'2';
+            pwc[5] = L'8';
+            pwc[6] = L'8';
+            pwc[7] = L'c';
+
+            pwc[13] = L'0';
+            pwc[14] = L'0';
+            pwc[15] = L'0';
+            pwc[16] = L'2';
+
+            pwc[21] = L'0';
+            pwc[22] = L'0';
+
+            log_misc("drs::rgbcam", "replaced {}", ws2s(*ppwszValue));
+        }
+
+        // return original result
+        return result;
+    }
+
+    static void hook_camera(std::wstring camera_id, std::string camera_instance) {
+        // don't hook if camera 0 is already hooked
+        if (CAMERA0_ID.length() > 0) {
+            return;
+        }
+
+        // save the camera ID
+        CAMERA0_ID = camera_id;
+
+        // cfgmgr hook
+        CFGMGR32_HOOK_SETTING camera_setting;
+        camera_setting.device_instance = 0xDEADBEEF;
+        camera_setting.parent_instance = ~camera_setting.device_instance;
+        camera_setting.device_id = "USB\\VEN_8086&DEV_8C2D";
+        camera_setting.device_node_id = "USB\\VID_288C&PID_0002&MI_00\\?&????????&?&????";
+        if (camera_instance.length() == 17) {
+            for (int i = 0; i < 17; i++) {
+                camera_setting.device_node_id[28 + i] = camera_instance[i];
+            }
+        }
+        cfgmgr32hook_add(camera_setting);
+
+        log_info("drs::rgbcam", "hooked camera @ {}", ws2s(camera_id));
+    }
+
+    static void hook_camera_vtable(IMFActivate *camera) {
+
+        // hook allocated string method for camera identification
+        memutils::VProtectGuard camera_guard(camera->lpVtbl);
+        camera->lpVtbl->GetAllocatedString = GetAllocatedString_hook;
+    }
+
+    static HRESULT WINAPI MFEnumDeviceSources_hook(IMFAttributes *pAttributes, IMFActivate ***pppSourceActivate,
+                                                   UINT32 *pcSourceActivate) {
+
+        // call original function
+        HRESULT result_orig = MFEnumDeviceSources_orig(pAttributes, pppSourceActivate, pcSourceActivate);
+
+        // check for capture devices
+        if (FAILED(result_orig) || !*pcSourceActivate) {
+            return result_orig;
+        }
+
+        // get camera
+        IMFActivate *camera = **pppSourceActivate;
+
+        // save original method for later use
+        if (GetAllocatedString_orig == nullptr) {
+            GetAllocatedString_orig = camera->lpVtbl->GetAllocatedString;
+        }
+
+        // hook allocated string method for camera identification
+        hook_camera_vtable(camera);
+
+        // get camera link
+        LPWSTR camera_link_lpwstr;
+        UINT32 camera_link_length;
+        if (SUCCEEDED(GetAllocatedString_orig(
+                camera,
+                MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK,
+                &camera_link_lpwstr,
+                &camera_link_length))) {
+
+            // cut name to make ID
+            std::wstring camera_link_ws = std::wstring(camera_link_lpwstr);
+            std::wstring camera_id = camera_link_ws.substr(8, 23);
+
+            log_info("drs::rgbcam", "found video capture device: {}", ws2s(camera_link_ws));
+
+            // only support cameras that start with \\?\usb
+            if (!string_begins_with(camera_link_ws, L"\\\\?\\usb")) {
+                return result_orig;
+            }
+
+            // get camera instance
+            std::string camera_link = ws2s(camera_link_ws);
+            std::string camera_instance = camera_link.substr(32, 17);
+
+            // hook the camera
+            hook_camera(camera_id, camera_instance);
+        } else {
+            log_warning("drs::rgbcam", "failed to open camera");
+        }
+
+        // return result
+        return result_orig;
+    }
+
+    void init_rgb_camera_hook() {
+        log_info("drs::rgbcam", "initializing camera hook");
+
+        cfgmgr32hook_init(avs::game::DLL_INSTANCE);
+
+        // camera media framework hook
+        MFEnumDeviceSources_orig = detour::iat_try(
+                "MFEnumDeviceSources", MFEnumDeviceSources_hook, avs::game::DLL_INSTANCE);
+    }
+}
@@ -0,0 +1,5 @@
+#pragma once
+
+namespace games::drs {
+    void init_rgb_camera_hook();
+}
@@ -35,13 +35,14 @@ std::vector<Analog> &games::ftt::get_analogs() {
    if (analogs.empty()) {
        analogs = GameAPI::Analogs::getAnalogs("FutureTomTom");

-        GameAPI::Analogs::sortAnalogs(
-                &analogs,
-                "Pad 1",
-                "Pad 2",
-                "Pad 3",
-                "Pad 4"
-        );
+        using GameAPI::Analogs::AnalogType;
+
+        GameAPI::Analogs::sortAnalogsWithType(&analogs, {
+            { "Pad 1", AnalogType::LinearPositive },
+            { "Pad 2", AnalogType::LinearPositive },
+            { "Pad 3", AnalogType::LinearPositive },
+            { "Pad 4", AnalogType::LinearPositive }
+        });
    }

    return analogs;
@@ -0,0 +1,171 @@
+#include "asio.h"
+
+#include <windows.h>
+#include <cstring>
+
+#include "avs/game.h"
+#include "gitadora.h"
+#include "util/detour.h"
+#include "util/logging.h"
+
+namespace games::gitadora {
+
+    // Redirects the game's hard-coded "XONAR" ASIO driver lookup to the
+    // driver name in ASIO_DRIVER by intercepting registry calls to
+    // HKLM\SOFTWARE\ASIO. Sentinel HKEY values mark the redirected handles
+    // so we can recognise them on subsequent reg* calls.
+
+    static const HKEY PARENT_ASIO_REG_HANDLE = reinterpret_cast<HKEY>(0x4001);
+    static const HKEY DEVICE_ASIO_REG_HANDLE = reinterpret_cast<HKEY>(0x4002);
+    static const char *FAKE_ASIO_DEVICE_NAME = "XONAR";
+
+    static decltype(RegCloseKey) *RegCloseKey_orig = nullptr;
+    static decltype(RegEnumKeyA) *RegEnumKeyA_orig = nullptr;
+    static decltype(RegOpenKeyA) *RegOpenKeyA_orig = nullptr;
+    static decltype(RegOpenKeyExA) *RegOpenKeyExA_orig = nullptr;
+    static decltype(RegQueryValueExA) *RegQueryValueExA_orig = nullptr;
+
+    static HKEY real_asio_reg_handle = nullptr;
+    static HKEY real_asio_device_reg_handle = nullptr;
+
+    static LONG WINAPI RegOpenKeyExA_hook(HKEY hKey, LPCSTR lpSubKey, DWORD ulOptions, REGSAM samDesired,
+            PHKEY phkResult)
+    {
+        if (ASIO_DRIVER.has_value() &&
+            lpSubKey != nullptr &&
+            phkResult != nullptr &&
+            hKey == PARENT_ASIO_REG_HANDLE &&
+            _stricmp(lpSubKey, FAKE_ASIO_DEVICE_NAME) == 0) {
+
+            *phkResult = DEVICE_ASIO_REG_HANDLE;
+
+            log_info("gitadora::asio", "replacing '{}' with '{}'", lpSubKey, ASIO_DRIVER.value());
+            const auto result = RegOpenKeyExA_orig(
+                    real_asio_reg_handle,
+                    ASIO_DRIVER.value().c_str(),
+                    ulOptions,
+                    samDesired,
+                    &real_asio_device_reg_handle);
+
+            if (result != ERROR_SUCCESS) {
+                log_warning(
+                    "gitadora::asio",
+                    "failed to open registry subkey '{}', error=0x{:x}",
+                    ASIO_DRIVER.value(), result);
+                log_warning(
+                    "gitadora::asio",
+                    "due to improper ASIO setting, audio init will fail");
+            }
+
+            return result;
+        }
+
+        return RegOpenKeyExA_orig(hKey, lpSubKey, ulOptions, samDesired, phkResult);
+    }
+
+    static LONG WINAPI RegOpenKeyA_hook(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult) {
+        if (ASIO_DRIVER.has_value() &&
+            lpSubKey != nullptr &&
+            phkResult != nullptr &&
+            hKey == HKEY_LOCAL_MACHINE &&
+            _stricmp(lpSubKey, "software\\asio") == 0)
+        {
+            *phkResult = PARENT_ASIO_REG_HANDLE;
+            return RegOpenKeyA_orig(hKey, lpSubKey, &real_asio_reg_handle);
+        }
+
+        return RegOpenKeyA_orig(hKey, lpSubKey, phkResult);
+    }
+
+    static LONG WINAPI RegEnumKeyA_hook(HKEY hKey, DWORD dwIndex, LPSTR lpName, DWORD cchName) {
+        if (hKey == PARENT_ASIO_REG_HANDLE && ASIO_DRIVER.has_value()) {
+            if (dwIndex == 0) {
+                // forward to real handle just to verify the key exists; we
+                // overwrite the name with our fake driver string regardless
+                auto ret = RegEnumKeyA_orig(real_asio_reg_handle, dwIndex, lpName, cchName);
+                if (ret == ERROR_SUCCESS && lpName != nullptr && cchName > 0) {
+                    log_info("gitadora::asio", "stubbing '{}' with '{}'", lpName, FAKE_ASIO_DEVICE_NAME);
+                    strncpy(lpName, FAKE_ASIO_DEVICE_NAME, cchName);
+                    lpName[cchName - 1] = '\0';
+                }
+                return ret;
+            } else {
+                return ERROR_NO_MORE_ITEMS;
+            }
+        }
+
+        return RegEnumKeyA_orig(hKey, dwIndex, lpName, cchName);
+    }
+
+    static LONG WINAPI RegQueryValueExA_hook(HKEY hKey, LPCSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType,
+            LPBYTE lpData, LPDWORD lpcbData)
+    {
+        HKEY target = hKey;
+
+        if (ASIO_DRIVER.has_value() &&
+            lpValueName != nullptr &&
+            lpData != nullptr &&
+            lpcbData != nullptr &&
+            hKey == DEVICE_ASIO_REG_HANDLE) {
+            if (_stricmp(lpValueName, "Description") == 0) {
+                // engine may verify the driver name after open; ensure it still
+                // sees something containing "XONAR" so the substring check passes
+                const size_t len = strlen(FAKE_ASIO_DEVICE_NAME) + 1;
+                if (*lpcbData < len) {
+                    *lpcbData = static_cast<DWORD>(len);
+                    return ERROR_MORE_DATA;
+                }
+                memcpy(lpData, FAKE_ASIO_DEVICE_NAME, len);
+                *lpcbData = static_cast<DWORD>(len);
+                if (lpType != nullptr) {
+                    *lpType = REG_SZ;
+                }
+                return ERROR_SUCCESS;
+            }
+
+            // for everything else (CLSID etc.) defer to the real driver subkey
+            target = real_asio_device_reg_handle;
+        }
+
+        return RegQueryValueExA_orig(target, lpValueName, lpReserved, lpType, lpData, lpcbData);
+    }
+
+    static LONG WINAPI RegCloseKey_hook(HKEY hKey) {
+        if (hKey == PARENT_ASIO_REG_HANDLE) {
+            if (real_asio_reg_handle != nullptr) {
+                RegCloseKey_orig(real_asio_reg_handle);
+                real_asio_reg_handle = nullptr;
+            }
+            return ERROR_SUCCESS;
+        }
+
+        if (hKey == DEVICE_ASIO_REG_HANDLE) {
+            if (real_asio_device_reg_handle != nullptr) {
+                RegCloseKey_orig(real_asio_device_reg_handle);
+                real_asio_device_reg_handle = nullptr;
+            }
+            return ERROR_SUCCESS;
+        }
+
+        return RegCloseKey_orig(hKey);
+    }
+
+    void asio_hook_init() {
+        if (!ASIO_DRIVER.has_value()) {
+            return;
+        }
+
+        log_info("gitadora::asio", "installing ASIO driver redirect: XONAR -> {}", ASIO_DRIVER.value());
+
+        RegCloseKey_orig = detour::iat_try(
+                "RegCloseKey", RegCloseKey_hook, avs::game::DLL_INSTANCE);
+        RegEnumKeyA_orig = detour::iat_try(
+                "RegEnumKeyA", RegEnumKeyA_hook, avs::game::DLL_INSTANCE);
+        RegOpenKeyA_orig = detour::iat_try(
+                "RegOpenKeyA", RegOpenKeyA_hook, avs::game::DLL_INSTANCE);
+        RegOpenKeyExA_orig = detour::iat_try(
+                "RegOpenKeyExA", RegOpenKeyExA_hook, avs::game::DLL_INSTANCE);
+        RegQueryValueExA_orig = detour::iat_try(
+                "RegQueryValueExA", RegQueryValueExA_hook, avs::game::DLL_INSTANCE);
+    }
+}
@@ -0,0 +1,12 @@
+#pragma once
+
+namespace games::gitadora {
+
+    // installs IAT registry hooks in gfdm.dll that redirect the game's
+    // ASIO driver lookup (hard-coded "XONAR" substring) to a user-chosen
+    // driver name read from games::gitadora::ASIO_DRIVER.
+    //
+    // safe to call unconditionally; if ASIO_DRIVER is unset the hooks
+    // forward every call straight through to advapi32.
+    void asio_hook_init();
+}
@@ -0,0 +1,723 @@
+#include "bi2x_hook.h"
+
+#if SPICE64
+
+#include <optional>
+#include <cstdint>
+#include "util/detour.h"
+#include "util/logging.h"
+#include "rawinput/rawinput.h"
+#include "misc/eamuse.h"
+#include "games/io.h"
+#include "io.h"
+#include "util/tapeled.h"
+#include <typeinfo>
+
+namespace games::gitadora {
+
+    // /*
+    //  * class definitions
+    //  */
+
+    struct AIO_NMGR_IOB2 {
+        uint8_t data[0xe18];
+    };
+
+    struct AIO_IOB2_BI2X_AC1__SETTING {
+    };
+
+    struct AIO_NMGR_IOB5 {
+        uint8_t data[0xb10];
+    };
+
+    struct AIO_SCI_COMM {
+        uint8_t data[0x100];
+    };
+
+    struct AIO_IOB5_Y32D {
+        uint8_t data[0x2e8];
+    };
+
+    // struct AIO_IOB5_Y33I {
+    // };
+
+    struct AIO_IOB2_BI2X_AC1 {
+        uint8_t data[0x4570];
+    };
+
+    struct AIO_NMGR_IOB__NODEINFO {
+        uint8_t data[0xA8];
+    };
+
+    struct AIO_IOB2_BI2X_WRFIRM {
+        uint8_t data[0x20f48];
+    };
+
+    struct AIO_SCI_COMM_T {
+        uint64_t unk_0;
+        struct AIO_SCI_COMM *aioSciComm;
+    };
+
+    struct AIO_COMM_STATUS {
+        uint64_t unk[5];
+    };
+
+    struct AIO_IOB2_BI2X_AC1__INPUT {
+        uint8_t DevIoCounter;
+        uint8_t bExIoAErr;
+        uint8_t bExIoBErr;
+        uint8_t bPcPowerOn;
+        uint8_t bPcPowerCheck;
+        uint8_t bCoin1Jam;
+        uint8_t bCoin2Jam;
+        uint8_t bCoin3Jam;
+        uint8_t bCoin4Jam;
+        uint8_t Coin1Count;
+        uint8_t Coin2Count;
+        uint8_t Coin3Count;
+        uint8_t Coin4Count;
+        uint16_t AnalogCh1;
+        uint16_t AnalogCh2;
+        uint16_t AnalogCh3;
+        uint16_t AnalogCh4;
+        uint8_t CN8_8;
+        uint8_t CN8_9;
+        uint8_t CN8_10;
+        uint8_t CN9_8;
+        uint8_t CN9_9;
+        uint8_t CN9_10;
+        uint8_t CN11_11;
+        uint8_t CN11_12;
+        uint8_t CN11_13;
+        uint8_t CN11_14;
+        uint8_t CN11_15;
+        uint8_t CN11_16;
+        uint8_t CN11_17;
+        uint8_t CN11_18;
+        uint8_t CN11_19;
+        uint8_t CN11_20;
+        uint8_t CN12_11;
+        uint8_t CN12_12;
+        uint8_t CN12_13;
+        uint8_t CN12_14;
+        uint8_t CN12_15;
+        uint8_t CN12_16;
+        uint8_t CN12_17;
+        uint8_t CN12_18;
+        uint8_t CN12_19;
+        uint8_t CN12_20;
+        uint8_t CN12_21;
+        uint8_t CN12_22;
+        uint8_t CN12_23;
+        uint8_t CN12_24;
+        uint8_t CN15_3;
+        uint8_t CN15_4;
+        uint8_t CN15_5;
+        uint8_t CN15_6;
+        uint8_t CN15_7;
+        uint8_t CN15_8;
+        uint8_t CN15_9;
+        uint8_t CN15_10;
+        uint8_t CN15_11;
+        uint8_t CN15_12;
+        uint8_t CN15_13;
+        uint8_t CN15_14;
+        uint8_t CN15_15;
+        uint8_t CN15_16;
+        uint8_t CN15_17;
+        uint8_t CN15_18;
+        uint8_t CN15_19;
+        uint8_t CN15_20;
+        uint8_t CN19_8;
+        uint8_t CN19_9;
+        uint8_t CN19_10;
+        uint8_t CN19_11;
+        uint8_t CN19_12;
+        uint8_t CN19_13;
+        uint8_t CN19_14;
+        uint8_t CN19_15;
+    };
+
+    struct AIO_IOB2_BI2X_AC1__INPUTDATA {
+        uint8_t data[247];
+    };
+
+    struct AIO_IOB2_BI2X_AC1__OUTPUTDATA {
+        uint8_t data[48];
+    };
+
+    struct AIO_IOB2_BI2X_AC1__ICNPIN {
+        uint16_t Ain[4];
+        uint64_t CnPin;
+    };
+
+    struct AIO_IOB2_BI2X_AC1__DEVSTATUS {
+        uint8_t InputCounter;
+        uint8_t OutputCounter;
+        uint8_t IoResetCounter;
+        uint8_t TapeLedCounter;
+        uint8_t TapeLedRate[8];
+        AIO_IOB2_BI2X_AC1__INPUT Input;
+        AIO_IOB2_BI2X_AC1__INPUTDATA InputData;
+        AIO_IOB2_BI2X_AC1__OUTPUTDATA OutputData;
+        AIO_IOB2_BI2X_AC1__ICNPIN ICnPinHist[20];
+    };
+
+    struct AIO_IOB5_Y32D__DEVSTATUS {
+        uint8_t unk[0xB1];
+    };
+
+    // verified with M32-007-2025092400
+    static_assert(sizeof(AIO_NMGR_IOB2) == 0xe18);
+    static_assert(sizeof(AIO_NMGR_IOB5) == 0xb10);
+    static_assert(sizeof(AIO_SCI_COMM) == 0x100);
+    static_assert(sizeof(AIO_IOB5_Y32D) == 0x2e8);
+    static_assert(sizeof(AIO_IOB2_BI2X_AC1) == 0x4570);
+    static_assert(sizeof(AIO_IOB2_BI2X_WRFIRM) == 0x20f48);
+    static_assert(sizeof(AIO_IOB2_BI2X_AC1__DEVSTATUS) == 0x2C8);
+
+     /*
+      * typedefs
+      */
+
+    // libaio-iob2_video.dll
+    typedef AIO_IOB2_BI2X_AC1 *(__fastcall *aioIob2Bi2xAC1_Create_t)(AIO_NMGR_IOB2 *i_pNodeMgr, uint32_t i_DevId,
+                                                                     AIO_IOB2_BI2X_AC1__SETTING *i_Setting);
+    typedef void(__fastcall *aioIob2Bi2xAC1_GetDeviceStatus_t)(AIO_IOB2_BI2X_AC1 *i_pNodeCtl,
+                                                               AIO_IOB2_BI2X_AC1__DEVSTATUS *o_DevStatus);
+    typedef void(__fastcall *aioIob2Bi2xAC1_SetWatchDogTimer_t)(AIO_IOB2_BI2X_AC1 *i_pNodeCtl, uint8_t i_Count);
+    typedef void(__fastcall *aioIob2Bi2xAC1_AddCounter_t)(AIO_IOB2_BI2X_AC1 *i_pNodeCtl, uint32_t i_Counter,
+                                                          uint32_t i_Count);
+    typedef void(__fastcall *aioIob2Bi2xAC1_SetOutputData_t)(AIO_IOB2_BI2X_AC1 *i_pNodeCtl, uint32_t i_CnPin,
+                                                             uint8_t i_Data);
+    typedef void(__fastcall *aioIob2Bi2xAC1_SetTapeLedDataPart_t)(AIO_IOB2_BI2X_AC1 *i_pNodeCtl, uint32_t i_TapeLedCh,
+                                                                  uint32_t i_Offset, uint8_t *i_pData,
+                                                                  uint32_t i_cntTapeLed, bool i_bReverse);
+    typedef void(__fastcall *aioIob2Bi2x_SetTapeLedDataLimit_t)(AIO_IOB2_BI2X_AC1 *i_pNodeCtl, uint32_t i_Channel,
+                                                                uint8_t i_Scale, uint8_t i_Limit);
+    typedef AIO_IOB2_BI2X_WRFIRM *(__fastcall *aioIob2Bi2x_CreateWriteFirmContext_t)(uint32_t i_SerialNumber,
+                                                                                     uint32_t i_bfIob);
+    typedef void(__fastcall *aioIob2Bi2x_DestroyWriteFirmContext_t)(AIO_IOB2_BI2X_WRFIRM *i_pWrFirm);
+    typedef int32_t(__fastcall *aioIob2Bi2x_WriteFirmGetState_t)(AIO_IOB2_BI2X_WRFIRM *i_pWrFirm);
+    typedef bool(__fastcall *aioIob2Bi2x_WriteFirmIsCompleted_t)(int32_t i_State);
+    
+    // libaio-iob.dll
+    typedef AIO_NMGR_IOB2 *(__fastcall *aioNMgrIob2_Create_t)(AIO_SCI_COMM *i_pSci, uint32_t i_bfMode);
+    typedef void(__fastcall *aioNMgrIob_BeginManage_t)(AIO_NMGR_IOB2 *i_pNodeMgr);
+    typedef void(__fastcall *aioNCtlIob_GetNodeInfo_t)(AIO_IOB5_Y32D *i_pNodeCtl,
+                                                       AIO_NMGR_IOB__NODEINFO *o_NodeInfo);
+
+    // libaio.dll
+    typedef AIO_SCI_COMM_T *(__fastcall *aioSciComm_Open_t)(AIO_SCI_COMM_T *unk);
+    typedef void(__fastcall *aioSci_Destroy_t)(AIO_SCI_COMM *i_pNodeMgr);
+    typedef void(__fastcall *aioSci_GetCommStatus_t)(AIO_SCI_COMM *i_pNodeMgr, AIO_COMM_STATUS *i_Status);
+    typedef void(__fastcall *aioNodeMgr_Destroy_t)(AIO_NMGR_IOB5 *i_pNodeMgr);
+    typedef int32_t(__fastcall *aioNodeMgr_GetState_t)(AIO_NMGR_IOB5 *i_pNodeMgr);
+    typedef bool(__fastcall *aioNodeMgr_IsReady_t)(AIO_NMGR_IOB5 *i_pNodeMgr, int32_t i_State);
+    typedef bool(__fastcall *aioNodeMgr_IsError_t)(AIO_NMGR_IOB5 *i_pNodeMgr, int32_t i_State);
+    typedef void(__fastcall *aioNodeCtl_Destroy_t)(AIO_IOB5_Y32D *i_pNodeCtl);
+    typedef int32_t(__fastcall *aioNodeCtl_GetState_t)(AIO_IOB5_Y32D *i_pNodeCtl);
+    typedef bool(__fastcall *aioNodeCtl_IsReady_t)(AIO_IOB5_Y32D *i_pNodeCtl, int32_t i_State);
+    typedef bool(__fastcall *aioNodeCtl_IsError_t)(AIO_IOB5_Y32D *i_pNodeCtl, int32_t i_State);
+    typedef void(__fastcall *aioNodeCtl_UpdateDevicesStatus_t)();
+
+    // libaio-iob5.dll
+    typedef AIO_NMGR_IOB5 *(__fastcall *aioNMgrIob5_Create_t)(AIO_SCI_COMM *i_pSci, uint32_t i_bfMode);
+
+    // libaio-iob5_y32.dll
+    typedef AIO_IOB5_Y32D *(__fastcall *aioIob5Y32d_Create_t)(AIO_NMGR_IOB5 *i_pSci, uint32_t i_bfMode);
+    // typedef AIO_IOB5_Y33I *(__fastcall *aioIob5Y33i_Create_t)(AIO_NMGR_IOB5 *i_pSci, uint32_t i_bfMode);
+
+    typedef void(__fastcall *aioIob5Y32d_GetDeviceStatus_t)(AIO_IOB5_Y32D *i_pNodeCtl,
+                                                            AIO_IOB5_Y32D__DEVSTATUS *o_DevStatus);
+    // typedef void(__fastcall *aioIob5Y33i_GetDeviceStatus_t)(AIO_IOB5_Y33I *i_pNodeCtl,
+    //                                                         AIO_IOB2_BI2X_AC1__DEVSTATUS *o_DevStatus);
+
+    /*
+     * function pointers
+     */
+
+    // libaio-iob2_video.dll
+    static aioIob2Bi2xAC1_Create_t aioIob2Bi2xAC1_Create_orig = nullptr;
+    static aioIob2Bi2xAC1_GetDeviceStatus_t aioIob2Bi2xAC1_GetDeviceStatus_orig = nullptr;
+    static aioIob2Bi2xAC1_SetWatchDogTimer_t aioIob2Bi2xAC1_SetWatchDogTimer_orig = nullptr;
+    static aioIob2Bi2xAC1_AddCounter_t aioIob2Bi2xAC1_AddCounter_orig = nullptr;
+    static aioIob2Bi2xAC1_SetOutputData_t aioIob2Bi2xAC1_SetOutputData_orig = nullptr;
+    static aioIob2Bi2xAC1_SetTapeLedDataPart_t aioIob2Bi2xAC1_SetTapeLedDataPart_orig = nullptr;
+    static aioIob2Bi2x_SetTapeLedDataLimit_t aioIob2Bi2x_SetTapeLedDataLimit_orig = nullptr;
+    static aioIob2Bi2x_CreateWriteFirmContext_t aioIob2Bi2x_CreateWriteFirmContext_orig = nullptr;
+    static aioIob2Bi2x_DestroyWriteFirmContext_t aioIob2Bi2x_DestroyWriteFirmContext_orig = nullptr;
+    static aioIob2Bi2x_WriteFirmGetState_t aioIob2Bi2x_WriteFirmGetState_orig = nullptr;
+    static aioIob2Bi2x_WriteFirmIsCompleted_t aioIob2Bi2x_WriteFirmIsCompleted_orig = nullptr;
+
+    // libaio.dll
+    static aioSciComm_Open_t aioSciComm_Open_orig = nullptr;
+    static aioSci_Destroy_t aioSci_Destroy_orig = nullptr;
+    static aioSci_GetCommStatus_t aioSci_GetCommStatus_orig = nullptr;
+    static aioNodeMgr_Destroy_t aioNodeMgr_Destroy_orig = nullptr;
+    static aioNodeMgr_GetState_t aioNodeMgr_GetState_orig = nullptr;
+    static aioNodeMgr_IsReady_t aioNodeMgr_IsReady_orig = nullptr;
+    static aioNodeMgr_IsError_t aioNodeMgr_IsError_orig = nullptr;
+    static aioNodeCtl_Destroy_t aioNodeCtl_Destroy_orig = nullptr;
+    static aioNodeCtl_GetState_t aioNodeCtl_GetState_orig = nullptr;
+    static aioNodeCtl_IsReady_t aioNodeCtl_IsReady_orig = nullptr;
+    static aioNodeCtl_IsError_t aioNodeCtl_IsError_orig = nullptr;
+    static aioNodeCtl_UpdateDevicesStatus_t aioNodeCtl_UpdateDevicesStatus_orig = nullptr;
+
+    // libaio-iob5.dll
+    static aioNMgrIob5_Create_t aioNMgrIob5_Create_orig = nullptr;
+
+    // libaio-iob.dll
+    static aioNMgrIob2_Create_t aioNMgrIob2_Create_orig = nullptr;
+    static aioNMgrIob_BeginManage_t aioNMgrIob_BeginManage_orig = nullptr;
+    static aioNCtlIob_GetNodeInfo_t aioNCtlIob_GetNodeInfo_orig = nullptr;
+
+    // libaio-iob5_y32.dll
+    static aioIob5Y32d_Create_t aioIob5Y32d_Create_orig = nullptr;
+    static aioIob5Y32d_GetDeviceStatus_t aioIob5Y32d_GetDeviceStatus_orig = nullptr;
+
+    /*
+     * variables
+     */
+    static AIO_IOB2_BI2X_AC1 *aioIob2Bi2xAc1;
+    static AIO_NMGR_IOB2 *aioNmgrIob2;
+    static AIO_NMGR_IOB5 *aioNmgrIob5;
+    static AIO_IOB5_Y32D *aioIob5Y32d;
+    static AIO_SCI_COMM *aioSciComm;
+    static AIO_IOB2_BI2X_WRFIRM *aioIob2Bi2xWrfirm;
+
+    /*
+     * implementations
+     */
+
+    // libaio-iob2_video.dll
+
+    static AIO_IOB2_BI2X_AC1 *__fastcall aioIob2Bi2xAC1_Create(AIO_NMGR_IOB2 *i_pNodeMgr, uint32_t i_DevId,
+                                                               AIO_IOB2_BI2X_AC1__SETTING *i_Setting) {
+                               
+        if (i_pNodeMgr == aioNmgrIob2) {
+            aioIob2Bi2xAc1 = new AIO_IOB2_BI2X_AC1;
+            return aioIob2Bi2xAc1;
+        } else {
+            return aioIob2Bi2xAC1_Create_orig(i_pNodeMgr, i_DevId, i_Setting);
+        }
+    }
+
+    void __fastcall aioIob2Bi2xAC1_GetDeviceStatus(AIO_IOB2_BI2X_AC1 *i_pNodeCtl,
+                                                   AIO_IOB2_BI2X_AC1__DEVSTATUS *o_DevStatus) {
+        
+        RI_MGR->devices_flush_output();
+        if (i_pNodeCtl != aioIob2Bi2xAc1) {
+            return aioIob2Bi2xAC1_GetDeviceStatus_orig(i_pNodeCtl, o_DevStatus);
+        }
+
+        memset(o_DevStatus, 0x00, sizeof(AIO_IOB2_BI2X_AC1__DEVSTATUS));
+
+        auto &buttons = get_buttons();
+        // struct may be misaligned
+        o_DevStatus->Input.CN8_10 = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Test]) ? 0 : 0xFF;
+        o_DevStatus->Input.CN9_8 = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Service]) ? 0 : 0xFF;
+        o_DevStatus->Input.CN9_9 = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Coin]) ? 0 : 0xFF;
+        o_DevStatus->Input.CN12_14 = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::Headphone]) ? 0xFF : 0;
+
+        // coin
+        o_DevStatus->Input.Coin1Count = eamuse_coin_get_stock();
+    }
+
+    void __fastcall aioIob2Bi2xAC1_SetWatchDogTimer(AIO_IOB2_BI2X_AC1 *i_pNodeCtl, uint8_t i_Count) {
+
+        if (i_pNodeCtl != aioIob2Bi2xAc1) {
+            return aioIob2Bi2xAC1_SetWatchDogTimer_orig(i_pNodeCtl, i_Count);
+        }
+    }
+
+    void __fastcall aioIob2Bi2xAC1_AddCounter(AIO_IOB2_BI2X_AC1 *i_pNodeCtl, uint32_t i_Counter, uint32_t i_Count) {
+
+        if (i_pNodeCtl == aioIob2Bi2xAc1 && i_Count == 0) {
+            eamuse_coin_set_stock((uint16_t)i_Count);
+        } else {
+            return aioIob2Bi2xAC1_AddCounter_orig(i_pNodeCtl, i_Counter, i_Count);
+        }
+    }
+
+    void __fastcall aioIob2Bi2xAC1_SetOutputData(AIO_IOB2_BI2X_AC1 *i_pNodeCtl, uint32_t i_CnPin, uint8_t i_Data) {
+
+        if (i_pNodeCtl != aioIob2Bi2xAc1) {
+            return aioIob2Bi2xAC1_SetOutputData_orig(i_pNodeCtl, i_CnPin, i_Data);
+        }
+
+        std::optional<Lights::gitadora_lights_t> light;
+        switch (i_CnPin) {
+            case 14:
+                light = Lights::ArenaWooferR;
+                break;
+            case 15:
+                light = Lights::ArenaWooferG;
+                break;
+            case 16:
+                light = Lights::ArenaWooferB;
+                break;
+            case 17:
+                light = Lights::ArenaCardR;
+                break;
+            case 18:
+                light = Lights::ArenaCardG;
+                break;
+            case 19:
+                light = Lights::ArenaCardB;
+                break;
+            default:
+                break;
+        }
+        if (light.has_value()) {
+            auto &lights = games::gitadora::get_lights();
+            GameAPI::Lights::writeLight(RI_MGR, lights.at(light.value()), i_Data / 255.f);
+        }
+    }
+
+    void __fastcall aioIob2Bi2xAC1_SetTapeLedDataPart(AIO_IOB2_BI2X_AC1 *i_pNodeCtl, uint32_t i_TapeLedCh,
+                                                      uint32_t i_Offset, uint8_t *i_pData,
+                                                      uint32_t i_cntTapeLed, bool i_bReverse) {
+
+        if (i_pNodeCtl != aioIob2Bi2xAc1) {
+            return aioIob2Bi2xAC1_SetTapeLedDataPart_orig(i_pNodeCtl, i_TapeLedCh, i_Offset, i_pData, i_cntTapeLed, i_bReverse);
+        }
+
+        if (tapeledutils::is_enabled() && 
+            i_TapeLedCh == 0 && i_Offset == 0 && i_cntTapeLed == 62) {
+
+            auto &lights = get_lights();
+            const auto rgb = tapeledutils::pick_color_from_led_tape(i_pData, i_cntTapeLed);
+            GameAPI::Lights::writeLight(RI_MGR, lights[Lights::ArenaTitleAvgR], rgb.r);
+            GameAPI::Lights::writeLight(RI_MGR, lights[Lights::ArenaTitleAvgG], rgb.g);
+            GameAPI::Lights::writeLight(RI_MGR, lights[Lights::ArenaTitleAvgB], rgb.b);
+        }
+    }
+
+    void __fastcall aioIob2Bi2x_SetTapeLedDataLimit(AIO_IOB2_BI2X_AC1 *i_pNodeCtl, uint32_t i_Channel,
+                                                    uint8_t i_Scale, uint8_t i_Limit) {
+
+        if (i_pNodeCtl != aioIob2Bi2xAc1) {
+            return aioIob2Bi2x_SetTapeLedDataLimit_orig(i_pNodeCtl, i_Channel, i_Scale, i_Limit);
+        }
+    }
+
+    static AIO_IOB2_BI2X_WRFIRM *__fastcall aioIob2Bi2x_CreateWriteFirmContext(
+        uint32_t i_SerialNumber, uint32_t i_bfIob) {
+
+        aioIob2Bi2xWrfirm = new AIO_IOB2_BI2X_WRFIRM;
+        return aioIob2Bi2xWrfirm;
+    }
+
+    static void __fastcall aioIob2Bi2x_DestroyWriteFirmContext(AIO_IOB2_BI2X_WRFIRM *i_pWrFirm) {
+
+        if (i_pWrFirm == aioIob2Bi2xWrfirm) {
+            delete aioIob2Bi2xWrfirm;
+            aioIob2Bi2xWrfirm = nullptr;
+        } else {
+            return aioIob2Bi2x_DestroyWriteFirmContext_orig(i_pWrFirm);
+        }
+    }
+
+    static int32_t __fastcall aioIob2Bi2x_WriteFirmGetState(AIO_IOB2_BI2X_WRFIRM *i_pWrFirm) {
+
+        if (i_pWrFirm == aioIob2Bi2xWrfirm) {
+            return 8;
+        } else {
+            return aioIob2Bi2x_WriteFirmGetState_orig(i_pWrFirm);
+        }
+    }
+
+    static bool __fastcall aioIob2Bi2x_WriteFirmIsCompleted(int32_t i_State) {
+
+        if (aioIob2Bi2xWrfirm != nullptr) {
+            return true;
+        } else {
+            return aioIob2Bi2x_WriteFirmIsCompleted_orig(i_State);
+        }
+    }
+
+    // libaio-iob.dll
+    static AIO_NMGR_IOB2 *__fastcall aioNMgrIob2_Create(AIO_SCI_COMM *i_pSci, uint32_t i_bfMode) {
+
+        if (i_pSci == aioSciComm) {
+            aioNmgrIob2 = new AIO_NMGR_IOB2;
+            return aioNmgrIob2;
+        } else {
+            return aioNMgrIob2_Create_orig(i_pSci, i_bfMode);
+        }
+    }
+
+    static void __fastcall aioNMgrIob_BeginManage(AIO_NMGR_IOB2 *i_pNodeMgr) {
+
+        if (i_pNodeMgr == aioNmgrIob2) {
+        } else {
+            return aioNMgrIob_BeginManage_orig(i_pNodeMgr);
+        }
+    }
+
+    static void __fastcall aioNCtlIob_GetNodeInfo(
+        AIO_IOB5_Y32D *i_pNodeCtl, AIO_NMGR_IOB__NODEINFO *o_NodeInfo) {
+
+        if (i_pNodeCtl == aioIob5Y32d) {
+            memset(o_NodeInfo, 0, sizeof(AIO_NMGR_IOB__NODEINFO));
+        } else {
+            return aioNCtlIob_GetNodeInfo_orig(i_pNodeCtl, o_NodeInfo);
+        }
+    }
+
+    // libaio.dll
+
+    static AIO_SCI_COMM_T *__fastcall aioSciComm_Open(AIO_SCI_COMM_T *unk) {
+
+        aioSciComm = new AIO_SCI_COMM;
+        memset(unk, 0, sizeof(AIO_SCI_COMM_T));
+        unk->aioSciComm = aioSciComm;
+        return unk;
+    }
+
+    static void __fastcall aioSci_GetCommStatus(AIO_SCI_COMM *i_pNodeMgr, AIO_COMM_STATUS *i_Status) {
+
+        if (i_pNodeMgr == aioSciComm) {
+            memset(i_Status, 0, sizeof(AIO_COMM_STATUS));
+        } else {
+            return aioSci_GetCommStatus_orig(i_pNodeMgr, i_Status);
+        }
+    }
+
+    static void __fastcall aioSci_Destroy(AIO_SCI_COMM *i_pNodeMgr) {
+      
+        if (i_pNodeMgr == aioSciComm) {
+            delete aioSciComm;
+        } else {
+            return aioSci_Destroy_orig(i_pNodeMgr);
+        }
+    }
+
+    static void __fastcall aioNodeMgr_Destroy(AIO_NMGR_IOB5 *i_pNodeMgr) {
+
+        if (i_pNodeMgr == aioNmgrIob5 ||
+            i_pNodeMgr == (AIO_NMGR_IOB5 *)aioIob2Bi2xAc1 ||
+            i_pNodeMgr == (AIO_NMGR_IOB5 *)aioNmgrIob2) {
+
+            delete aioNmgrIob5;
+            aioNmgrIob5 = nullptr;
+        } else {
+            return aioNodeMgr_Destroy_orig(i_pNodeMgr);
+        }
+    }
+
+    static int32_t __fastcall aioNodeMgr_GetState(AIO_NMGR_IOB5 *i_pNodeMgr) {
+
+        if (i_pNodeMgr == aioNmgrIob5 ||
+            i_pNodeMgr == (AIO_NMGR_IOB5 *)aioIob2Bi2xAc1 ||
+            i_pNodeMgr == (AIO_NMGR_IOB5 *)aioNmgrIob2) {
+            return 1;
+        } else {
+            return aioNodeMgr_GetState_orig(i_pNodeMgr);
+        }
+    }
+
+    static bool __fastcall aioNodeMgr_IsReady(AIO_NMGR_IOB5 *i_pNodeMgr, int32_t i_State) {
+
+        if (i_pNodeMgr == aioNmgrIob5 ||
+            i_pNodeMgr == (AIO_NMGR_IOB5 *)aioIob2Bi2xAc1 ||
+            i_pNodeMgr == (AIO_NMGR_IOB5 *)aioNmgrIob2) {
+
+            return true;
+        } else {
+            return aioNodeMgr_IsReady_orig(i_pNodeMgr, i_State);
+        }
+    }
+
+    static bool __fastcall aioNodeMgr_IsError(AIO_NMGR_IOB5 *i_pNodeMgr, int32_t i_State) {
+
+        if (i_pNodeMgr == aioNmgrIob5 ||
+            i_pNodeMgr == (AIO_NMGR_IOB5 *)aioIob2Bi2xAc1 ||
+            i_pNodeMgr == (AIO_NMGR_IOB5 *)aioNmgrIob2) {
+
+            return false;
+        } else {
+            return aioNodeMgr_IsError_orig(i_pNodeMgr, i_State);
+        }
+    }
+
+    static void __fastcall aioNodeCtl_Destroy(AIO_IOB5_Y32D *i_pNodeCtl) {
+
+        if (i_pNodeCtl == aioIob5Y32d ||
+            i_pNodeCtl == (AIO_IOB5_Y32D *)aioIob2Bi2xAc1 ||
+            i_pNodeCtl == (AIO_IOB5_Y32D *)aioNmgrIob2) {
+            
+            delete aioIob5Y32d;
+            aioIob5Y32d = nullptr;
+        } else {
+            return aioNodeCtl_Destroy_orig(i_pNodeCtl);
+        }
+    }
+
+    static int32_t __fastcall aioNodeCtl_GetState(AIO_IOB5_Y32D *i_pNodeCtl) {
+
+        if (i_pNodeCtl == aioIob5Y32d ||
+            i_pNodeCtl == (AIO_IOB5_Y32D *)aioIob2Bi2xAc1 ||
+            i_pNodeCtl == (AIO_IOB5_Y32D *)aioNmgrIob2) {
+            
+            return 1;
+        } else {
+            return aioNodeCtl_GetState_orig(i_pNodeCtl);
+        }
+    }
+
+    static bool __fastcall aioNodeCtl_IsReady(AIO_IOB5_Y32D *i_pNodeCtl, int32_t i_State) {
+
+        if (i_pNodeCtl == aioIob5Y32d ||
+            i_pNodeCtl == (AIO_IOB5_Y32D *)aioIob2Bi2xAc1 ||
+            i_pNodeCtl == (AIO_IOB5_Y32D *)aioNmgrIob2) {
+
+            return true;
+        } else {
+            return aioNodeCtl_IsReady_orig(i_pNodeCtl, i_State);
+        }
+    }
+
+    static bool __fastcall aioNodeCtl_IsError(AIO_IOB5_Y32D *i_pNodeCtl, int32_t i_State) {
+
+        if (i_pNodeCtl == aioIob5Y32d ||
+            i_pNodeCtl == (AIO_IOB5_Y32D *)aioIob2Bi2xAc1 ||
+            i_pNodeCtl == (AIO_IOB5_Y32D *)aioNmgrIob2) {
+            
+            return false;
+        } else {
+            return aioNodeCtl_IsError_orig(i_pNodeCtl, i_State);
+        }
+    }
+
+    static void __fastcall aioNodeCtl_UpdateDevicesStatus() {
+    }
+
+    // libaio-iob5.dll
+
+    static AIO_NMGR_IOB5 *__fastcall aioNMgrIob5_Create(AIO_SCI_COMM *i_pSci, uint32_t i_bfMode) {
+
+        if (i_pSci == aioSciComm) {
+            aioNmgrIob5 = new AIO_NMGR_IOB5;
+            return aioNmgrIob5;
+        } else {
+            return aioNMgrIob5_Create_orig(i_pSci, i_bfMode);
+        }
+    }
+
+    // libaio-iob5_y32.dll
+
+    static AIO_IOB5_Y32D *__fastcall aioIob5Y32d_Create(AIO_NMGR_IOB5 *i_pSci, uint32_t i_bfMode) {
+
+        if (i_pSci == aioNmgrIob5) {
+            aioIob5Y32d = new AIO_IOB5_Y32D;
+            return aioIob5Y32d;
+        } else {
+            return aioIob5Y32d_Create_orig(i_pSci, i_bfMode);
+        }
+    }
+
+    void __fastcall aioIob5Y32d_GetDeviceStatus(AIO_IOB5_Y32D *i_pNodeCtl,
+                                                AIO_IOB5_Y32D__DEVSTATUS *o_DevStatus) {
+
+        if (i_pNodeCtl != aioIob5Y32d) {
+            return aioIob5Y32d_GetDeviceStatus_orig(i_pNodeCtl, o_DevStatus);
+        }
+
+        memset(o_DevStatus, 0, sizeof(AIO_IOB5_Y32D__DEVSTATUS));
+    }
+
+    void bi2x_hook_init() {
+
+        // avoid double init
+        static bool initialized = false;
+        if (initialized) {
+            return;
+        } else {
+            initialized = true;
+        }
+
+        // announce
+        log_info("bi2x_hook", "init");
+
+        // libaio-iob5_y32.dll
+        const auto libaioIob5Y32Dll = "libaio-iob5_y32.dll";
+        detour::trampoline_try(libaioIob5Y32Dll, "aioIob5Y32d_Create",
+                               aioIob5Y32d_Create, &aioIob5Y32d_Create_orig);
+        detour::trampoline_try(libaioIob5Y32Dll, "aioIob5Y32i_Create",
+                               aioIob5Y32d_Create, &aioIob5Y32d_Create_orig);
+        detour::trampoline_try(libaioIob5Y32Dll, "aioIob5Y32d_GetDeviceStatus",
+                               aioIob5Y32d_GetDeviceStatus, &aioIob5Y32d_GetDeviceStatus_orig);
+        detour::trampoline_try(libaioIob5Y32Dll, "aioIob5Y32i_GetDeviceStatus",
+                               aioIob5Y32d_GetDeviceStatus, &aioIob5Y32d_GetDeviceStatus_orig);
+
+        // libaio-iob5.dll
+        const auto libaioIob5Dll = "libaio-iob5.dll";
+        detour::trampoline_try(libaioIob5Dll, "aioNMgrIob5_Create",
+                               aioNMgrIob5_Create, &aioNMgrIob5_Create_orig);
+
+        // libaio-iob2_video.dll
+        const auto libaioIob2VideoDll = "libaio-iob2_video.dll";
+        detour::trampoline_try(libaioIob2VideoDll, "aioIob2Bi2xAC1_Create",
+                               aioIob2Bi2xAC1_Create, &aioIob2Bi2xAC1_Create_orig);
+        detour::trampoline_try(libaioIob2VideoDll, "aioIob2Bi2xAC1_GetDeviceStatus",
+                               aioIob2Bi2xAC1_GetDeviceStatus, &aioIob2Bi2xAC1_GetDeviceStatus_orig);
+        detour::trampoline_try(libaioIob2VideoDll, "aioIob2Bi2xAC1_SetWatchDogTimer",
+                               aioIob2Bi2xAC1_SetWatchDogTimer, &aioIob2Bi2xAC1_SetWatchDogTimer_orig);
+        detour::trampoline_try(libaioIob2VideoDll, "aioIob2Bi2xAC1_AddCounter",
+                               aioIob2Bi2xAC1_AddCounter, &aioIob2Bi2xAC1_AddCounter_orig);
+        detour::trampoline_try(libaioIob2VideoDll, "aioIob2Bi2xAC1_SetOutputData",
+                               aioIob2Bi2xAC1_SetOutputData, &aioIob2Bi2xAC1_SetOutputData_orig);
+        detour::trampoline_try(libaioIob2VideoDll, "aioIob2Bi2xAC1_SetTapeLedDataPart",
+                               aioIob2Bi2xAC1_SetTapeLedDataPart, &aioIob2Bi2xAC1_SetTapeLedDataPart_orig);
+        detour::trampoline_try(libaioIob2VideoDll, "aioIob2Bi2x_SetTapeLedDataLimit",
+                               aioIob2Bi2x_SetTapeLedDataLimit, &aioIob2Bi2x_SetTapeLedDataLimit_orig);
+        detour::trampoline_try(libaioIob2VideoDll, "?CreateWriteFirmContext@AIO_IOB2_BI2X@@SAPEAUWRFIRM@1@II@Z",
+                               aioIob2Bi2x_CreateWriteFirmContext, &aioIob2Bi2x_CreateWriteFirmContext_orig);
+        detour::trampoline_try(libaioIob2VideoDll, "?DestroyWriteFirmContext@AIO_IOB2_BI2X@@SAXPEAUWRFIRM@1@@Z",
+                               aioIob2Bi2x_DestroyWriteFirmContext, &aioIob2Bi2x_DestroyWriteFirmContext_orig);
+        detour::trampoline_try(libaioIob2VideoDll, "?WriteFirmGetState@AIO_IOB2_BI2X@@SAHPEAUWRFIRM@1@@Z",
+                               aioIob2Bi2x_WriteFirmGetState, &aioIob2Bi2x_WriteFirmGetState_orig);
+        detour::trampoline_try(libaioIob2VideoDll, "?WriteFirmIsCompleted@AIO_IOB2_BI2X@@SA_NH@Z",
+                               aioIob2Bi2x_WriteFirmIsCompleted, &aioIob2Bi2x_WriteFirmIsCompleted_orig);
+
+        // libaio-iob.dll
+        const auto libaioIobDll = "libaio-iob.dll";
+        detour::trampoline_try(libaioIobDll, "aioNMgrIob2_Create",
+                               aioNMgrIob2_Create, &aioNMgrIob2_Create_orig);
+        detour::trampoline_try(libaioIobDll, "aioNMgrIob_BeginManage",
+                               aioNMgrIob_BeginManage, &aioNMgrIob_BeginManage_orig);
+        detour::trampoline_try(libaioIobDll, "aioNCtlIob_GetNodeInfo",
+                               aioNCtlIob_GetNodeInfo, &aioNCtlIob_GetNodeInfo_orig);
+
+        // libaio.dll
+        const auto libaioDll = "libaio.dll";
+        detour::trampoline_try(libaioDll, "?Open@AIO_SCI_COMM@@SA?AU?$AC_ERESULT_T@PEAVAIO_SCI_COMM@@@@PEBD0AEBUSETTING@1@@Z",
+                               aioSciComm_Open, &aioSciComm_Open_orig);
+        detour::trampoline_try(libaioDll, "aioSci_GetCommStatus",
+                               aioSci_GetCommStatus, &aioSci_GetCommStatus_orig);
+        detour::trampoline_try(libaioDll, "aioSci_Destroy",
+                               aioSci_Destroy, &aioSci_Destroy_orig);
+        detour::trampoline_try(libaioDll, "aioNodeMgr_Destroy",
+                               aioNodeMgr_Destroy, &aioNodeMgr_Destroy_orig);
+        detour::trampoline_try(libaioDll, "aioNodeMgr_GetState",
+                               aioNodeMgr_GetState, &aioNodeMgr_GetState_orig);
+        detour::trampoline_try(libaioDll, "aioNodeMgr_IsReady",
+                               aioNodeMgr_IsReady, &aioNodeMgr_IsReady_orig);
+        detour::trampoline_try(libaioDll, "aioNodeMgr_IsError",
+                               aioNodeMgr_IsError, &aioNodeMgr_IsError_orig);
+        detour::trampoline_try(libaioDll, "aioNodeCtl_Destroy",
+                               aioNodeCtl_Destroy, &aioNodeCtl_Destroy_orig);
+        detour::trampoline_try(libaioDll, "aioNodeCtl_GetState",
+                               aioNodeCtl_GetState, &aioNodeCtl_GetState_orig);
+        detour::trampoline_try(libaioDll, "aioNodeCtl_IsReady",
+                               aioNodeCtl_IsReady, &aioNodeCtl_IsReady_orig);
+        detour::trampoline_try(libaioDll, "aioNodeCtl_IsError",
+                               aioNodeCtl_IsError, &aioNodeCtl_IsError_orig);
+        detour::trampoline_try(libaioDll, "aioNodeCtl_UpdateDevicesStatus",
+                               aioNodeCtl_UpdateDevicesStatus, &aioNodeCtl_UpdateDevicesStatus_orig);
+    }
+}
+
+#endif
@@ -0,0 +1,9 @@
+#pragma once
+
+#if SPICE64
+
+namespace games::gitadora {
+    void bi2x_hook_init();
+}
+
+#endif
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "acioemu/acioemu.h"
+
+namespace games::gitadora {
+    class GitadoraDevice : public acioemu::ACIODeviceEmu {
+        public:
+            bool is_ready = false;
+    };
+}
@@ -1,20 +1,67 @@
 #include "gitadora.h"
-
+#include "asio.h"
+#include "handle.h"
+#include "bi2x_hook.h"
 #include <unordered_map>

+#include <ks.h>
+#include <ksmedia.h>
+
 #include "cfg/configurator.h"
+#include "hooks/audio/audio.h"
+#include "hooks/audio/mme.h"
 #include "hooks/graphics/graphics.h"
+#include "misc/wintouchemu.h"
+#include "overlay/overlay.h"
 #include "util/cpuutils.h"
+#include "util/deferlog.h"
 #include "util/detour.h"
 #include "util/libutils.h"
 #include "util/logging.h"
 #include "util/sigscan.h"
+#include "util/socd_cleaner.h"
+#include "util/sysutils.h"
+#include "util/utils.h"
+#include "hooks/setupapihook.h"

 namespace games::gitadora {

    // settings
    bool TWOCHANNEL = false;
    std::optional<unsigned int> CAB_TYPE = std::nullopt;
+    bool P1_LEFTY = false;
+    bool P2_LEFTY = false;
+    std::optional<std::string> SUBSCREEN_OVERLAY_SIZE;
+    std::optional<socd::SocdAlgorithm> PICK_ALGO = socd::SocdAlgorithm::PreferRecent;
+    std::optional<uint8_t> ARENA_WINDOW_COUNT = std::nullopt;
+    std::optional<std::string> ASIO_DRIVER = std::nullopt;
+    bool ALLOW_REALTEK_AUDIO = false;
+
+    /*
+     * Prevent GitaDora from creating folders on F drive
+     */
+
+#ifdef SPICE64
+    static DWORD WINAPI GetLogicalDrives_hook() {
+        return GetLogicalDrives() | 0x20;
+    }
+
+    static UINT WINAPI GetDriveTypeA_hook(LPCSTR lpRootPathName) {
+        if (!strcmp(lpRootPathName, "F:\\")) {
+            return DRIVE_FIXED;
+        }
+
+        return GetDriveTypeA(lpRootPathName);
+    }
+
+    static BOOL WINAPI CreateDirectoryA_hook(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes) {
+        if (!strncmp(lpPathName, "F:/", 3)) {
+            return TRUE;
+        }
+
+        return CreateDirectoryA(lpPathName, lpSecurityAttributes);
+    }
+#endif

    /*
     * GitaDora checks if the IP address has changed, and if it has it throws 5-1506-0000 like jubeat.
@@ -184,12 +231,344 @@ namespace games::gitadora {
                log_fatal("gitadora", "Cabinet type 3 (SD2) not supported on XG series");
            }
 #endif
+
+            // for guitar wail SOCD cleaning
+            socd::ALGORITHM = socd::SocdAlgorithm::PreferRecent;
+
+            // for guitar picking
+            if (PICK_ALGO.has_value()) {
+                log_info("gitadora", "guitar pick SOCD algorithm: {}", static_cast<int>(PICK_ALGO.value()));
+            } else {
+                log_info("gitadora", "guitar pick SOCD algorithm: legacy");
+            }
+
+#if SPICE64 && !SPICE_XP
+
+            if (is_arena_model()) {
+                // in full screen, if single-adapter option is checked, it's functionally
+                // the same as forcing a single monitor
+                if (!GRAPHICS_WINDOWED && GRAPHICS_FORCE_SINGLE_ADAPTER) {
+                    ARENA_WINDOW_COUNT = 1;
+                }
+
+                // figure out default settings if user didn't provide one
+                if (!ARENA_WINDOW_COUNT.has_value()) {
+                    if (!GRAPHICS_WINDOWED && sysutils::enumerate_monitors().size() < 4) {
+                        log_info("gitadora", "arena model: <4 monitors, defaulting to single window mode");
+                        ARENA_WINDOW_COUNT = 1;
+                    } else {
+                        ARENA_WINDOW_COUNT = 4;
+                    }
+                }
+
+                const int count = ARENA_WINDOW_COUNT.value();
+                switch (count) {
+                    case 1:
+                        log_info("gitadora", "arena model: single-window mode");
+                        GRAPHICS_FORCE_SINGLE_ADAPTER = true;
+                        GRAPHICS_PREVENT_SECONDARY_WINDOWS = true;
+                        break;
+                    case 2:
+                        if (!GRAPHICS_WINDOWED) {
+                            log_fatal(
+                                "gitadora",
+                                "arena model: 2-window mode is not supported in fullscreen, choose 1 or 4");
+                        }
+                        log_info("gitadora", "arena model: two-window mode");
+                        GRAPHICS_GITADORA_HIDE_SIDE_WINDOWS = true;
+                        break;
+                    case 4:
+                        log_info("gitadora", "arena model: four-window mode");
+                        break;
+                    default:
+                        log_fatal(
+                            "gitadora",
+                            "arena model: unsupported window count: {}", count);
+                }
+            }
+
+#endif
+
        }
    }

+#if SPICE64 && !SPICE_XP
+
+    static decltype(GetDisplayConfigBufferSizes) *GetDisplayConfigBufferSizes_orig = nullptr;
+    static decltype(QueryDisplayConfig) *QueryDisplayConfig_orig = nullptr;
+    static decltype(DisplayConfigGetDeviceInfo) *DisplayConfigGetDeviceInfo_orig = nullptr;
+
+    // cached primary real monitor: its path + source/target mode entries.
+    // modeInfoIdx values on the path are renumbered to 0 / 1 so the cache is self-contained.
+    static DISPLAYCONFIG_PATH_INFO real_primary_path = {};
+    static DISPLAYCONFIG_MODE_INFO real_primary_modes[2] = {}; // [0]=source, [1]=target
+
+    // fake monitors appended after the real ones. the game classifies monitors
+    // by outputTechnology + connectorInstance:
+    //   HDMI               -> main 4k monitor (real primary)
+    //   DP connInstance 0  -> left
+    //   DP connInstance 1  -> right
+    //   DP connInstance 2  -> small (sub/touch)
+    // ids are negated on the fake monitor headers so they can be distinguished
+    // from real ones in DisplayConfigGetDeviceInfo.
+    struct FakeMonitor {
+        LONG id;
+        int width;
+        int height;
+        int offset_x;
+        int offset_y;
+        UINT32 connector_instance;
+    };
+
+    // ORDERING MATTERS: the d3d9 wrapper (FAKE_SUBSCREEN_ADAPTER) hands out
+    // adapters as "\\.\DISPLAY_SPICE_FAKE_{N}" for N=1,2,3. The game maps each
+    // adapter to a swap chain role via its DisplayConfig connector instance,
+    // so the entries here must be listed in the same order the wrapper enumerates
+    // them: id=1 -> adapter 1 -> left, id=2 -> adapter 2 -> right, id=3 -> adapter 3 -> small.
+    static constexpr FakeMonitor FAKE_MONITORS[] = {
+        { 1, 1080, 1920, -100000, -100000, 0 }, // left  (DP connector instance 0)
+        { 2, 1080, 1920, -200000, -200000, 1 }, // right (DP connector instance 1)
+        { 3,  800, 1280, -300000, -300000, 2 }, // small (DP connector instance 2, touch)
+    };
+    static constexpr UINT32 FAKE_MONITOR_COUNT = static_cast<UINT32>(std::size(FAKE_MONITORS));
+
+    // call QueryDisplayConfig once, keep only the primary monitor's path and its
+    // two referenced modes (source + target). modeInfoIdx values are rewritten to
+    // 0 and 1 so the cache is self-consistent.
+    static void cache_primary_monitor_info() {
+        UINT32 path_count = 0;
+        UINT32 mode_count = 0;
+        if (GetDisplayConfigBufferSizes_orig(
+                QDC_ONLY_ACTIVE_PATHS, &path_count, &mode_count) != ERROR_SUCCESS) {
+            log_fatal("gitadora", "cache_primary_monitor_info: GetDisplayConfigBufferSizes failed");
+        }
+
+        std::vector<DISPLAYCONFIG_PATH_INFO> all_paths(path_count);
+        std::vector<DISPLAYCONFIG_MODE_INFO> all_modes(mode_count);
+        if (QueryDisplayConfig_orig(
+                QDC_ONLY_ACTIVE_PATHS,
+                &path_count, all_paths.data(),
+                &mode_count, all_modes.data(),
+                nullptr) != ERROR_SUCCESS) {
+            log_fatal("gitadora", "cache_primary_monitor_info: QueryDisplayConfig failed");
+        }
+        all_paths.resize(path_count);
+        all_modes.resize(mode_count);
+
+        // pick the primary monitor: source mode at (0, 0)
+        auto primary = std::find_if(all_paths.begin(), all_paths.end(),
+            [&](const auto &p) {
+                const auto idx = p.sourceInfo.modeInfoIdx;
+                return idx < all_modes.size() &&
+                       all_modes[idx].infoType == DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE &&
+                       all_modes[idx].sourceMode.position.x == 0 &&
+                       all_modes[idx].sourceMode.position.y == 0;
+            });
+        if (primary == all_paths.end()) {
+            log_fatal("gitadora", "cache_primary_monitor_info: no primary monitor found");
+        }
+
+        real_primary_modes[0] = all_modes[primary->sourceInfo.modeInfoIdx];
+        real_primary_modes[1] = all_modes[primary->targetInfo.modeInfoIdx];
+        real_primary_path = *primary;
+        real_primary_path.sourceInfo.modeInfoIdx = 0;
+        real_primary_path.targetInfo.modeInfoIdx = 1;
+
+        log_info("gitadora", "cache_primary_monitor_info: cached primary monitor");
+    }
+
+    static
+    LONG
+    WINAPI
+    GetDisplayConfigBufferSizes_hook(
+        UINT32 Flags,
+        UINT32 *pNumPathArrayElements,
+        UINT32 *pNumModeInfoArrayElements)
+    {
+        // populate cached primary real monitor on the first call
+        static std::once_flag populate_once;
+        std::call_once(populate_once, cache_primary_monitor_info);
+
+        // always report exactly 1 real + N fake monitors
+        *pNumPathArrayElements = 1 + FAKE_MONITOR_COUNT;
+        *pNumModeInfoArrayElements = 2 + FAKE_MONITOR_COUNT * 2;
+
+        log_info(
+            "gitadora",
+            "GetDisplayConfigBufferSizes: 1 real path + {} fake monitor(s)",
+            FAKE_MONITOR_COUNT);
+
+        return ERROR_SUCCESS;
+    }
+
+    // write fake monitor i into the caller's path/mode arrays. layout (single-monitor
+    // assumption): index 0 in both arrays holds the cached primary real monitor, so
+    // fake i occupies path slot (1 + i) and mode slots (2 + i*2) / (2 + i*2 + 1).
+    static void insert_fake_monitor(
+        DISPLAYCONFIG_PATH_INFO *paths,
+        DISPLAYCONFIG_MODE_INFO *modes,
+        UINT32 i)
+    {
+        const FakeMonitor &m = FAKE_MONITORS[i];
+        const UINT32 src_idx = 2 + i * 2;
+        const UINT32 tgt_idx = src_idx + 1;
+        const LUID adapter_id { .LowPart = static_cast<DWORD>(-m.id), .HighPart = -m.id };
+        const UINT32 uid = static_cast<UINT32>(-m.id);
+
+        paths[1 + i] = {
+            .sourceInfo = {
+                .adapterId = adapter_id,
+                .id = uid,
+                .modeInfoIdx = src_idx,
+                .statusFlags = DISPLAYCONFIG_SOURCE_IN_USE,
+            },
+            .targetInfo = {
+                .adapterId = adapter_id,
+                .id = uid,
+                .modeInfoIdx = tgt_idx,
+                .outputTechnology = DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EXTERNAL,
+                .rotation = DISPLAYCONFIG_ROTATION_IDENTITY,
+                .scaling = DISPLAYCONFIG_SCALING_IDENTITY,
+                .refreshRate = { .Numerator = 60000, .Denominator = 1000 },
+                .scanLineOrdering = DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE,
+                .targetAvailable = TRUE,
+                .statusFlags = DISPLAYCONFIG_TARGET_IN_USE,
+            },
+            .flags = DISPLAYCONFIG_PATH_ACTIVE,
+        };
+
+        modes[src_idx] = {
+            .infoType = DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE,
+            .id = uid,
+            .adapterId = adapter_id,
+            .sourceMode = {
+                .width = static_cast<UINT32>(m.width),
+                .height = static_cast<UINT32>(m.height),
+                .pixelFormat = DISPLAYCONFIG_PIXELFORMAT_32BPP,
+                .position = { .x = m.offset_x, .y = m.offset_y },
+            },
+        };
+
+        modes[tgt_idx] = {
+            .infoType = DISPLAYCONFIG_MODE_INFO_TYPE_TARGET,
+            .id = uid,
+            .adapterId = adapter_id,
+            .targetMode = {},
+        };
+
+        log_misc(
+            "gitadora",
+            "inserted fake monitor: id={}, width={}, height={}, offset_x={}, offset_y={}",
+            m.id, m.width, m.height, m.offset_x, m.offset_y);
+    }
+
+    static
+    LONG
+    WINAPI
+    QueryDisplayConfig_hook(
+        UINT32 flags,
+        UINT32* numPathArrayElements,
+        DISPLAYCONFIG_PATH_INFO* pathArray,
+        UINT32* numModeInfoArrayElements,
+        DISPLAYCONFIG_MODE_INFO* modeInfoArray,
+        DISPLAYCONFIG_TOPOLOGY_ID* currentTopologyId)
+    {
+        // copy cached primary real monitor into caller buffers at index 0
+        pathArray[0] = real_primary_path;
+        modeInfoArray[0] = real_primary_modes[0];
+        modeInfoArray[1] = real_primary_modes[1];
+        *numPathArrayElements = 1 + FAKE_MONITOR_COUNT;
+        *numModeInfoArrayElements = 2 + FAKE_MONITOR_COUNT * 2;
+        if (currentTopologyId != nullptr) {
+            *currentTopologyId = DISPLAYCONFIG_TOPOLOGY_EXTEND;
+        }
+
+        log_misc("gitadora", "QueryDisplayConfig returning fake monitor paths and modes");
+
+        // append fake monitors after the real one
+        for (UINT32 i = 0; i < FAKE_MONITOR_COUNT; i++) {
+            insert_fake_monitor(pathArray, modeInfoArray, i);
+        }
+
+        return ERROR_SUCCESS;
+    }
+
+    static
+    LONG
+    WINAPI
+    DisplayConfigGetDeviceInfo_hook(DISPLAYCONFIG_DEVICE_INFO_HEADER* requestPacket)
+    {
+        if (requestPacket == nullptr) {
+            return DisplayConfigGetDeviceInfo_orig(requestPacket);
+        }
+
+        // handle fake monitors (negative id) directly without calling orig
+        const auto id = static_cast<int>(requestPacket->id);
+        if (id < 0) {
+            if (requestPacket->type == DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME) {
+                const auto sourceName = reinterpret_cast<DISPLAYCONFIG_SOURCE_DEVICE_NAME*>(requestPacket);
+                // name must match WrappedIDirect3D9::GetAdapterIdentifier
+                const std::string adapter_name = fmt::format("\\\\.\\DISPLAY_SPICE_FAKE_{}", -id);
+                wcscpy(sourceName->viewGdiDeviceName, s2ws(adapter_name).c_str());
+                log_misc("gitadora",
+                    "DisplayConfigGetDeviceInfo: fake source id={} name={}", id, adapter_name);
+                return ERROR_SUCCESS;
+            }
+            if (requestPacket->type == DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME) {
+                const auto targetName = reinterpret_cast<DISPLAYCONFIG_TARGET_DEVICE_NAME*>(requestPacket);
+                const LONG fake_id = -id;
+                UINT32 conn_inst = 0xff;
+                for (const auto& f : FAKE_MONITORS) {
+                    if (f.id == fake_id) {
+                        conn_inst = f.connector_instance;
+                        break;
+                    }
+                }
+                targetName->outputTechnology = DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EXTERNAL;
+                targetName->connectorInstance = conn_inst;
+                wcscpy(targetName->monitorFriendlyDeviceName, L"Spice Fake Monitor");
+                wcscpy(targetName->monitorDevicePath, L"\\\\?\\SpiceFakeMonitor");
+                log_misc("gitadora",
+                    "DisplayConfigGetDeviceInfo: fake target id={} -> DP connInst {}",
+                    id, targetName->connectorInstance);
+                return ERROR_SUCCESS;
+            }
+        }
+
+        const auto ret = DisplayConfigGetDeviceInfo_orig(requestPacket);
+        if (ret != ERROR_SUCCESS ||
+            requestPacket->type != DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME) {
+            return ret;
+        }
+
+        // override the cached primary real monitor target info to look like HDMI/0
+        const auto targetName = reinterpret_cast<DISPLAYCONFIG_TARGET_DEVICE_NAME*>(requestPacket);
+        const auto& target = real_primary_path.targetInfo;
+        if (target.id == targetName->header.id &&
+            target.adapterId.HighPart == targetName->header.adapterId.HighPart &&
+            target.adapterId.LowPart == targetName->header.adapterId.LowPart)
+        {
+            targetName->outputTechnology = DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HDMI;
+            targetName->connectorInstance = 0;
+            log_info("gitadora",
+                "overriding primary monitor (id={}) to pretend to be HDMI",
+                targetName->header.id);
+        }
+        return ret;
+    }
+
+#endif
+
    void GitaDoraGame::attach() {
        Game::attach();

+        // arena model launches a tiny window yet backbuffer at 4k, resulting in unusable overlay
+        // force scaling to make things usable
+        if (!overlay::UI_SCALE_PERCENT.has_value() && is_arena_model()) {
+            log_info("gitadora", "forcing UI scale to 250% for arena model");
+            overlay::UI_SCALE_PERCENT = 250;
+        }
+
        // modules
        HMODULE sharepj_module = libutils::try_module("libshare-pj.dll");
        HMODULE bmsd2_module = libutils::try_module("libbmsd2.dll");
@@ -214,28 +593,109 @@ namespace games::gitadora {
                system_module, "sys_debug_dip_set_param"));

 #ifdef SPICE64
+        // gitadora arena model 
+        auto aio = libutils::try_library("libaio.dll");

-        HMODULE gdme_module = libutils::try_module("libgdme.dll");
-
-        // window patch
-        if (GRAPHICS_WINDOWED && !replace_pattern(
-                gdme_module,
-                "754185ED753D8B4118BF0000CB02",
-                "9090????9090??????????????12", 0, 0))
-        {
-            log_warning("gitadora", "windowed mode failed");
+        // before we start patching and hooking things, detect invalid configuration
+        if (aio != nullptr && !is_arena_model()) {
+            log_fatal("gitadora", "arena model i/o (libaio.dll) detected, but <spec> is not an arena model - bad prop XML files?");
        }

-        HMODULE bmsd_engine_module = libutils::try_module("libbmsd-engine.dll");
-        HMODULE bmsd_module = libutils::try_module("libbmsd.dll");
+        if (aio != nullptr) {
+            SETUPAPI_SETTINGS settings{};
+            settings.class_guid[0] = 0x86E0D1E0;
+            settings.class_guid[1] = 0x11D08089;
+            settings.class_guid[2] = 0x0008E49C;
+            settings.class_guid[3] = 0x731F303E;
+            const char property[] = "1CCF(8050)_000";
+            const char property_hardwareid[] = "USB\\VID_1CCF&PID_8050&MI_00\\000";
+            memcpy(settings.property_devicedesc, property, sizeof(property));
+            memcpy(settings.property_hardwareid, property_hardwareid, sizeof(property_hardwareid));
+            setupapihook_init(avs::game::DLL_INSTANCE);
+            setupapihook_add(settings);
+
+            // Gitadora IO(J32D/J33I) board emulation
+            devicehook_init(avs::game::DLL_INSTANCE);
+            devicehook_add(new GitaDoraSerialHandle());
+
+            // test/service/coin buttons
+            bi2x_hook_init();
+
+            // f: drive hook
+            detour::iat_try("GetLogicalDrives", GetLogicalDrives_hook, avs::game::DLL_INSTANCE);
+            detour::iat_try("GetDriveTypeA", GetDriveTypeA_hook, avs::game::DLL_INSTANCE);
+            detour::iat_try("CreateDirectoryA", CreateDirectoryA_hook, avs::game::DLL_INSTANCE);
+
+            // ASIO driver redirect (XONAR -> user-configured driver)
+            asio_hook_init();
+
+            // volume change prevention
+            hooks::audio::mme::init(avs::game::DLL_INSTANCE);
+
+            // fake Realtek audio injection
+            // if ASIO init succeeds, game tries to look for audio device with `Realtek` in friendly name
+            // if ASIO init fails, game opens default audio device
+            // therefore, it's safe to enable this hook by default regardless of ASIO preference
+            // (unless the user explicitly disables it, of course)
+            if (ALLOW_REALTEK_AUDIO) {
+                log_info(
+                    "gitadora",
+                    "fake Realtek audio injection disabled "
+                    "(user's real Realtek audio may be used after successful ASIO init)");
+            } else {
+                log_info(
+                    "gitadora",
+                    "fake Realtek audio injection enabled "
+                    "(create a fake Realtek audio device to prevent crashes after successful ASIO init)");
+                hooks::audio::INJECT_FAKE_REALTEK_AUDIO = true;
+            }
+
+            // monitor/touch hooks (windowed or full screen)
+            if (GRAPHICS_PREVENT_SECONDARY_WINDOWS) {
+                // enable touch hook for subscreen overlay
+                wintouchemu::FORCE = true;
+                wintouchemu::INJECT_MOUSE_AS_WM_TOUCH = true;
+                wintouchemu::hook("GITADORA", avs::game::DLL_INSTANCE);
+
+#if !SPICE_XP
+
+                if (!GRAPHICS_WINDOWED) {
+                    // monitor hook: always pretend to have 1 primary real monitor + 3 fake monitors
+                    // (LEFT / RIGHT / SMALL) so the game accepts the arena cab topology
+                    GetDisplayConfigBufferSizes_orig =
+                        detour::iat_try("GetDisplayConfigBufferSizes",
+                            GetDisplayConfigBufferSizes_hook, avs::game::DLL_INSTANCE);
+                    QueryDisplayConfig_orig =
+                        detour::iat_try("QueryDisplayConfig",
+                            QueryDisplayConfig_hook, avs::game::DLL_INSTANCE);
+                    DisplayConfigGetDeviceInfo_orig =
+                        detour::iat_try("DisplayConfigGetDeviceInfo",
+                            DisplayConfigGetDeviceInfo_hook, avs::game::DLL_INSTANCE);
+                }
+#endif
+
+            }
+        }
+
+        // window patch
+        if (!is_arena_model()) {
+            HMODULE gdme_module = libutils::try_module("libgdme.dll");
+            if (GRAPHICS_WINDOWED && !replace_pattern(
+                    gdme_module,
+                    "754185ED753D8B4118BF0000CB02",
+                    "9090????9090??????????????12", 0, 0)) {
+                log_warning("gitadora", "windowed mode failed");
+            }
+        }

        // two channel mod
-        if (TWOCHANNEL) {
-            bmsd2_boot_orig = detour::iat_try("bmsd2_boot", bmsd2_boot_hook, bmsd_module);
+        if (TWOCHANNEL && !is_arena_model()) {
+            HMODULE bmsd_engine_module = libutils::try_module("libbmsd-engine.dll");
+            HMODULE bmsd_module = libutils::try_module("libbmsd.dll");

+            bmsd2_boot_orig = detour::iat_try("bmsd2_boot", bmsd2_boot_hook, bmsd_module);
            if (!(replace_pattern(bmsd_engine_module, "33000000488D", "03??????????", 0, 0) ||
-                    replace_pattern(bmsd_engine_module, "330000000F10", "03??????????", 0, 0)))
-            {
+                    replace_pattern(bmsd_engine_module, "330000000F10", "03??????????", 0, 0))) {
                log_warning("gitadora", "two channel mode failed");
            }
        }
@@ -243,4 +703,18 @@ namespace games::gitadora {
 #endif

    }
+
+    void fix_audio_channel_mask(WAVEFORMATEX *format) {
+        if (!format || format->wFormatTag != WAVE_FORMAT_EXTENSIBLE) {
+            return;
+        }
+
+        auto ext = reinterpret_cast<WAVEFORMATEXTENSIBLE *>(format);
+
+        // fix the legacy 7.1 channel mask to the modern surround layout
+        // makes it more compatible with modern audio cards
+        if (ext->dwChannelMask == KSAUDIO_SPEAKER_7POINT1) {
+            ext->dwChannelMask = KSAUDIO_SPEAKER_7POINT1_SURROUND;
+        }
+    }
 }
@@ -2,14 +2,25 @@

 #include <optional>

+#include <windows.h>
+#include <mmreg.h>
+
 #include "avs/game.h"
 #include "games/game.h"
+#include "util/socd_cleaner.h"

 namespace games::gitadora {

    // settings
    extern bool TWOCHANNEL;
    extern std::optional<unsigned int> CAB_TYPE;
+    extern bool P1_LEFTY;
+    extern bool P2_LEFTY;
+    extern std::optional<std::string> SUBSCREEN_OVERLAY_SIZE;
+    extern std::optional<socd::SocdAlgorithm> PICK_ALGO;
+    extern std::optional<uint8_t> ARENA_WINDOW_COUNT;
+    extern std::optional<std::string> ASIO_DRIVER;
+    extern bool ALLOW_REALTEK_AUDIO;

    class GitaDoraGame : public games::Game {
    public:
@@ -18,17 +29,34 @@ namespace games::gitadora {
        virtual void attach() override;
    };

+    void fix_audio_channel_mask(WAVEFORMATEX *format);
+
    static inline bool is_drum() {
        return (
            avs::game::is_model({ "J32", "K32", "L32" }) ||
-            (avs::game::is_model("M32") && avs::game::SPEC[0] == 'B')
+            (avs::game::is_model("M32") && (avs::game::SPEC[0] == 'B' || avs::game::SPEC[0] == 'D'))
            );
    }
    static inline bool is_guitar() {
        return (
            avs::game::is_model({ "J33", "K33", "L33" }) ||
-            (avs::game::is_model("M32") && avs::game::SPEC[0] == 'A')
+            (avs::game::is_model("M32") && (avs::game::SPEC[0] == 'A' || avs::game::SPEC[0] == 'C'))
            );
    }

+    static inline bool is_arena_model() {
+        return (
+            avs::game::is_model("M32") &&
+            (avs::game::SPEC[0] == 'C' || avs::game::SPEC[0] == 'D')
+            );
+    }
+
+    static inline bool is_player_lefty(size_t player) {
+        if (player == 0) {
+            return P1_LEFTY;
+        } else if (player == 1) {
+            return P2_LEFTY;
+        }
+        return false;
+    }
 }
@@ -0,0 +1,110 @@
+#include "handle.h"
+#include "misc/eamuse.h"
+#include "rawinput/rawinput.h"
+#include "util/utils.h"
+#include "util/time.h"
+#include "io.h"
+#include "gitadora.h"
+#include "j32d.h"
+#include "j33i.h"
+#include "device.h"
+
+
+using namespace acioemu;
+static games::gitadora::GitadoraDevice *device;
+
+bool games::gitadora::GitaDoraSerialHandle::open(LPCWSTR lpFileName) {
+    if (wcscmp(lpFileName, L"COM1") != 0) {
+        return false;
+    }
+
+    bool is_drum = games::gitadora::is_drum();
+
+    if (is_drum) {
+        device = new J32DSerialDevice();
+    } else {
+        device = new J33ISerialDevice();
+    }
+
+    acio_emu.add_device(device);
+    log_info("gitadora", "Opened COM1 ({} DEVICE)", is_drum ? "J32D" : "J33I");
+    return true;
+}
+
+int games::gitadora::GitaDoraSerialHandle::read(LPVOID lpBuffer, DWORD nNumberOfBytesToRead) {
+
+    auto buffer = reinterpret_cast<uint8_t *>(lpBuffer);
+
+    // the game does not send cmd 0x12F to the IO
+    // but it is expected to receive 0x12F for user input
+    // so i manually created a payload so that parse_msg can be used
+    // to write to the response_buffer
+    if (device->is_ready) {
+        uint8_t chk = 0;
+        MessageData* msg = ACIODeviceEmu::create_msg(0x1, 0x12F, 0, 0);
+        msg->addr = 0x1;
+        auto write_buffer = reinterpret_cast<uint8_t *>(msg);
+        while (acio_emu.read() != std::nullopt); // there may be old stuffs in the buffer
+        acio_emu.write(0xAA);
+        acio_emu.write(0xAA);
+
+        for(DWORD i = 0; i < 5; i++) {
+            chk += write_buffer[i];
+            acio_emu.write(write_buffer[i]);
+        }
+        // direct copy and paste from write_msg
+        if (chk == ACIO_SOF || chk == ACIO_ESCAPE) {
+            acio_emu.write(ACIO_ESCAPE);
+            acio_emu.write(~chk);
+        } else {
+            acio_emu.write(chk);
+        }
+    }
+
+    // read from emu
+    DWORD bytes_read = 0;
+    while (bytes_read < nNumberOfBytesToRead) {
+        auto cur_byte = acio_emu.read();
+
+        if (cur_byte.has_value()) {
+            buffer[bytes_read++] = cur_byte.value();
+        } else {
+            break;
+        }
+    }
+
+#ifdef ACIOEMU_LOG
+    log_info("gitadora", "Read IO Data: {}", bin2hex(buffer, bytes_read));
+#endif
+    // return amount of bytes read
+    return (int)bytes_read;
+}
+
+
+int games::gitadora::GitaDoraSerialHandle::write(LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite)
+{
+    auto buffer = reinterpret_cast<const uint8_t *>(lpBuffer);
+
+    // write to emu
+    for (DWORD i = 0; i < nNumberOfBytesToWrite; i++) {
+        acio_emu.write(buffer[i]);
+    }
+
+#ifdef ACIOEMU_LOG
+    log_info("gitadora", "Write IO Data: {}", bin2hex(buffer, nNumberOfBytesToWrite));
+#endif
+    // return all data written
+    return (int)nNumberOfBytesToWrite;
+}
+
+int games::gitadora::GitaDoraSerialHandle::device_io(DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize,
+                                                    LPVOID lpOutBuffer, DWORD nOutBufferSize) {
+ 
+    return -1;
+}
+
+bool games::gitadora::GitaDoraSerialHandle::close() {
+    
+    log_info("gitadora", "Closed COM1");
+    return true;
+}
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "acioemu/acioemu.h"
+#include "hooks/devicehook.h"
+
+namespace games::gitadora {
+
+    class GitaDoraSerialHandle : public CustomHandle {
+    private:
+        acioemu::ACIOEmu acio_emu;
+
+    public:
+        bool open(LPCWSTR lpFileName) override;
+
+        int read(LPVOID lpBuffer, DWORD nNumberOfBytesToRead) override;
+
+        int write(LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite) override;
+
+        int device_io(DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer,
+                      DWORD nOutBufferSize) override;
+        bool close() override;
+        
+    };
+}
@@ -10,6 +10,7 @@ std::vector<Button> &games::gitadora::get_buttons() {
                "Service",
                "Test",
                "Coin",
+                "Headphone",
                "Guitar P1 Start",
                "Guitar P1 Up",
                "Guitar P1 Down",
@@ -64,17 +65,18 @@ std::vector<Button> &games::gitadora::get_buttons() {
                "Drum Help",
                "Drum Button Extra 1",
                "Drum Button Extra 2",
+
+                "Drum Left Cymbal",
                "Drum Hi-Hat",
-                "Drum Hi-Hat Closed",
-                "Drum Hi-Hat Half-Open",
+                "Drum Left Pedal",
                "Drum Snare",
                "Drum Hi-Tom",
-                "Drum Low-Tom",
-                "Drum Right Cymbal",
                "Drum Bass Pedal",
-                "Drum Left Cymbal",
-                "Drum Left Pedal",
-                "Drum Floor Tom"
+                "Drum Low-Tom",
+                "Drum Floor Tom",
+                "Drum Right Cymbal",
+                "Drum Hi-Hat Closed",
+                "Drum Hi-Hat Half-Open"
        );
    }

@@ -84,19 +86,21 @@ std::vector<Button> &games::gitadora::get_buttons() {
 std::vector<Analog> &games::gitadora::get_analogs() {
    static std::vector<Analog> analogs;

+    using namespace GameAPI::Analogs;
+
    if (analogs.empty()) {
        analogs = GameAPI::Analogs::getAnalogs("GitaDora");

-        GameAPI::Analogs::sortAnalogs(&analogs,
-                "Guitar P1 Wail X",
-                "Guitar P1 Wail Y",
-                "Guitar P1 Wail Z",
-                "Guitar P1 Knob",
-                "Guitar P2 Wail X",
-                "Guitar P2 Wail Y",
-                "Guitar P2 Wail Z",
-                "Guitar P2 Knob"
-        );
+        GameAPI::Analogs::sortAnalogsWithType(&analogs, {
+            {"Guitar P1 Wail X", AnalogType::LinearCentered},
+            {"Guitar P1 Wail Y", AnalogType::LinearCentered},
+            {"Guitar P1 Wail Z", AnalogType::LinearCentered},
+            {"Guitar P1 Knob", AnalogType::Circular},
+            {"Guitar P2 Wail X", AnalogType::LinearCentered},
+            {"Guitar P2 Wail Y", AnalogType::LinearCentered},
+            {"Guitar P2 Wail Z", AnalogType::LinearCentered},
+            {"Guitar P2 Knob", AnalogType::Circular}
+        });
    }

    return analogs;
@@ -106,9 +110,18 @@ std::string games::gitadora::get_buttons_help() {
    // keep to max 100 characters wide
    return
        "guitar:\n"
+        "\n"
        " < R G B Y P --- Pick ] \n"
        "\n"
+        " If you normally hold your guitar left-handed (frets on right hand):\n"
+        "   * here, hold the guitar as right-handed (frets on left hand),\n"
+        "     and bind the buttons, pick, and wail controls\n"
+        "   * in Options tab, turn on GitaDora Lefty Guitar\n"
+        "   * finally, use the in-game option to turn on LEFT mode\n"
+        "\n"
+        "\n"
        "drums:\n"
+        "\n"
        " LeftCymbal                                RightCymbal\n"
        "         HiHat        HiTom      LowTom \n"
        "                  Snare              FloorTom \n"
@@ -116,10 +129,28 @@ std::string games::gitadora::get_buttons_help() {
        "             Left          Bass\n"
        "             Pedal         Pedal\n"
        "\n"
-        "Drums are NOT velocity-sensitive!\n"
+        " For MIDI drums with Open/Closed HiHat configurations or pads with\n"
+        " multiple hit zones, ensure you bind all variation using the Pages\n"
+        " button at the bottom."
+        ;
+}
+std::string games::gitadora::get_analogs_help() {
+    // keep to max 100 characters wide
+    return
+        "guitar:\n"
        "\n"
-        "For MIDI drums with Open/Closed HiHat configurations, bind variations below. "
-        "v2_drum algorithm might work better for those drums."
+        "X axis: 0% when body is held facing monitor, 50% when flat on a table\n"
+        "Y axis: 50% when held horizontal, 0% when neck is raised, 100% pointing down\n"
+        "Z axis: 50% at rest, 100% when swinging neck toward monitor (only used in XG series)\n"
+        "\n"
+        "You need both X and Y axis for up/down wail to work correctly in-game.\n"
+        "If you only have Y axis, consider using digital wailing instead.\n"
+        "\n"
+        "Ensure you clear all analog bindings if you want to use digital wailing.\n"
+        "\n"
+        "If you hold your guitar left-handed (frets on the right hand),\n"
+        "analog bindings will likely not work as intended.\n"
+        "Consider using digital wailing in Buttons tab."
        ;
 }

@@ -129,88 +160,102 @@ std::vector<Light> &games::gitadora::get_lights() {
    if (lights.empty()) {
        lights = GameAPI::Lights::getLights("GitaDora");

-        GameAPI::Lights::sortLights(&lights,
-                "Guitar P1 Motor",
-                "Guitar P2 Motor",
+        GameAPI::Lights::sortLightsWithCategory(&lights,
+            {
+                {"Guitar", "Guitar P1 Motor"},
+                {"Guitar", "Guitar P2 Motor"},

-                "P1 Start",
-                "P1 Menu Up Down (DX)",
-                "P1 Menu Left Right (DX)",
-                "P1 Help (DX)",
+                {"Menu", "P1 Start"},
+                {"Menu", "P1 Menu Up Down (DX)"},
+                {"Menu", "P1 Menu Left Right (DX)"},
+                {"Menu", "P1 Help (DX)"},

-                "P2 Start",
-                "P2 Menu Up Down (DX)",
-                "P2 Menu Left Right (DX)",
-                "P2 Help (DX)",
+                {"Menu", "P2 Start"},
+                {"Menu", "P2 Menu Up Down (DX)"},
+                {"Menu", "P2 Menu Left Right (DX)"},
+                {"Menu", "P2 Help (DX)"},

-                "Drum Left Cymbal",
-                "Drum Hi-Hat",
-                "Drum Snare",
-                "Drum High Tom",
-                "Drum Low Tom",
-                "Drum Floor Tom",
-                "Drum Right Cymbal",
+                {"Drums", "Drum Left Cymbal"},
+                {"Drums", "Drum Hi-Hat"},
+                {"Drums", "Drum Snare"},
+                {"Drums", "Drum High Tom"},
+                {"Drums", "Drum Low Tom"},
+                {"Drums", "Drum Floor Tom"},
+                {"Drums", "Drum Right Cymbal"},

-                "Drum Woofer R",
-                "Drum Woofer G",
-                "Drum Woofer B",
+                {"DX/SD", "Drum Woofer R"},
+                {"DX/SD", "Drum Woofer G"},
+                {"DX/SD", "Drum Woofer B"},

-                "Drum Stage R (DX)",
-                "Drum Stage G (DX)",
-                "Drum Stage B (DX)",
+                {"DX/SD", "Drum Stage R (DX)"},
+                {"DX/SD", "Drum Stage G (DX)"},
+                {"DX/SD", "Drum Stage B (DX)"},

-                "Spot Left (DX)",
-                "Spot Right (DX)",
-                "Spot Center Left (DX)",
-                "Spot Center Right (DX)",
+                {"DX/SD", "Spot Left (DX)"},
+                {"DX/SD", "Spot Right (DX)"},
+                {"DX/SD", "Spot Center Left (DX)"},
+                {"DX/SD", "Spot Center Right (DX)"},

-                "Drum Spot Rear Left (DX)",
-                "Drum Spot Rear Right (DX)",
+                {"DX/SD", "Drum Spot Rear Left (DX)"},
+                {"DX/SD", "Drum Spot Rear Right (DX)"},

-                "Guitar Lower Left R (DX)",
-                "Guitar Lower Left G (DX)",
-                "Guitar Lower Left B (DX)",
-                "Guitar Lower Right R (DX)",
-                "Guitar Lower Right G (DX)",
-                "Guitar Lower Right B (DX)",
+                {"DX/SD", "Guitar Lower Left R (DX)"},
+                {"DX/SD", "Guitar Lower Left G (DX)"},
+                {"DX/SD", "Guitar Lower Left B (DX)"},
+                {"DX/SD", "Guitar Lower Right R (DX)"},
+                {"DX/SD", "Guitar Lower Right G (DX)"},
+                {"DX/SD", "Guitar Lower Right B (DX)"},

-                "Guitar Left Speaker Upper R (DX)",
-                "Guitar Left Speaker Upper G (DX)",
-                "Guitar Left Speaker Upper B (DX)",
-                "Guitar Left Speaker Mid Up Left R (DX)",
-                "Guitar Left Speaker Mid Up Left G (DX)",
-                "Guitar Left Speaker Mid Up Left B (DX)",
-                "Guitar Left Speaker Mid Up Right R (DX)",
-                "Guitar Left Speaker Mid Up Right G (DX)",
-                "Guitar Left Speaker Mid Up Right B (DX)",
-                "Guitar Left Speaker Mid Low Left R (DX)",
-                "Guitar Left Speaker Mid Low Left G (DX)",
-                "Guitar Left Speaker Mid Low Left B (DX)",
-                "Guitar Left Speaker Mid Low Right R (DX)",
-                "Guitar Left Speaker Mid Low Right G (DX)",
-                "Guitar Left Speaker Mid Low Right B (DX)",
-                "Guitar Left Speaker Lower R (DX)",
-                "Guitar Left Speaker Lower G (DX)",
-                "Guitar Left Speaker Lower B (DX)",
+                {"DX/SD", "Guitar Left Speaker Upper R (DX)"},
+                {"DX/SD", "Guitar Left Speaker Upper G (DX)"},
+                {"DX/SD", "Guitar Left Speaker Upper B (DX)"},
+                {"DX/SD", "Guitar Left Speaker Mid Up Left R (DX)"},
+                {"DX/SD", "Guitar Left Speaker Mid Up Left G (DX)"},
+                {"DX/SD", "Guitar Left Speaker Mid Up Left B (DX)"},
+                {"DX/SD", "Guitar Left Speaker Mid Up Right R (DX)"},
+                {"DX/SD", "Guitar Left Speaker Mid Up Right G (DX)"},
+                {"DX/SD", "Guitar Left Speaker Mid Up Right B (DX)"},
+                {"DX/SD", "Guitar Left Speaker Mid Low Left R (DX)"},
+                {"DX/SD", "Guitar Left Speaker Mid Low Left G (DX)"},
+                {"DX/SD", "Guitar Left Speaker Mid Low Left B (DX)"},
+                {"DX/SD", "Guitar Left Speaker Mid Low Right R (DX)"},
+                {"DX/SD", "Guitar Left Speaker Mid Low Right G (DX)"},
+                {"DX/SD", "Guitar Left Speaker Mid Low Right B (DX)"},
+                {"DX/SD", "Guitar Left Speaker Lower R (DX)"},
+                {"DX/SD", "Guitar Left Speaker Lower G (DX)"},
+                {"DX/SD", "Guitar Left Speaker Lower B (DX)"},

-                "Guitar Right Speaker Upper R (DX)",
-                "Guitar Right Speaker Upper G (DX)",
-                "Guitar Right Speaker Upper B (DX)",
-                "Guitar Right Speaker Mid Up Left R (DX)",
-                "Guitar Right Speaker Mid Up Left G (DX)",
-                "Guitar Right Speaker Mid Up Left B (DX)",
-                "Guitar Right Speaker Mid Up Right R (DX)",
-                "Guitar Right Speaker Mid Up Right G (DX)",
-                "Guitar Right Speaker Mid Up Right B (DX)",
-                "Guitar Right Speaker Mid Low Left R (DX)",
-                "Guitar Right Speaker Mid Low Left G (DX)",
-                "Guitar Right Speaker Mid Low Left B (DX)",
-                "Guitar Right Speaker Mid Low Right R (DX)",
-                "Guitar Right Speaker Mid Low Right G (DX)",
-                "Guitar Right Speaker Mid Low Right B (DX)",
-                "Guitar Right Speaker Lower R (DX)",
-                "Guitar Right Speaker Lower G (DX)",
-                "Guitar Right Speaker Lower B (DX)"
+                {"DX/SD", "Guitar Right Speaker Upper R (DX)"},
+                {"DX/SD", "Guitar Right Speaker Upper G (DX)"},
+                {"DX/SD", "Guitar Right Speaker Upper B (DX)"},
+                {"DX/SD", "Guitar Right Speaker Mid Up Left R (DX)"},
+                {"DX/SD", "Guitar Right Speaker Mid Up Left G (DX)"},
+                {"DX/SD", "Guitar Right Speaker Mid Up Left B (DX)"},
+                {"DX/SD", "Guitar Right Speaker Mid Up Right R (DX)"},
+                {"DX/SD", "Guitar Right Speaker Mid Up Right G (DX)"},
+                {"DX/SD", "Guitar Right Speaker Mid Up Right B (DX)"},
+                {"DX/SD", "Guitar Right Speaker Mid Low Left R (DX)"},
+                {"DX/SD", "Guitar Right Speaker Mid Low Left G (DX)"},
+                {"DX/SD", "Guitar Right Speaker Mid Low Left B (DX)"},
+                {"DX/SD", "Guitar Right Speaker Mid Low Right R (DX)"},
+                {"DX/SD", "Guitar Right Speaker Mid Low Right G (DX)"},
+                {"DX/SD", "Guitar Right Speaker Mid Low Right B (DX)"},
+                {"DX/SD", "Guitar Right Speaker Lower R (DX)"},
+                {"DX/SD", "Guitar Right Speaker Lower G (DX)"},
+                {"DX/SD", "Guitar Right Speaker Lower B (DX)"},
+
+                {"Arena Model", "Title Average R (Arena)"},
+                {"Arena Model", "Title Average G (Arena)"},
+                {"Arena Model", "Title Average B (Arena)"},
+
+                {"Arena Model", "Woofer R (Arena)"},
+                {"Arena Model", "Woofer G (Arena)"},
+                {"Arena Model", "Woofer B (Arena)"},
+
+                {"Arena Model", "Card Reader R (Arena)"},
+                {"Arena Model", "Card Reader G (Arena)"},
+                {"Arena Model", "Card Reader B (Arena)"}
+            }
        );
    }

@@ -11,6 +11,7 @@ namespace games::gitadora {
            Service,
            Test,
            Coin,
+            Headphone,
            GuitarP1Start,
            GuitarP1Up,
            GuitarP1Down,
@@ -65,18 +66,21 @@ namespace games::gitadora {
            DrumHelp,
            DrumButtonExtra1,
            DrumButtonExtra2,
-            // note: this is the order they appear in the test menu
+            // note: this is the order of drums in the default layout
+            DrumLeftCymbal,
            DrumHiHat,
-            DrumHiHatClosed,
-            DrumHiHatHalfOpen,
+            DrumLeftPedal,
            DrumSnare,
            DrumHiTom,
-            DrumLowTom,
-            DrumRightCymbal,
            DrumBassPedal,
-            DrumLeftCymbal,
-            DrumLeftPedal,
-            DrumFloorTom
+            DrumLowTom,
+            DrumFloorTom,
+            DrumRightCymbal,
+
+            // these only exist for back compat
+            // (created before it was possible to map multiple input to a button)
+            DrumHiHatClosed,
+            DrumHiHatHalfOpen
        };
    }

@@ -190,13 +194,25 @@ namespace games::gitadora {
            GuitarRightSpeakerMidLowRightB,
            GuitarRightSpeakerLowerR,
            GuitarRightSpeakerLowerG,
-            GuitarRightSpeakerLowerB
+            GuitarRightSpeakerLowerB,
+
+            // arena model (common for both guitar and drum)
+            ArenaTitleAvgR,
+            ArenaTitleAvgG,
+            ArenaTitleAvgB,
+            ArenaWooferR,
+            ArenaWooferG,
+            ArenaWooferB,
+            ArenaCardR,
+            ArenaCardG,
+            ArenaCardB,
        } gitadora_lights_t;
    }

    // getters
    std::vector<Button> &get_buttons();
    std::string get_buttons_help();
+    std::string get_analogs_help();
    std::vector<Analog> &get_analogs();
    std::vector<Light> &get_lights();
 }
@@ -0,0 +1,100 @@
+
+#include "misc/eamuse.h"
+#include "util/utils.h"
+#include "io.h"
+#include "j32d.h"
+
+
+using namespace acioemu;
+
+games::gitadora::J32DSerialDevice::J32DSerialDevice() {
+    this->node_count = 1;
+    log_info("gitadora", "J32D device created.");
+}
+
+bool games::gitadora::J32DSerialDevice::parse_msg(
+    MessageData *msg_in,
+    circular_buffer<uint8_t> *response_buffer) {
+
+#ifdef ACIOEMU_LOG
+    log_info("gitadora", "GTDR ADDR: {}, CMD: 0x{:04x}", msg_in->addr, msg_in->cmd.code);
+#endif
+
+    static uint8_t pid = 0;
+    // check command
+    switch (msg_in->cmd.code) {
+        case ACIO_CMD_GET_VERSION: {
+            // send version data
+            auto msg = this->create_msg(msg_in, MSG_VERSION_SIZE);
+            this->set_version(msg, 0x20a, 0, 0, 1, 0, "J32D");
+            write_msg(msg, response_buffer);
+            delete msg;
+            break;
+        }
+        case ACIO_CMD_STARTUP:
+        case ACIO_CMD_CLEAR:
+        case 0x0120: {
+            if (msg_in->cmd.code == 0x0120) {
+                pid = msg_in->cmd.pid;
+                this->is_ready = true;
+            }
+            // send status 0
+            auto msg = this->create_msg_status(msg_in, 0);
+            write_msg(msg, response_buffer);
+            delete msg;
+            break;
+        }
+    // IO
+        case 0x012F: {
+            auto msg = this->create_msg(msg_in, 0x11);
+            msg->cmd.pid = pid;
+            // don't know if it's needed/correct, 
+            // without it the game seems to work just fine 
+            pid += 1;
+            J32D_IO_STATUS payload;
+            memset(&payload, 0, sizeof(J32D_IO_STATUS));
+
+            auto &buttons = get_buttons();
+            auto high_tom = (uint16_t) (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::DrumHiTom]) * 1023);
+            auto low_tom = (uint16_t) (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::DrumLowTom]) * 1023);
+            auto snare = (uint16_t) (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::DrumSnare]) * 1023);
+            auto floor_tom = (uint16_t) (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::DrumFloorTom]) * 1023);
+            auto left_cymbal = (uint16_t) (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::DrumLeftCymbal]) * 1023);
+            auto right_cymbal = (uint16_t) (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::DrumRightCymbal]) * 1023);
+            auto hihat = (uint16_t) ((GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::DrumHiHat]) ||
+                                     GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::DrumHiHatClosed]) ||
+                                     GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::DrumHiHatHalfOpen])) * 1023);
+
+#define ENCODE_ANALOG(__val) (((__val & 0x3f) << 10) | ((__val & 0x3c0) >> 6))
+            payload.high_tom = ENCODE_ANALOG(high_tom);
+            payload.low_tom = ENCODE_ANALOG(low_tom);
+            payload.snare = ENCODE_ANALOG(snare);
+            payload.floor_tom = ENCODE_ANALOG(floor_tom);
+            payload.left_cymbal = ENCODE_ANALOG(left_cymbal);
+            payload.right_cymbal = ENCODE_ANALOG(right_cymbal);
+            payload.hihat = ENCODE_ANALOG(hihat);
+#undef ENCODE_ANALOG
+
+            if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::DrumBassPedal])) {
+                payload.pedals |= 1;
+            }
+            
+            if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::DrumLeftPedal])) {
+                payload.pedals |= 2; 
+            }
+
+            memcpy(msg->cmd.raw, &payload, sizeof(J32D_IO_STATUS));
+            write_msg(msg, response_buffer);
+            delete msg;
+            break;
+        }
+        default:
+#ifdef ACIOEMU_LOG
+            log_info("gitadora", "Unhandled cmd {} received.", msg_in->cmd.code);
+#endif
+            return false;
+    }
+
+    // mark as handled
+    return true;
+}
@@ -0,0 +1,25 @@
+#pragma once
+#include "acioemu/device.h"
+#include "device.h"
+
+namespace games::gitadora {
+
+    class J32DSerialDevice : public GitadoraDevice {
+        private:
+            uint8_t coin_counter = 0;
+        public:
+            J32DSerialDevice();
+            bool parse_msg(acioemu::MessageData *msg_in, circular_buffer<uint8_t> *response_buffer) override;  
+            struct J32D_IO_STATUS {
+                uint16_t high_tom;
+                uint16_t low_tom;
+                uint16_t snare;
+                uint16_t floor_tom;
+                uint16_t left_cymbal;
+                uint16_t right_cymbal;
+                uint16_t hihat;
+                uint16_t unk7;
+                uint8_t pedals;
+            };
+        };
+}
@@ -0,0 +1,203 @@
+
+#include "misc/eamuse.h"
+#include "games/gitadora/gitadora.h"
+#include "util/socd_cleaner.h"
+#include "util/time.h"
+#include "util/utils.h"
+#include "io.h"
+#include "j33i.h"
+
+#define GUITAR_BTN_R 0x7
+#define GUITAR_BTN_G 0x6
+#define GUITAR_BTN_B 0x5
+#define GUITAR_BTN_Y 0x4
+#define GUITAR_BTN_P 0x3
+#define GUITAR_PICK_DOWN 0xC
+#define GUITAR_PICK_UP 0xD
+
+using namespace acioemu;
+
+// why this number?? no clue, but this is what the test menu shows as the max
+// value in the green box with the red dot; the value display itself can go
+// higher but the red dot will reach the edge at +-189
+#define ARENA_MODEL_WAIL_MAX 189
+
+static bool GFDM_GF_PICK_STATE_UP;
+static bool GFDM_GF_PICK_STATE_DOWN;
+
+games::gitadora::J33ISerialDevice::J33ISerialDevice() {
+    this->node_count = 1;
+    log_info("gitadora", "J33I device created.");
+}
+
+bool games::gitadora::J33ISerialDevice::parse_msg(
+    MessageData *msg_in,
+    circular_buffer<uint8_t> *response_buffer) {
+
+#ifdef ACIOEMU_LOG
+    log_info("gitadora", "GTDR ADDR: {}, CMD: 0x{:04x}", msg_in->addr, msg_in->cmd.code);
+#endif
+
+    static uint8_t pid = 0;
+    // check command
+    switch (msg_in->cmd.code)
+    {
+        case ACIO_CMD_GET_VERSION: {
+            // send version data
+            auto msg = this->create_msg(msg_in, MSG_VERSION_SIZE);
+            this->set_version(msg, 0x10a, 0, 1, 0, 2, "J33I");
+            write_msg(msg, response_buffer);
+            delete msg;
+            break;
+        }
+        case ACIO_CMD_STARTUP:
+        case ACIO_CMD_CLEAR:
+        case 0x0120: {
+            if (msg_in->cmd.code == 0x0120) {
+                pid = msg_in->cmd.pid;
+                this->is_ready = true;
+            }
+            // send status 0
+            auto msg = this->create_msg_status(msg_in, 0);
+            write_msg(msg, response_buffer);
+            delete msg;
+            break;
+        }
+        // IO
+        case 0x012F: {
+            auto msg = this->create_msg(msg_in, 0x8);
+            msg->cmd.pid = pid;
+            pid += 1;
+            J33I_IO_STATUS payload;
+            memset(&payload, 0, sizeof(J33I_IO_STATUS));
+
+            auto &buttons = get_buttons();
+            if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1R])) {
+                payload.buttons |= 1 << GUITAR_BTN_R;
+            }
+
+            if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1G])) {
+                payload.buttons |= 1 << GUITAR_BTN_G;
+            }
+
+            if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1B])) {
+                payload.buttons |= 1 << GUITAR_BTN_B;
+            }
+
+            if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1Y])) {
+                payload.buttons |= 1 << GUITAR_BTN_Y;
+            }   
+
+            if (GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1P])) {
+                payload.buttons |= 1 << GUITAR_BTN_P;
+            }
+
+
+            const auto pick_up = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1PickUp]);
+            const auto pick_down = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1PickDown]);
+            if (!games::gitadora::PICK_ALGO.has_value()) {
+                // legacy behavior (detect rising edges only, input for 1 frame)
+                if (pick_up) {
+                    if (!GFDM_GF_PICK_STATE_UP) {
+                        GFDM_GF_PICK_STATE_UP = true;
+                        payload.buttons |= 1 << GUITAR_PICK_UP;
+                    }
+                } else {
+                    GFDM_GF_PICK_STATE_UP = false;
+                }
+
+                if (pick_down) {
+                    if (!GFDM_GF_PICK_STATE_DOWN) {
+                        GFDM_GF_PICK_STATE_DOWN = true;
+                        payload.buttons |= 1 << GUITAR_PICK_DOWN;
+                    }
+                } else {
+                    GFDM_GF_PICK_STATE_DOWN = false;
+                }
+            } else {
+                const auto socd = socd::socd_clean(
+                    0,
+                    pick_up,
+                    pick_down,
+                    get_performance_milliseconds(),
+                    games::gitadora::PICK_ALGO.value()
+                );
+                if (socd == socd::SocdCCW) {
+                    payload.buttons |= 1 << GUITAR_PICK_UP;
+                } else if (socd == socd::SocdCW) {
+                    payload.buttons |= 1 << GUITAR_PICK_DOWN;
+                } else if (socd == socd::SocdBoth) {
+                    payload.buttons |= 1 << GUITAR_PICK_UP;
+                    payload.buttons |= 1 << GUITAR_PICK_DOWN;
+                }
+            }
+
+            auto &analogs = get_analogs();
+
+            // get x,y,z analog values [-0.5f, 0.5f]
+            float x = is_player_lefty(0) ? 0.3f : -0.5f;
+            auto x_analog = analogs[Analogs::GuitarP1WailX];
+            if (x_analog.isSet()) {
+                x = GameAPI::Analogs::getState(RI_MGR, x_analog) - 0.5f;
+            }
+
+            float y = 0.f;
+            auto y_analog = analogs[Analogs::GuitarP1WailY];
+            if (y_analog.isSet()) {
+                y = GameAPI::Analogs::getState(RI_MGR, y_analog) - 0.5f;
+            }
+
+            float z = 0.f;
+            auto z_analog = analogs[Analogs::GuitarP1WailZ];
+            if (z_analog.isSet()) {
+                z = GameAPI::Analogs::getState(RI_MGR, z_analog) - 0.5f;
+            }
+
+            // handle digital wail up/down
+            const auto wail_up = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1WailUp]);
+            const auto wail_down = GameAPI::Buttons::getState(RI_MGR, buttons[Buttons::GuitarP1WailDown]);
+            const auto wail_result =
+                socd::get_guitar_wail(0, wail_up, wail_down, get_performance_milliseconds());
+            if (!is_player_lefty(0)) {
+                // righty
+                if (wail_result == socd::TiltUp) {
+                    x = 0;
+                    y = -0.5f;
+                } else if (wail_result == socd::TiltDown) {
+                    x = -0.5f;
+                    y = 0.5f;
+                }
+            } else {
+                // lefty
+                if (wail_result == socd::TiltUp) {
+                    x = 0.f;
+                    y = 0.f;
+                } else if (wail_result == socd::TiltDown) {
+                    x = 0.5f;
+                    y = 0.f;
+                }
+            }
+
+            // convert x,y,z to unsigned integer values that the game expects
+            const uint16_t x_int = x * ARENA_MODEL_WAIL_MAX * 2;
+            const uint16_t y_int = y * ARENA_MODEL_WAIL_MAX * 2;
+            const uint16_t z_int = z * ARENA_MODEL_WAIL_MAX * 2;
+            payload.gyroscope_x = static_cast<uint16_t>(((x_int >> 3) & (0xFF)) | ((x_int & 0x07) << 12));
+            payload.gyroscope_y = static_cast<uint16_t>(((y_int >> 3) & (0xFF)) | ((y_int & 0x07) << 12));
+            payload.gyroscope_z = static_cast<uint16_t>(((z_int >> 3) & (0xFF)) | ((z_int & 0x07) << 12));
+
+            memcpy(msg->cmd.raw, &payload, sizeof(J33I_IO_STATUS));
+            write_msg(msg, response_buffer);
+            delete msg;
+            break;
+        }
+    default:
+#ifdef ACIOEMU_LOG
+        log_info("gitadora", "Unhandled cmd {} received.", msg_in->cmd.code);
+#endif
+        return false;
+    }
+
+    // mark as handled
+    return true;
+}
--- a/Show More
+++ b/Show More