update changelog

## Link to GitHub Issue, if one exists
n/a

## Description of change
Allow importing patches for `libshare-pj.dll`

## Testing
Observed patch for the new DLL being attempted to be imported in the
logs.

src/spice2x/README.md

@@ -247,6 +247,25 @@ which also means that your hex edits are applicable directly.
   - sets the contents of the 16 segment display and disables writes from game
 - ticker_reset()
   - re-enables writes from game
+- tapeled_get(name: str, ...)
+  - returns a list containing a dict of the current tape LED states. The dict keys are:
+    - `Stage Left`
+    - `Stage Right`
+    - `Cabinet Left`
+    - `Cabinet Right`
+    - `Control Panel Under`
+    - `Ceiling Left`
+    - `Title Left`
+    - `Title Right`
+    - `Ceiling Right`
+    - `Touch Panel Left`
+    - `Touch Panel Right`
+    - `Side Panel Left Inner`
+    - `Side Panel Left Outer`
+    - `Side Panel Left`
+    - `Side Panel Right Outer`
+    - `Side Panel Right Inner`
+    - `Side Panel Right`
 
 #### LCD
 - info()

src/spice2x/acio/acio.cpp

@@ -41,6 +41,7 @@
 namespace acio {
     HINSTANCE DLL_INSTANCE = nullptr;
     std::vector<acio::ACIOModule *> MODULES;
+    std::atomic<bool> IO_INIT_IN_PROGRESS = false;
 }
 
 /*
@@ -58,6 +59,7 @@ static inline acio::HookMode get_hookmode() {
 
 void acio::attach() {
     log_info("acio", "SpiceTools ACIO");
+    IO_INIT_IN_PROGRESS = true;
 
     // load settings and instance
     acio::DLL_INSTANCE = LoadLibraryA("libacio.dll");
@@ -111,6 +113,8 @@ void acio::attach() {
     for (auto &module : MODULES) {
         module->attach();
     }
+
+    IO_INIT_IN_PROGRESS = false;
 }
 
 void acio::attach_icca() {

src/spice2x/acio/acio.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <atomic>
 #include <vector>
 
 #include <windows.h>
@@ -11,6 +12,7 @@ namespace acio {
     // globals
     extern HINSTANCE DLL_INSTANCE;
     extern std::vector<acio::ACIOModule *> MODULES;
+    extern std::atomic<bool> IO_INIT_IN_PROGRESS;
 
     void attach();
     void attach_icca();

src/spice2x/api/modules/iidx.cpp

@@ -1,13 +1,9 @@
 #include "iidx.h"
 #include <functional>
-#include <vector>
-#include "games/iidx/iidx.h"
-#include "external/rapidjson/document.h"
 
 using namespace std::placeholders;
 using namespace rapidjson;
 
-
 namespace api::modules {
 
     // settings
@@ -17,6 +13,11 @@ namespace api::modules {
         functions["ticker_get"] = std::bind(&IIDX::ticker_get, this, _1, _2);
         functions["ticker_set"] = std::bind(&IIDX::ticker_set, this, _1, _2);
         functions["ticker_reset"] = std::bind(&IIDX::ticker_reset, this, _1, _2);
+        functions["tapeled_get"] = std::bind(&IIDX::tapeled_get, this, _1, _2);
+
+        for (auto &light : games::iidx::TAPELED_MAPPING) {
+            this->lights_by_names.emplace(light.lightName, light);
+        }
     }
 
     /**
@@ -69,4 +70,51 @@ namespace api::modules {
         // disable read only
         games::iidx::IIDXIO_LED_TICKER_READONLY = false;
     }
+
+    /**
+     * tapeled_get()
+     * tapeled_get(name: str, ...)
+     */
+    void IIDX::tapeled_get(Request &req, Response &res) {
+        Value response_object(kObjectType);
+
+        // all tape leds
+        if (req.params.Size() == 0) {
+            // Iterate through each device and dump its lights data into the response
+            for (const auto &mapping : games::iidx::TAPELED_MAPPING) {
+                copy_tapeled_data(res, response_object, mapping);
+            }
+        } else {
+            // specified light names
+            for (Value &param : req.params.GetArray()) {
+                // check params
+                if (!param.IsString()) {
+                    error_type(res, "name", "string");
+                    return;
+                }
+                const auto name = param.GetString();
+                if (const auto &it = lights_by_names.find(name); it != lights_by_names.end()) {
+                    const auto mapping = it->second.get();
+                    copy_tapeled_data(res, response_object, mapping);
+                }
+            }
+        }
+
+        res.add_data(response_object);
+    }
+
+    void IIDX::copy_tapeled_data(Response &res, Value &response_object, const tapeledutils::tape_led &mapping) {
+        // Create an array for the light state
+        Value light_state(kArrayType);
+        light_state.Reserve(mapping.data.capacity() * 3, res.doc()->GetAllocator());
+        for (const auto [r, g, b] : mapping.data) {
+            light_state.PushBack(r, res.doc()->GetAllocator());
+            light_state.PushBack(g, res.doc()->GetAllocator());
+            light_state.PushBack(b, res.doc()->GetAllocator());
+        }
+
+        // Can't use StringRef here, turns some strings partially into null bytes for some reason
+        Value light_name(mapping.lightName.c_str(), res.doc()->GetAllocator());
+        response_object.AddMember(light_name, light_state, res.doc()->GetAllocator());
+    }
 }

src/spice2x/api/modules/iidx.h

@@ -2,6 +2,7 @@
 
 #include "api/module.h"
 #include "api/request.h"
+#include "games/iidx/iidx.h"
 
 namespace api::modules {
 
@@ -10,10 +11,16 @@ namespace api::modules {
         IIDX();
 
     private:
+        // state
+        robin_hood::unordered_map<std::string, std::reference_wrapper<tapeledutils::tape_led>> lights_by_names;
 
         // function definitions
         void ticker_get(Request &req, Response &res);
         void ticker_set(Request &req, Response &res);
         void ticker_reset(Request &req, Response &res);
+        void tapeled_get(Request &req, Response &res);
+
+        // helper
+        void copy_tapeled_data(Response &res, rapidjson::Value &response_object, const tapeledutils::tape_led &mapping);
     };
 }

src/spice2x/api/resources/python/spiceapi/iidx.py

@@ -16,3 +16,13 @@ def iidx_ticker_set(con: Connection, text: str):
 def iidx_ticker_reset(con: Connection):
     req = Request("iidx", "ticker_reset")
     con.request(req)
+
+
+def iidx_tapeled_get(con: Connection, *light_names):
+    req = Request("iidx", "tapeled_get")
+
+    for light_name in light_names:
+        req.add_param(light_name)
+
+    res = con.request(req)
+    return res.get_data()

src/spice2x/cfg/option.h

@@ -43,6 +43,7 @@ public:
     std::string value;
     std::vector<Option> alternatives;
     bool disabled = false;
+    bool conflicting = false;
 
     explicit Option(OptionDefinition definition, std::string value = "") :
         definition(std::move(definition)), value(std::move(value)) {

src/spice2x/changelog.txt

@@ -1,3 +1,14 @@
+06/03/2025 [spice2x]
+    Add libshare-pj.dll to Gitadora patch import
+    Detect ACIO init failures
+
+05/31/2025 [spice2x]
+    IIDX: fix windowed subscreen not accepting mouse clicks when
+        overlay is active
+    IIDX: tape LED over API
+    Option to make command line args take precedence
+    UI tweaks
+
 05/09/2025 [spice2x]
     Check for window focus when processing input (-inputfocus)
     More options for IIDX/SDVX windowed subscreen

src/spice2x/games/iidx/bi2x_hook.cpp

@@ -409,50 +409,27 @@ namespace games::iidx {
          * 16 - side panel right - 183 bytes - 61 colors
          *
          * data is stored in RGB order, 3 bytes per color
-         *
-         * TODO: expose this data via API
          */
 
-        // data mapping
-        static struct TapeLedMapping {
-            size_t data_size;
-            int index_r, index_g, index_b;
-
-            TapeLedMapping(size_t data_size, int index_r, int index_g, int index_b)
-            : data_size(data_size), index_r(index_r), index_g(index_g), index_b(index_b) {}
-
-        } mapping[] = {
-                { 19, Lights::StageLeftAvgR, Lights::StageLeftAvgG, Lights::StageLeftAvgB },
-                { 19, Lights::StageRightAvgR, Lights::StageRightAvgG, Lights::StageRightAvgB },
-                { 45, Lights::CabinetLeftAvgR, Lights::CabinetLeftAvgG, Lights::CabinetLeftAvgB },
-                { 45, Lights::CabinetRightAvgR, Lights::CabinetRightAvgG, Lights::CabinetRightAvgB },
-                { 21, Lights::ControlPanelUnderAvgR, Lights::ControlPanelUnderAvgG, Lights::ControlPanelUnderAvgB },
-                { 54, Lights::CeilingLeftAvgR, Lights::CeilingLeftAvgG, Lights::CeilingLeftAvgB },
-                { 11, Lights::TitleLeftAvgR, Lights::TitleLeftAvgG, Lights::TitleLeftAvgB },
-                { 11, Lights::TitleRightAvgR, Lights::TitleRightAvgG, Lights::TitleRightAvgB },
-                { 54, Lights::CeilingRightAvgR, Lights::CeilingRightAvgG, Lights::CeilingRightAvgB },
-                { 17, Lights::TouchPanelLeftAvgR, Lights::TouchPanelLeftAvgG, Lights::TouchPanelLeftAvgB },
-                { 17, Lights::TouchPanelRightAvgR, Lights::TouchPanelRightAvgG, Lights::TouchPanelRightAvgB },
-                { 68, Lights::SidePanelLeftInnerAvgR, Lights::SidePanelLeftInnerAvgG, Lights::SidePanelLeftInnerAvgB },
-                { 68, Lights::SidePanelLeftOuterAvgR, Lights::SidePanelLeftOuterAvgG, Lights::SidePanelLeftOuterAvgB },
-                { 61, Lights::SidePanelLeftAvgR, Lights::SidePanelLeftAvgG, Lights::SidePanelLeftAvgB },
-                { 68, Lights::SidePanelRightOuterAvgR, Lights::SidePanelRightOuterAvgG, Lights::SidePanelRightOuterAvgB },
-                { 68, Lights::SidePanelRightInnerAvgR, Lights::SidePanelRightInnerAvgG, Lights::SidePanelRightInnerAvgB },
-                { 61, Lights::SidePanelRightAvgR, Lights::SidePanelRightAvgG, Lights::SidePanelRightAvgB },
-        };
-
         // check index bounds
-        if (tapeledutils::is_enabled() && index < std::size(mapping)) {
-            auto &map = mapping[index];
+        if (tapeledutils::is_enabled() && index < std::size(TAPELED_MAPPING)) {
+            auto &map = TAPELED_MAPPING[index];
+            const auto data_size = map.data.capacity();
 
             // pick a color to use
-            const auto rgb = tapeledutils::pick_color_from_led_tape(data, map.data_size);
+            const auto rgb = tapeledutils::pick_color_from_led_tape(data, data_size);
 
             // program the lights into API
             auto &lights = get_lights();
             GameAPI::Lights::writeLight(RI_MGR, lights[map.index_r], rgb.r);
             GameAPI::Lights::writeLight(RI_MGR, lights[map.index_g], rgb.g);
             GameAPI::Lights::writeLight(RI_MGR, lights[map.index_b], rgb.b);
+
+            for (unsigned int i = 0; i < data_size; ++i) {
+                map.data[i].r = data[i * 3];
+                map.data[i].g = data[i * 3 + 1];
+                map.data[i].b = data[i * 3 + 2];
+            }
         }
 
         if (This != custom_node) {

src/spice2x/games/iidx/iidx.cpp

@@ -28,6 +28,8 @@
 #include "util/sigscan.h"
 #include "util/utils.h"
 
+#include "external/robin_hood.h"
+
 #include "bi2a.h"
 #include "bi2x_hook.h"
 #include "ezusb.h"
@@ -74,6 +76,26 @@ namespace games::iidx {
     bool IIDXIO_LED_TICKER_READONLY = false;
     std::mutex IIDX_LED_TICKER_LOCK;
 
+    tapeledutils::tape_led TAPELED_MAPPING[IIDX_TAPELED_TOTAL] = {
+        { 19, Lights::StageLeftAvgR, Lights::StageLeftAvgG, Lights::StageLeftAvgB, "Stage Left" },
+        { 19, Lights::StageRightAvgR, Lights::StageRightAvgG, Lights::StageRightAvgB, "Stage Right" },
+        { 45, Lights::CabinetLeftAvgR, Lights::CabinetLeftAvgG, Lights::CabinetLeftAvgB, "Cabinet Left" },
+        { 45, Lights::CabinetRightAvgR, Lights::CabinetRightAvgG, Lights::CabinetRightAvgB, "Cabinet Right" },
+        { 21, Lights::ControlPanelUnderAvgR, Lights::ControlPanelUnderAvgG, Lights::ControlPanelUnderAvgB, "Control Panel Under" },
+        { 54, Lights::CeilingLeftAvgR, Lights::CeilingLeftAvgG, Lights::CeilingLeftAvgB, "Ceiling Left" },
+        { 11, Lights::TitleLeftAvgR, Lights::TitleLeftAvgG, Lights::TitleLeftAvgB, "Title Left" },
+        { 11, Lights::TitleRightAvgR, Lights::TitleRightAvgG, Lights::TitleRightAvgB, "Title Right" },
+        { 54, Lights::CeilingRightAvgR, Lights::CeilingRightAvgG, Lights::CeilingRightAvgB, "Ceiling Right" },
+        { 17, Lights::TouchPanelLeftAvgR, Lights::TouchPanelLeftAvgG, Lights::TouchPanelLeftAvgB, "Touch Panel Left" },
+        { 17, Lights::TouchPanelRightAvgR, Lights::TouchPanelRightAvgG, Lights::TouchPanelRightAvgB, "Touch Panel Right" },
+        { 68, Lights::SidePanelLeftInnerAvgR, Lights::SidePanelLeftInnerAvgG, Lights::SidePanelLeftInnerAvgB, "Side Panel Left Inner" },
+        { 68, Lights::SidePanelLeftOuterAvgR, Lights::SidePanelLeftOuterAvgG, Lights::SidePanelLeftOuterAvgB, "Side Panel Left Outer" },
+        { 61, Lights::SidePanelLeftAvgR, Lights::SidePanelLeftAvgG, Lights::SidePanelLeftAvgB, "Side Panel Left" },
+        { 68, Lights::SidePanelRightOuterAvgR, Lights::SidePanelRightOuterAvgG, Lights::SidePanelRightOuterAvgB, "Side Panel Right Outer" },
+        { 68, Lights::SidePanelRightInnerAvgR, Lights::SidePanelRightInnerAvgG, Lights::SidePanelRightInnerAvgB, "Side Panel Right Inner" },
+        { 61, Lights::SidePanelRightAvgR, Lights::SidePanelRightAvgG, Lights::SidePanelRightAvgB, "Side Panel Right" },
+    };
+
     static LONG WINAPI RegOpenKeyA_hook(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult) {
         if (lpSubKey != nullptr && phkResult != nullptr) {
             if (hKey == HKEY_LOCAL_MACHINE &&

src/spice2x/games/iidx/iidx.h

@@ -2,9 +2,13 @@
 
 #include <mutex>
 #include <optional>
+#include <vector>
 
 #include "games/game.h"
 
+#include "external/robin_hood.h"
+#include "util/tapeled.h"
+
 namespace games::iidx {
 
     // settings
@@ -30,6 +34,10 @@ namespace games::iidx {
     extern bool IIDXIO_LED_TICKER_READONLY;
     extern std::mutex IIDX_LED_TICKER_LOCK;
 
+    constexpr int IIDX_TAPELED_TOTAL = 17;
+    // data mapping
+    extern tapeledutils::tape_led TAPELED_MAPPING[IIDX_TAPELED_TOTAL];
+
     class IIDXGame : public games::Game {
     public:
         IIDXGame();

src/spice2x/launcher/launcher.cpp

@@ -244,6 +244,11 @@ int main_implementation(int argc, char *argv[]) {
     // parse arguments
     LAUNCHER_OPTIONS = launcher::parse_options(argc, argv);
 
+    // command line override (must be done before merging options with cfg)
+    if (LAUNCHER_OPTIONS->at(launcher::Options::OptionConflictResolution).value_bool()) {
+        launcher::USE_CMD_OVERRIDE = true;
+    }
+
     // determine config file path - must be done before anything else
     const auto &cfg_path = LAUNCHER_OPTIONS->at(launcher::Options::ConfigurationPath);
     if (cfg_path.is_active()) {
@@ -285,6 +290,7 @@ int main_implementation(int argc, char *argv[]) {
         cfg::CONFIGURATOR_TYPE = cfg::ConfigType::Config;
         cfg_run = true;
     }
+
     if (options[launcher::Options::EAmusementEmulation].value_bool() &&
         options[launcher::Options::ServiceURL].is_active() &&
         !cfg::CONFIGURATOR_STANDALONE) {
@@ -1220,6 +1226,38 @@ int main_implementation(int argc, char *argv[]) {
     }
     log_info("launcher", "arguments:\n{}", arguments.str());
 
+    // print out conflicts
+    size_t conflicts = 0;
+    for (const auto &option : options) {
+        if (option.conflicting && option.get_definition().type != OptionType::Bool) {
+            conflicts += 1;
+            if (launcher::USE_CMD_OVERRIDE) {
+                log_warning(
+                    "launcher",
+                    "multiple values for -{}, command line args take precedence: {}",
+                    option.get_definition().name, 
+                    option.value);
+            } else {
+                log_warning(
+                    "launcher",
+                    "multiple values for -{}, spicecfg values take precedence: {}",
+                    option.get_definition().name,
+                    option.value);
+            }
+        }
+    }
+    if (conflicts) {
+        if (launcher::USE_CMD_OVERRIDE) {
+            log_info(
+                "launcher",
+                "user specified -cmdoverride, therefore command line args took precedence over spicecfg"); 
+        } else {
+            log_warning(
+                "launcher",
+                "spicecfg values take precedence over command line args; to change this behavior, use -cmdoverride");
+        }
+    }
+
     if (options[launcher::Options::FullscreenResolution].is_active()) {
         std::pair<uint32_t, uint32_t> result;
         if (parse_width_height(options[launcher::Options::FullscreenResolution].value_text(), result)) {
@@ -1874,6 +1912,9 @@ int main_implementation(int argc, char *argv[]) {
     libutils::warn_if_dll_exists("d3d12.dll");
     libutils::warn_if_dll_exists("dxgi.dll");
     libutils::warn_if_dll_exists("opengl32.dll");
+    libutils::warn_if_dll_exists("nvcuda.dll");
+    libutils::warn_if_dll_exists("nvcuvid.dll");
+    libutils::warn_if_dll_exists("nvEncodeAPI64.dll");
 
     // complain loudly & early about dll load ordering issue
     libutils::check_duplicate_dlls();

src/spice2x/launcher/options.cpp

@@ -43,6 +43,8 @@ static const std::vector<std::string> CATEGORY_ORDER_NONE = {
     ""
 };
 
+bool launcher::USE_CMD_OVERRIDE = false;
+
 /*
  * Option Definitions
  * Be aware that the order must be the same as in the enum launcher::Options!
@@ -81,6 +83,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .category = "Network",
     },
     {
+        // ServiceURL
         .title = "EA Service URL",
         .name = "url",
         .desc = "Sets a custom service URL override",
@@ -142,6 +145,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .category = "Graphics (Windowed)",
     },
     {
+        // InjectHook
         .title = "Inject DLL Hooks",
         .name = "k",
         .desc = "Multiple files are allowed; use multiple -k flags, or in SpiceCfg, separate by "
@@ -152,6 +156,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .category = "Common",
     },
     {
+        // EarlyInjectHook
         .title = "Inject Early DLL Hooks",
         .name = "z",
         .desc = "Equivalent to 'Inject DLL Hooks' option, but ensures hooks are injected before "
@@ -668,6 +673,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .category = "Game Options (Advanced)",
     },
     {
+        // SDVXPrinterOutputPath
         .title = "SDVX Printer Output Path",
         .name = "printerpath",
         .desc = "Path to folder where images will be stored",
@@ -692,6 +698,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .category = "Game Options (Advanced)",
     },
     {
+        // SDVXPrinterOutputFormat
         .title = "SDVX Printer Output Format",
         .name = "printerformat",
         .desc = "File format for printer output",
@@ -1311,6 +1318,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .category = "Touch Parameters",
     },
     {
+        // ICCAReaderPort
         .title = "ICCA Reader Port",
         .name = "reader",
         .desc = "Connects to and uses a ICCA on a given COM port",
@@ -1387,6 +1395,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         },
     },
     {
+        // SextetStreamPort
         .title = "SextetStream Port",
         .name = "sextet",
         .desc = "Use a SextetStream device on a given COM port",
@@ -2260,6 +2269,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .category = "Game Options",
     },
     {
+        // LovePlusPrinterOutputPath
         .title = "LovePlus Printer Output Path",
         .name = "lpprinterpath",
         .desc = "Path to folder where images will be stored",
@@ -2284,6 +2294,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .category = "Game Options (Advanced)",
     },
     {
+        // LovePlusPrinterOutputFormat
         .title = "LovePlus Printer Output Format",
         .name = "lpprinterformat",
         .desc = "File format for printer output",
@@ -2301,6 +2312,16 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .game_name = "LovePlus",
         .category = "Game Options (Advanced)",
     },
+    {
+        // OptionConflictResolution
+        .title = "Command Line Args Override",
+        .name = "cmdoverride",
+        .desc = "By default, option values in spicecfg take precedence over command-line args, for legacy compat.\n"
+            "When this is specified in command line, command-line args take precedence instead",
+        .type = OptionType::Bool,
+        .category = "Development",
+        .disabled = true,
+    },
 };
 
 const std::vector<std::string> &launcher::get_categories(Options::OptionsCategory category) {
@@ -2482,12 +2503,25 @@ std::vector<Option> launcher::merge_options(
                         auto &new_option = merged.emplace_back(option.get_definition(), "");
                         new_option.disabled = true;
 
-                        for (auto &value : option.values()) {
-                            new_option.value_add(value);
-                        }
-                        for (auto &value : override.values()) {
-                            new_option.value_add(value);
+                        if (USE_CMD_OVERRIDE) {
+                            // command-line arguments take precedence (opt-in)
+                            for (auto &value : override.values()) {
+                                new_option.value_add(value);
+                            }
+                            for (auto &value : option.values()) {
+                                new_option.value_add(value);
+                            }
+                        } else {
+                            // spicecfg options take precedence (default)
+                            // this sucks, but it's the default for legacy spicetools compat
+                            for (auto &value : option.values()) {
+                                new_option.value_add(value);
+                            }
+                            for (auto &value : override.values()) {
+                                new_option.value_add(value);
+                            }
                         }
+                        new_option.conflicting = true;
                     } else {
                         auto &new_option = merged.emplace_back(override.get_definition(), "");
                         new_option.disabled = true;
@@ -2503,7 +2537,6 @@ std::vector<Option> launcher::merge_options(
             }
         }
     }
-
     return merged;
 }
 

src/spice2x/launcher/options.h

@@ -246,6 +246,7 @@ namespace launcher {
             LovePlusPrinterOutputOverwrite,
             LovePlusPrinterOutputFormat,
             LovePlusPrinterJPGQuality,
+            OptionConflictResolution,
         };
 
         enum class OptionsCategory {
@@ -257,6 +258,8 @@ namespace launcher {
         };
     }
 
+    extern bool USE_CMD_OVERRIDE;
+    
     const std::vector<std::string> &get_categories(Options::OptionsCategory category);
     const std::vector<OptionDefinition> &get_option_definitions();
     std::unique_ptr<std::vector<Option>> parse_options(int argc, char *argv[]);

src/spice2x/launcher/signal.cpp

@@ -6,6 +6,7 @@
 #include <windows.h>
 #include <dbghelp.h>
 
+#include "acio/acio.h"
 #include "external/stackwalker/stackwalker.h"
 #include "hooks/libraryhook.h"
 #include "launcher/shutdown.h"
@@ -97,6 +98,19 @@ static LONG WINAPI TopLevelExceptionFilter(struct _EXCEPTION_POINTERS *Exception
         // print signal
         log_warning("signal", "exception raised: {}", exception_code(ExceptionRecord));
 
+        // check ACIO init failures
+        if (acio::IO_INIT_IN_PROGRESS) {
+            log_warning(
+                "signal",
+                "exception raised during ACIO init, this usually happens when a third party application interferes with hooks");
+            log_warning(
+                "signal",
+                "    please check for the following, disable them, and try launching the game again:");
+            log_warning(
+                "signal",
+                "    RivaTuner Statistics Server (RTSS), MSI Afterburner, kernel mode anti-cheat");
+        }
+
         // walk the exception chain
         struct _EXCEPTION_RECORD *record_cause = ExceptionRecord->ExceptionRecord;
         while (record_cause != nullptr) {

src/spice2x/overlay/imgui/impl_spice.cpp

@@ -12,6 +12,7 @@
 #include "touch/touch.h"
 #include "util/logging.h"
 #include "util/utils.h"
+#include "hooks/graphics/graphics.h"
 
 #if !defined(IMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS) || \
     !defined(IMGUI_DISABLE_DEFAULT_ALLOCATORS) || \
@@ -175,10 +176,22 @@ static void ImGui_ImplSpice_UpdateMousePos() {
                     static_cast<int>(pos.y / io.DisplaySize.y * window_size.y));
         }
 
+        const auto active_window = ::GetForegroundWindow();
+
+        // if the main focus is a windowed subscreen, put the imgui cursor in a place that won't
+        // trigger any overlay, don't process anything else
+        const auto is_windowed_subscreen = 
+            (GRAPHICS_IIDX_WSUB && active_window == TDJ_SUBSCREEN_WINDOW) ||
+            (active_window == SDVX_SUBSCREEN_WINDOW);
+        if (is_windowed_subscreen) {
+            io.MousePos = ImVec2(-FLT_MAX, -FLT_MAX);
+            return;
+        }
+
         // set mouse position
         io.MousePos = ImVec2(-FLT_MAX, -FLT_MAX);
         POINT pos;
-        if (HWND active_window = ::GetForegroundWindow()) {
+        if (active_window) {
             if (active_window == g_hWnd
             || ::IsChild(active_window, g_hWnd)
             || ::IsChild(g_hWnd, active_window)
@@ -208,7 +221,7 @@ static void ImGui_ImplSpice_UpdateMousePos() {
         static size_t delay_touch = 0;
         static size_t delay_touch_target = 2;
         static DWORD last_touch_id = ~0u;
-        if (!touch_points.empty()) {
+        if (!touch_points.empty() && !is_windowed_subscreen) {
 
             // use the first touch point
             auto &tp = touch_points[0];

src/spice2x/overlay/windows/config.cpp

@@ -16,7 +16,6 @@
 #include "avs/ea3.h"
 #include "avs/game.h"
 #include "launcher/launcher.h"
-#include "launcher/shutdown.h"
 #include "launcher/options.h"
 #include "misc/eamuse.h"
 #include "overlay/imgui/extensions.h"
@@ -2914,7 +2913,7 @@ namespace overlay::windows {
         ImGui::TextUnformatted("");
 
         if (ImGui::Button(PROJECT_URL)) {
-            launch_shell(PROJECT_URL, nullptr);
+            launch_shell(PROJECT_URL);
         }
 
         ImGui::TextUnformatted("");
@@ -2979,31 +2978,28 @@ namespace overlay::windows {
     void Config::build_menu(int *game_selected) {
         bool about_popup = false;
         bool licenses_popup = false;
-        bool shutdown_popup = false;
         if (ImGui::BeginMenuBar()) {
 
             // [spice2x]
             ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.f, 0.f, 0.f, 1.f));
-            ImGui::PushStyleColor(ImGuiCol_TextDisabled, ImVec4(1.f, 0.f, 0.f, 1.f));
-            ImGui::BeginDisabled(!cfg::CONFIGURATOR_STANDALONE);
-            if (ImGui::MenuItem("[spice2x]")) {
-                launch_shell(PROJECT_URL, nullptr);
+            if (ImGui::BeginMenu("[spice2x]")) {
+                ImGui::PopStyleColor();
+                if (ImGui::MenuItem("spice2x.github.io")) {
+                    launch_shell(PROJECT_URL);
+                }
+                if (ImGui::MenuItem("Licenses")) {
+                    licenses_popup = true;
+                }
+                if (ImGui::MenuItem("About")) {
+                    about_popup = true;
+                }
+                ImGui::EndMenu();
+            } else {
+                ImGui::PopStyleColor();
             }
-            ImGui::EndDisabled();
-            ImGui::PopStyleColor();
-            ImGui::PopStyleColor();
-
-            ImGui::Separator();
-
-            // game selector
-            ImGui::PushItemWidth(MIN(580, MAX(80, ImGui::GetWindowSize().x - 520)));
-            ImGui::Combo("##game_selector", game_selected, games_names.data(), (int)games_list.size());
-            ImGui::PopItemWidth();
-
-            ImGui::Separator();
 
             // shortcuts
-            if (ImGui::BeginMenu("Shortcuts", cfg::CONFIGURATOR_STANDALONE)) {
+            if (ImGui::BeginMenu("Shortcuts")) {
                 if (ImGui::MenuItem("USB Game Controllers")) {
                     launch_shell("control.exe", "joy.cpl");
                 }
@@ -3016,32 +3012,21 @@ namespace overlay::windows {
                 ImGui::EndMenu();
             }
 
-            // popup menus
-            if (ImGui::MenuItem("Licenses")) {
-                licenses_popup = true;
-            }
-            if (ImGui::MenuItem("About")) {
-                about_popup = true;
-            }
-
-            // power - only active in games
-            if (ImGui::BeginMenu("Power", !cfg::CONFIGURATOR_STANDALONE)) {
-                if (ImGui::MenuItem("Restart Game")) {
-                    launcher::restart();
+            // help
+            if (ImGui::BeginMenu("Help")) {
+                if (ImGui::MenuItem("FAQ")) {
+                    launch_shell("https://github.com/spice2x/spice2x.github.io/wiki/Known-issues");
                 }
-                if (ImGui::MenuItem("Exit Game")) {
-                    launcher::shutdown();
-                }
-                ImGui::Spacing();
-                ImGui::Separator();
-                ImGui::Spacing();
-                if (ImGui::MenuItem("Shutdown PC")) {
-                    shutdown_popup = true;
+                if (ImGui::MenuItem("Wiki")) {
+                    launch_shell("https://github.com/spice2x/spice2x.github.io/wiki");
                 }
                 ImGui::EndMenu();
             }
 
-            ImGui::Separator();
+            // game selector
+            ImGui::PushItemWidth(MIN(700, MAX(100, ImGui::GetWindowSize().x - 400)));
+            ImGui::Combo("##game_selector", game_selected, games_names.data(), (int)games_list.size());
+            ImGui::PopItemWidth();
 
             ImGui::BeginDisabled();
             if (!avs::game::is_model("000")) {
@@ -3059,45 +3044,9 @@ namespace overlay::windows {
         if (licenses_popup) {
             ImGui::OpenPopup("Licenses##topbarpopup");
         }
-        if (shutdown_popup) {
-            ImGui::OpenPopup("System##topbarpopup");
-        }
 
         // draw popups
         {
-            // unused_open is needed for close button to appear on the popup
-            bool unused_open = true;
-
-            if (ImGui::BeginPopupModal(
-                "System##topbarpopup",
-                &unused_open,
-                ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize)) {
-
-                static bool force_shutdown = false;
-                ImGui::Spacing();
-                ImGui::Checkbox("Force", &force_shutdown);
-                ImGui::Spacing();
-
-                const ImVec2 button_size(100.f, 0.f);
-
-                ImGui::Spacing();
-                if (ImGui::Button("Shutdown PC", button_size)) {
-                    this->shutdown_system(force_shutdown, false);
-                }
-                ImGui::Spacing();
-                if (ImGui::Button("Reboot PC", button_size)) {
-                    this->shutdown_system(force_shutdown, true);
-                }
-                ImGui::Spacing();
-                ImGui::Separator();
-                ImGui::Spacing();
-                if (ImGui::Button("Cancel", button_size)) {
-                    ImGui::CloseCurrentPopup();
-                }
-                ImGui::Spacing();
-                ImGui::EndPopup();
-            }
-
             const ImVec2 popup_size(
                 std::min(ImGui::GetIO().DisplaySize.x * 0.9f, 800.f),
                 std::min(ImGui::GetIO().DisplaySize.y * 0.9f, 800.f));
@@ -3122,23 +3071,4 @@ namespace overlay::windows {
             }
         }
     }
-
-    void Config::shutdown_system(bool force, bool reboot_instead) {
-        if (!acquire_shutdown_privs()) {
-            return;
-        }
-        UINT flags = 0;
-        if (force) {
-            flags |= EWX_FORCE;
-        }
-        if (reboot_instead) {
-            flags |= EWX_REBOOT;
-        } else {
-            flags |= EWX_SHUTDOWN | EWX_HYBRID_SHUTDOWN;
-        }
-        if (!ExitWindowsEx(flags, SHTDN_REASON_MAJOR_APPLICATION | SHTDN_REASON_MINOR_MAINTENANCE)) {
-            return;
-        }
-        launcher::shutdown(0);
-    }
 }

src/spice2x/overlay/windows/config.h

@@ -95,7 +95,7 @@ namespace overlay::windows {
         void build_about();
         void build_licenses();
         void build_launcher();
-        void launch_shell(LPCSTR app, LPCSTR file);
+        void launch_shell(LPCSTR app, LPCSTR file=nullptr);
 
         static void build_page_selector(int *page);
         void build_menu(int *game_selected);

src/spice2x/overlay/windows/patch_manager.cpp

@@ -80,7 +80,7 @@ namespace overlay::windows {
         {"arkmmd.dll", {"gamemmd.dll"}},
         {"arkklp.dll", {"lpac.dll"}},
         {"arknck.dll", {"weac.dll"}},
-        {"gdxg.dll", {"game.dll"}}
+        {"gdxg.dll", {"game.dll", "libshare-pj.dll"}}
     };
 
     static size_t url_recent_idx = -1;

src/spice2x/touch/touch.cpp

@@ -240,8 +240,11 @@ static LRESULT CALLBACK SpiceTouchWndProc(HWND hWnd, UINT msg, WPARAM wParam, LP
         rawinput::touch::display_update();
     }
 
+    const auto is_windowed_sub =
+        (GRAPHICS_IIDX_WSUB && hWnd == TDJ_SUBSCREEN_WINDOW) || (hWnd == SDVX_SUBSCREEN_WINDOW);
+
     if (msg == WM_CLOSE) { 
-        if ((GRAPHICS_IIDX_WSUB && hWnd == TDJ_SUBSCREEN_WINDOW) || (hWnd == SDVX_SUBSCREEN_WINDOW)) {
+        if (is_windowed_sub) {
             log_misc("touch", "ignore WM_CLOSE for subscreen window");
             return false;
         }
@@ -461,11 +464,14 @@ static LRESULT CALLBACK SpiceTouchWndProc(HWND hWnd, UINT msg, WPARAM wParam, LP
     };
 
     // check if imgui is handling this mouse event
-    if (overlay::OVERLAY != nullptr && overlay::OVERLAY->get_active() && ImGui::GetIO().WantCaptureMouse) {
+    if (is_windowed_sub) {
+        // do nothing, don't let imgui hijack clicks on the sub window
+        result.action = ACTION_PASS;
+
+    } else if (overlay::OVERLAY != nullptr && overlay::OVERLAY->get_active() && ImGui::GetIO().WantCaptureMouse) {
         result.action = ACTION_RETURN_DEFAULT;
 
     } else if (TOUCH_HANDLER != nullptr) {
-
         // call touch handler
         TOUCH_HANDLER->handle_message(result, hWnd, msg, wParam, lParam);
     }

src/spice2x/util/tapeled.h

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <cstdint>
+#include <string>
+#include <vector>
 
 namespace tapeledutils {
 
@@ -20,6 +22,15 @@ namespace tapeledutils {
         float b;
     } rgb_float3_t;
 
+    struct tape_led {
+        std::vector<rgb_float3_t> data;
+        int index_r, index_g, index_b; // Averaged RGB light output indexes
+        std::string lightName;
+
+        tape_led(size_t data_size, int index_r, int index_g, int index_b, std::string lightName)
+        : data(std::vector<rgb_float3_t>(data_size)), index_r(index_r), index_g(index_g), index_b(index_b), lightName(std::move(lightName)) {}
+    };
+
     bool is_enabled();
     rgb_float3_t pick_color_from_led_tape(uint8_t *data, size_t data_size);
     size_t get_led_index_using_avg_algo(size_t data_size);