Use read byte data for ENE detect

.gitignore

@@ -6,8 +6,6 @@ OpenRGB
 openrgb
 OpenRGB-x86_64.AppImage
 60-openrgb.rules
-debian/changelog
-fedora/OpenRGB.spec
 
 # Directories
 .build/
@@ -118,3 +116,4 @@ compile_commands.json
 
 # Generated i18n files
 *.qm
+

.gitlab-ci.yml

@@ -43,7 +43,6 @@ before_script:
     name: "${CI_PROJECT_NAME}_Supported_Devices_${CI_COMMIT_SHORT_SHA}"
     paths:
     - ./*.md
-    - Supported Devices.csv
     exclude:
     - README.md
     - CONTRIBUTING.md
@@ -109,10 +108,9 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
   stage: build
   script:
-  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
-  - rm -v ../openrgb-dbgsym*.*deb
+  - rm -v ../openrgb-dbgsym*.deb
   - mv -v ../openrgb*.deb ./
 
   artifacts:
@@ -120,7 +118,7 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
     expire_in: 30 days
 
   rules:
@@ -138,10 +136,9 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
   stage: build
   script:
-  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.*deb
+  - rm -v ../openrgb-dbgsym*.deb
   - mv -v ../openrgb*.deb ./
 
   artifacts:
@@ -149,7 +146,7 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
     expire_in: 30 days
 
   rules:
@@ -167,10 +164,9 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
   stage: build
   script:
-  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
-  - rm -v ../openrgb-dbgsym*.*deb
+  - rm -v ../openrgb-dbgsym*.deb
   - mv -v ../openrgb*.deb ./
 
   artifacts:
@@ -178,7 +174,7 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
     expire_in: 30 days
 
   rules:
@@ -196,10 +192,9 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
   stage: build
   script:
-  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.*deb
+  - rm -v ../openrgb-dbgsym*.deb
   - mv -v ../openrgb*.deb ./
 
   artifacts:
@@ -207,7 +202,7 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
     expire_in: 30 days
 
   rules:
@@ -225,7 +220,6 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
   stage: build
   script:
-  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
   - rm -v ../openrgb-dbgsym*.deb
@@ -254,7 +248,6 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
   stage: build
   script:
-  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
   - rm -v ../openrgb-dbgsym*.deb
@@ -284,7 +277,6 @@ before_script:
   script:
   - dnf install rpmdevtools dnf-plugins-core -y
   - rpmdev-setuptree
-  - ./scripts/build-package-files.sh fedora/OpenRGB.spec
   - ls /root/
   - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
   - cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
@@ -317,9 +309,8 @@ before_script:
   image: fedora:36
   stage: build
   script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel -y
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel -y
   - rpmdev-setuptree
-  - ./scripts/build-package-files.sh fedora/OpenRGB.spec
   - ls /root/
   - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
   - cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
@@ -355,6 +346,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 32 .deb (Debian Buster)"
@@ -371,6 +363,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Buster)"
@@ -387,6 +380,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 32 .deb (Debian Bullseye)"
@@ -403,6 +397,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Bullseye)"
@@ -419,6 +414,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 32 .deb (Debian Bookworm)"
@@ -435,6 +431,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Bookworm)"
@@ -451,6 +448,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Buster)"
@@ -467,6 +465,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Bookworm)"
@@ -482,6 +481,7 @@ before_script:
   script:
   - yum -y localinstall ./openrgb*64.rpm
   - openrgb --version
+  - openrgb -l
   - yum -y remove openrgb
   dependencies:
   - "Linux 64 f35 rpm"
@@ -497,6 +497,7 @@ before_script:
   script:
   - yum -y localinstall ./openrgb*64.rpm
   - openrgb --version
+  - openrgb -l
   - yum -y remove openrgb
   dependencies:
   - "Linux 64 f36 rpm"
@@ -528,9 +529,9 @@ before_script:
   - mkdir _qt
   - mkdir _qt_download
   - Push-Location _qt_download
-  - curl.exe -LJ -o qt-base.7z  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610076/download'
-  - curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610097/download'
-  - curl.exe -LJ -o qt-jom.zip  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
+  - curl.exe -LJ -o qt-base.7z  'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
+  - curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
+  - curl.exe -LJ -o qt-jom.zip  'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
   - _fold_final_
 
   - _fold_start_ 'extracting the downloaded qt binaries'
@@ -546,6 +547,10 @@ before_script:
   - Pop-Location
   - _fold_final_
 
+  - _fold_start_ 'Generate qm files'
+  - .\_qt\5.15.0\msvc2019\bin\lrelease OpenRGB.pro
+  - _fold_final_
+
   - _fold_start_ 'run qmake and generate the msvc nmake makefile'
   - mkdir _build; cd _build
   - ..\_qt\5.15.0\msvc2019\bin\qmake ..\OpenRGB.pro
@@ -570,8 +575,6 @@ before_script:
     name: "${CI_PROJECT_NAME}_Windows_32_${CI_COMMIT_SHORT_SHA}"
     paths:
     - 'OpenRGB Windows 32-bit'
-    exclude:
-    - 'OpenRGB Windows 32-bit\*.qm'
     expire_in: 30 days
 
   rules:
@@ -606,9 +609,9 @@ before_script:
   - mkdir _qt
   - mkdir _qt_download
   - Push-Location _qt_download
-  - curl.exe -LJ -o qt-base.7z  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610116/download'
-  - curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610131/download'
-  - curl.exe -LJ -o qt-jom.zip  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
+  - curl.exe -LJ -o qt-base.7z  'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
+  - curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
+  - curl.exe -LJ -o qt-jom.zip  'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
   - _fold_final_
 
   - _fold_start_ 'extracting the downloaded qt binaries'
@@ -624,6 +627,10 @@ before_script:
   - Pop-Location
   - _fold_final_
 
+  - _fold_start_ 'Generate qm files'
+  - .\_qt\5.15.0\msvc2019_64\bin\lrelease OpenRGB.pro
+  - _fold_final_
+
   - _fold_start_ 'run qmake and generate the msvc nmake makefile'
   - mkdir _build; cd _build
   - ..\_qt\5.15.0\msvc2019_64\bin\qmake ..\OpenRGB.pro
@@ -648,8 +655,6 @@ before_script:
     name: "${CI_PROJECT_NAME}_Windows_64_${CI_COMMIT_SHORT_SHA}"
     paths:
     - 'OpenRGB Windows 64-bit'
-    exclude:
-    - 'OpenRGB Windows 64-bit\*.qm'
     expire_in: 30 days
 
 #-----------------------------------------------------------------------#

.gitlab/CODEOWNERS

@@ -74,6 +74,7 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/NZXTHue2Controller/
 /Controllers/NZXTHuePlusController/
 /Controllers/NZXTKrakenController/
+/Controllers/OpenRazerController/
 /Controllers/PNYGPUController/
 /Controllers/PatriotViperController/
 /Controllers/PhilipsHueController/

.vscode/extensions.json

@@ -1,10 +0,0 @@
-{
-    // See http://go.microsoft.com/fwlink/?LinkId=827846
-    // for the documentation about the extensions.json format
-    "recommendations": [
-        "EditorConfig.EditorConfig"
-    ],
-    "unwantedRecommendations": [
-        "ms-vscode.cpptools-extension-pack"
-    ]
-}

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -3,6 +3,7 @@
 \*-----------------------------------------------------*/
 #include <hidapi/hidapi.h>
 #include "Detector.h"
+#include "LogManager.h"
 #include "RGBController.h"
 
 /*-----------------------------------------------------*\
@@ -30,5 +31,4 @@ void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name
 }
 
 REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
 REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);

Controllers/A4TechController/BloodyMouseController.cpp

@@ -8,7 +8,6 @@
 \*---------------------------------------------------------------------*/
 
 #include "BloodyMouseController.h"
-#include "LogManager.h"
 
 BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
 {

Controllers/A4TechController/BloodyMouseController.h

@@ -9,6 +9,7 @@
 
 #include <string>
 #include <hidapi/hidapi.h>
+#include "LogManager.h"
 #include "RGBController.h"
 
 #pragma once
@@ -17,7 +18,6 @@
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
 #define BLOODY_W60_PRO_PID                          0x37EA
-#define BLOODY_W90_MAX_PID                          0x3666
 
 /*-----------------------------------------------------*\
 | Mousemat product IDs                                  |

Controllers/A4TechController/RGBController_BloodyMouse.cpp

@@ -25,19 +25,6 @@ static const mouse_layout w60_pro
     }
 };
 
-static const mouse_layout w90_max
-{
-    {
-        "Scroll Wheel", { 14 }
-    },
-    {
-        "Logo",         { 7 }
-    },
-    {
-        "Rear",         { 13, 12, 11, 10, 9, 8, 6, 5, 4, 3, 2, 1, 0 }
-    }
-};
-
 static const mouse_layout mp_50rs
 {
     {
@@ -69,6 +56,7 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont
             type                = DEVICE_TYPE_MOUSE;
     }
 
+    name                        = "BloodyMouse";
     vendor                      = "Bloody";
     description                 = "Controller compatible with the Bloody W60 Pro and MP 50RS";
     serial                      = controller->GetSerial();
@@ -101,15 +89,11 @@ void RGBController_BloodyMouse::SetupZones()
     | Select layout from PID                            |
     \*-------------------------------------------------*/
     mouse_layout layout;
-
     switch(controller->GetPid())
     {
         case BLOODY_W60_PRO_PID:
             layout = w60_pro;
             break;
-        case BLOODY_W90_MAX_PID:
-            layout = w90_max;
-            break;
         case BLOODY_MP_50RS_PID:
             layout = mp_50rs;
             break;

Controllers/A4TechController/RGBController_BloodyMouse.h

@@ -9,6 +9,7 @@
 
 #pragma once
 #include <vector>
+#include "LogManager.h"
 #include "RGBController.h"
 #include "BloodyMouseController.h"
 

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -17,6 +17,8 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
     dev         = dev_handle;
     location    = path;
 
+    strcpy(device_name, "AMD Wraith Prism");
+
     current_fan_mode            = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
     current_fan_speed           = 0xFF;
     current_fan_random_color    = false;
@@ -31,6 +33,8 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
     current_ring_speed          = 0xFF;
     current_ring_direction      = false;
     current_ring_brightness     = 0xFF;
+
+    SendEnableCommand();
 }
 
 AMDWraithPrismController::~AMDWraithPrismController()
@@ -43,6 +47,11 @@ std::string AMDWraithPrismController::GetLocationString()
     return("HID: " + location);
 }
 
+char* AMDWraithPrismController::GetDeviceName()
+{
+    return device_name;
+}
+
 std::string AMDWraithPrismController::GetSerialString()
 {
     wchar_t serial_string[128];
@@ -59,6 +68,41 @@ std::string AMDWraithPrismController::GetSerialString()
     return(return_string);
 }
 
+std::string AMDWraithPrismController::GetEffectChannelString(unsigned char channel)
+{
+    std::string ret_string = "";
+
+    unsigned char usb_buf[] =
+    {
+        0x00,
+        0x40, 0x21, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+    };
+
+    usb_buf[0x03] = channel;
+
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
+
+    ret_string.append((char *)&usb_buf[0x08]);
+
+    return(ret_string);
+}
+
 std::string AMDWraithPrismController::GetFirmwareVersionString()
 {
     std::string ret_string = "";
@@ -188,7 +232,7 @@ void AMDWraithPrismController::SetRingEffectChannel(unsigned char channel)
     SendChannelRemap(channel, AMD_WRAITH_PRISM_EFFECT_CHANNEL_LOGO_LED, AMD_WRAITH_PRISM_EFFECT_CHANNEL_FAN_LED);
 }
 
-void AMDWraithPrismController::SendEnableCommand(bool direct)
+void AMDWraithPrismController::SendEnableCommand()
 {
     unsigned char usb_buf[] =
     {
@@ -211,11 +255,6 @@ void AMDWraithPrismController::SendEnableCommand(bool direct)
         0x00, 0x00, 0x00, 0x00,
     };
 
-    if(direct)
-    {
-        usb_buf[0x02]   = 0x03;
-    }
-
     hid_write(dev, usb_buf, 65);
     hid_read(dev, usb_buf, 64);
 }
@@ -247,48 +286,6 @@ void AMDWraithPrismController::SendApplyCommand()
     hid_read(dev, usb_buf, 64);
 }
 
-void AMDWraithPrismController::SendDirectPacket
-    (
-    unsigned char   size,
-    unsigned char * led_ids,
-    RGBColor *      colors
-    )
-{
-    unsigned char usb_buf[] =
-    {
-        0x00,
-        0xC0, 0x01, size, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-    };
-
-    for(unsigned int led_idx = 0; led_idx < size; led_idx++)
-    {
-        unsigned int index  = led_idx * 4;
-
-        usb_buf[index + 5]  = led_ids[led_idx];
-        usb_buf[index + 6]  = RGBGetRValue(colors[led_idx]);
-        usb_buf[index + 7]  = RGBGetGValue(colors[led_idx]);
-        usb_buf[index + 8]  = RGBGetBValue(colors[led_idx]);
-    }
-
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
-}
-
 void AMDWraithPrismController::SendEffectChannelUpdate
     (
     unsigned char effect_channel,

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

@@ -10,8 +10,6 @@
 #include <string>
 #include <hidapi/hidapi.h>
 
-#include "RGBController.h"
-
 #pragma once
 
 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
@@ -76,7 +74,6 @@ enum
     AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE       = 0x09, /* Chase effect channel         */
     AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL       = 0x0A, /* Swirl effect channel         */
     AMD_WRAITH_PRISM_EFFECT_CHANNEL_MORSE       = 0x0B, /* Morse code effect channel    */
-    AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT      = 0xFF, /* Value for direct mode        */
 };
 
 enum
@@ -94,11 +91,29 @@ public:
     AMDWraithPrismController(hid_device* dev_handle, const char* path);
     ~AMDWraithPrismController();
 
+    char* GetDeviceName();
+
     std::string GetEffectChannelString(unsigned char channel);
     std::string GetFirmwareVersionString();
     std::string GetLocationString();
     std::string GetSerialString();
 
+    void SetRingEffectChannel(unsigned char channel);
+
+    void SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
+    void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
+
+    void SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
+    void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
+
+    void SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color);
+    void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
+
+private:
+    char                    device_name[32];
+    hid_device*             dev;
+    std::string             location;
+
     unsigned char           current_fan_mode;
     unsigned char           current_fan_speed;
     unsigned char           current_fan_brightness;
@@ -115,30 +130,10 @@ public:
     bool                    current_ring_direction;
     bool                    current_ring_random_color;
 
-    void SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
-    void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
-    void SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
-    void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
-    void SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color);
-    void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
-
-    void SendDirectPacket
-        (
-        unsigned char   size,
-        unsigned char * led_ids,
-        RGBColor *      colors
-        );
-
-    void SendEnableCommand(bool direct);
+    void SendEnableCommand();
 
     void SendApplyCommand();
 
-private:
-    hid_device*             dev;
-    std::string             location;
-
-    void SetRingEffectChannel(unsigned char channel);
-
     void SendEffectChannelUpdate
         (
         unsigned char effect_channel,

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -33,29 +33,33 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     description = "AMD Wraith Prism Device";
     version     = controller->GetFirmwareVersionString();
     location    = controller->GetLocationString();
+    /*-----------------------------------------------------*\
+    | Don't use HID serial string, it is inconsistent on my |
+    | Wraith Prism                                          |
+    \*-----------------------------------------------------*/
+    serial      = "";//controller->GetSerialString();
 
     mode Direct;
     Direct.name                 = "Direct";
-    Direct.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT;
+    Direct.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
     Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Direct.brightness_min       = 0;
-    Direct.brightness_max       = 0;
-    Direct.brightness           = 0;
+    Direct.brightness_max       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Direct.brightness           = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
     Direct.color_mode           = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Breathing;
     Breathing.name              = "Breathing";
     Breathing.value             = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Breathing.speed_min         = AMD_WRAITH_PRISM_SPEED_SLOWEST;
     Breathing.speed_max         = AMD_WRAITH_PRISM_SPEED_FASTEST;
     Breathing.brightness_min    = 0;
     Breathing.brightness_max    = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
     Breathing.brightness        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
     Breathing.speed             = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    Breathing.colors.resize(3);
     modes.push_back(Breathing);
 
     mode ColorCycle;
@@ -100,29 +104,27 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     mode Chase;
     Chase.name                  = "Chase";
     Chase.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE;
-    Chase.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Chase.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Chase.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
     Chase.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
     Chase.brightness_min        = 0;
     Chase.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
     Chase.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Chase.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Chase.color_mode            = MODE_COLORS_PER_LED;
     Chase.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    Chase.colors.resize(3);
     modes.push_back(Chase);
 
     mode Swirl;
     Swirl.name                  = "Swirl";
     Swirl.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL;
-    Swirl.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Swirl.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Swirl.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
     Swirl.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
     Swirl.brightness_min        = 0;
     Swirl.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
     Swirl.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Swirl.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Swirl.color_mode            = MODE_COLORS_PER_LED;
     Swirl.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    Swirl.colors.resize(3);
     modes.push_back(Swirl);
 
     SetupZones();
@@ -135,14 +137,6 @@ RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 
 void RGBController_AMDWraithPrism::SetupZones()
 {
-    /*---------------------------------------------------------*\
-    | LED maps                                                  |
-    \*---------------------------------------------------------*/
-    const unsigned int logo_leds[1] =   { 0x00 };
-    const unsigned int fan_leds[1] =    { 0x01 };
-    const unsigned int ring_leds[14] =  { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10, 0x0F,
-                                          0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };
-
     /*---------------------------------------------------------*\
     | Set up zones                                              |
     \*---------------------------------------------------------*/
@@ -166,39 +160,27 @@ void RGBController_AMDWraithPrism::SetupZones()
 
     zone ring_zone;
     ring_zone.name          = "Ring";
-    ring_zone.type          = ZONE_TYPE_LINEAR;
-    ring_zone.leds_min      = 14;
-    ring_zone.leds_max      = 14;
-    ring_zone.leds_count    = 14;
+    ring_zone.type          = ZONE_TYPE_SINGLE;
+    ring_zone.leds_min      = 1;
+    ring_zone.leds_max      = 1;
+    ring_zone.leds_count    = 1;
     ring_zone.matrix_map    = NULL;
     zones.push_back(ring_zone);
 
     /*---------------------------------------------------------*\
     | Set up LEDs                                               |
     \*---------------------------------------------------------*/
-    for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
-    {
-        led logo_led;
-        logo_led.name = "Logo LED";
-        logo_led.value = logo_leds[led_idx];
-        leds.push_back(logo_led);
-    }
+    led logo_led;
+    logo_led.name = "Logo LED";
+    leds.push_back(logo_led);
 
-    for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
-    {
-        led fan_led;
-        fan_led.name = "Fan LED";
-        fan_led.value = fan_leds[led_idx];
-        leds.push_back(fan_led);
-    }
+    led fan_led;
+    fan_led.name = "Fan LED";
+    leds.push_back(fan_led);
 
-    for(unsigned int led_idx = 0; led_idx < 14; led_idx++)
-    {
-        led ring_led;
-        ring_led.name = "Ring LED";
-        ring_led.value = ring_leds[led_idx];
-        leds.push_back(ring_led);
-    }
+    led ring_led;
+    ring_led.name = "Ring LED";
+    leds.push_back(ring_led);
 
     SetupColors();
 }
@@ -212,95 +194,68 @@ void RGBController_AMDWraithPrism::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
 {
-    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+    controller->SetLogoColor(red, grn, blu);
+
+    red = RGBGetRValue(colors[1]);
+    grn = RGBGetGValue(colors[1]);
+    blu = RGBGetBValue(colors[1]);
+    controller->SetFanColor(red, grn, blu);
+
+    red = RGBGetRValue(colors[2]);
+    grn = RGBGetGValue(colors[2]);
+    blu = RGBGetBValue(colors[2]);
+    controller->SetRingColor(red, grn, blu);
+}
+
+void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
+{
+    RGBColor      color = colors[zone];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
+
+    if(zone == 0)
     {
-        unsigned char   led_ids[15];
-        RGBColor        color_buf[15];
-        unsigned int    leds_count = 0;
-
-        for(unsigned int led_idx = 0; led_idx < colors.size(); led_idx++)
-        {
-            led_ids[leds_count]     = (unsigned char)leds[led_idx].value;
-            color_buf[leds_count]   = colors[led_idx];
-
-            leds_count++;
-
-            if(leds_count >= 15)
-            {
-                controller->SendDirectPacket(15, led_ids, color_buf);
-                leds_count = 0;
-            }
-        }
-
-        if(leds_count > 0)
-        {
-            controller->SendDirectPacket(leds_count, led_ids, color_buf);
-        }
-    }
-    else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        unsigned char red = RGBGetRValue(modes[active_mode].colors[0]);
-        unsigned char grn = RGBGetGValue(modes[active_mode].colors[0]);
-        unsigned char blu = RGBGetBValue(modes[active_mode].colors[0]);
         controller->SetLogoColor(red, grn, blu);
-
-        red = RGBGetRValue(modes[active_mode].colors[1]);
-        grn = RGBGetGValue(modes[active_mode].colors[1]);
-        blu = RGBGetBValue(modes[active_mode].colors[1]);
+    }
+    else if(zone == 1)
+    {
         controller->SetFanColor(red, grn, blu);
-
-        red = RGBGetRValue(modes[active_mode].colors[2]);
-        grn = RGBGetGValue(modes[active_mode].colors[2]);
-        blu = RGBGetBValue(modes[active_mode].colors[2]);
+    }
+    else if(zone == 2)
+    {
         controller->SetRingColor(red, grn, blu);
     }
-    else
-    {
-        controller->SetLogoColor(0, 0, 0);
-        controller->SetFanColor(0, 0, 0);
-        controller->SetRingColor(0, 0, 0);
-    }
 }
 
-void RGBController_AMDWraithPrism::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AMDWraithPrism::UpdateSingleLED(int led)
 {
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AMDWraithPrism::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
+    UpdateZoneLEDs(led);
 }
 
 void RGBController_AMDWraithPrism::DeviceUpdateMode()
 {
     bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
 
+    controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
+
     switch(modes[active_mode].value)
     {
-        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT:
-            controller->SendEnableCommand(true);
-            controller->SendApplyCommand();
-            break;
-
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE:
-            controller->SendEnableCommand(false);
-            controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
             controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
             controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
             break;
 
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW:
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE:
-            controller->SendEnableCommand(false);
-            controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
             controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
             controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
             break;
 
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
-            controller->SendEnableCommand(false);
-            controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
             controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
             controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
             break;
@@ -308,15 +263,11 @@ void RGBController_AMDWraithPrism::DeviceUpdateMode()
         default:
             if(random)
             {
-                controller->SendEnableCommand(false);
-                controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
                 controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
                 controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
             }
             else
             {
-                controller->SendEnableCommand(false);
-                controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
                 controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
                 controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
             }

Controllers/AOCKeyboardController/AOCKeyboardController.cpp

@@ -1,211 +0,0 @@
-/*-----------------------------------------*\
-|  AOCKeyboardController.cpp                |
-|                                           |
-|  Driver for AOC Keyboard lighting         |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/10/2023   |
-\*-----------------------------------------*/
-
-#include "AOCKeyboardController.h"
-
-#include <cstring>
-#include <chrono>
-#include <thread>
-
-using namespace std::chrono_literals;
-
-AOCKeyboardController::AOCKeyboardController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-AOCKeyboardController::~AOCKeyboardController()
-{
-    hid_close(dev);
-}
-
-std::string AOCKeyboardController::GetDeviceLocation()
-{
-    return("HID " + location);
-}
-
-std::string AOCKeyboardController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-void AOCKeyboardController::SetLightingConfig
-    (
-    unsigned char   mode,
-    unsigned char   random,
-    unsigned char   brightness,
-    unsigned char   speed,
-    unsigned char   direction,
-    RGBColor*       color_data
-    )
-{
-    SendStartPacket();
-    std::this_thread::sleep_for(5ms);
-
-    SendLightingConfigPacket(mode, random, brightness, speed, direction, color_data);
-    std::this_thread::sleep_for(5ms);
-
-    SendEndPacket();
-    std::this_thread::sleep_for(10ms);
-}
-
-void AOCKeyboardController::SetCustom
-    (
-    RGBColor*       color_data
-    )
-{
-    SendStartPacket();
-    std::this_thread::sleep_for(5ms);
-
-    SendCustomPacket(color_data);
-    std::this_thread::sleep_for(5ms);
-
-    SendEndPacket();
-    std::this_thread::sleep_for(5ms);
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void AOCKeyboardController::SendStartPacket()
-{
-    unsigned char buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up start packet                                   |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x09;
-    buf[0x01]   = 0x21;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, buf, sizeof(buf));
-}
-
-void AOCKeyboardController::SendEndPacket()
-{
-    unsigned char buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up end packet                                     |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x09;
-    buf[0x01]   = 0x22;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, buf, sizeof(buf));
-}
-
-void AOCKeyboardController::SendCustomPacket
-    (
-    RGBColor*       color_data
-    )
-{
-    unsigned char buf[361];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up custom lighting packet                         |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x20;
-
-    /*-----------------------------------------------------*\
-    | Copy in color data                                    |
-    \*-----------------------------------------------------*/
-    for(unsigned int color_idx = 0; color_idx < 120; color_idx++)
-    {
-        buf[color_idx + 1]      = RGBGetRValue(color_data[color_idx]);
-        buf[color_idx + 121]    = RGBGetGValue(color_data[color_idx]);
-        buf[color_idx + 241]    = RGBGetBValue(color_data[color_idx]);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, sizeof(buf));
-}
-
-void AOCKeyboardController::SendLightingConfigPacket
-    (
-    unsigned char   mode,
-    unsigned char   random,
-    unsigned char   brightness,
-    unsigned char   speed,
-    unsigned char   direction,
-    RGBColor*       color_data
-    )
-{
-    unsigned char buf[117];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up lighting configuration packet                  |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x14;
-    buf[0x01]   = 0x01;
-
-    buf[0x06]   = mode;
-
-    buf[0x07 + (9 * mode) + 0] = RGBGetRValue(color_data[0]);
-    buf[0x07 + (9 * mode) + 1] = RGBGetGValue(color_data[0]);
-    buf[0x07 + (9 * mode) + 2] = RGBGetBValue(color_data[0]);
-    buf[0x07 + (9 * mode) + 3] = random;
-    buf[0x07 + (9 * mode) + 4] = direction;
-    buf[0x07 + (9 * mode) + 5] = speed;
-    buf[0x07 + (9 * mode) + 6] = brightness;
-
-    unsigned short checksum = 0x4A9E;
-
-    for(unsigned int buf_idx = 0; buf_idx < 115; buf_idx++)
-    {
-        checksum += buf[buf_idx];
-    }
-
-    buf[115]    = checksum & 0xFF;
-    buf[116]    = checksum >> 8;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 117);
-}

Controllers/AOCKeyboardController/AOCKeyboardController.h

@@ -1,107 +0,0 @@
-/*-----------------------------------------*\
-|  AOCKeyboardController.h                  |
-|                                           |
-|  Definitions and types for AOC keyboard   |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/10/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-#include <string>
-
-#pragma once
-
-/*-----------------------------------------*\
-| AOC Keyboard Modes                        |
-\*-----------------------------------------*/
-enum
-{
-    AOC_KEYBOARD_MODE_STATIC                    = 0x00,     /* Static mode                  */
-    AOC_KEYBOARD_MODE_BREATHING                 = 0x01,     /* Breathing mode               */
-    AOC_KEYBOARD_MODE_REACT                     = 0x02,     /* React mode                   */
-    AOC_KEYBOARD_MODE_RIPPLE                    = 0x04,     /* Ripple mode                  */
-    AOC_KEYBOARD_MODE_RADAR                     = 0x05,     /* Radar mode                   */
-    AOC_KEYBOARD_MODE_FIREWORKS                 = 0x06,     /* Fireworks mode               */
-    AOC_KEYBOARD_MODE_BLINK                     = 0x07,     /* Blink mode                   */
-    AOC_KEYBOARD_MODE_WAVE                      = 0x08,     /* Wave mode                    */
-    AOC_KEYBOARD_MODE_CUSTOM                    = 0x09,     /* Custom mode                  */
-    AOC_KEYBOARD_MODE_CONCENTRIC_CIRCLES        = 0x0A,     /* Concentric Circles mode      */
-    AOC_KEYBOARD_MODE_W_WAVE                    = 0x0B,     /* W Wave mode                  */
-};
-
-enum
-{
-    AOC_KEYBOARD_SPEED_SLOW                     = 0x03,     /* Slowest speed                */
-    AOC_KEYBOARD_SPEED_MEDIUM                   = 0x02,     /* Medium speed                 */
-    AOC_KEYBOARD_SPEED_FAST                     = 0x01,     /* Fastest speed                */
-};
-
-enum
-{
-    AOC_KEYBOARD_BRIGHTNESS_OFF                 = 0x00,     /* Lowest brightness (off)      */
-    AOC_KEYBOARD_BRIGHTNESS_LOW                 = 0x01,     /* Low brightness               */
-    AOC_KEYBOARD_BRIGHTNESS_MEDIUM              = 0x02,     /* Medium brightness            */
-    AOC_KEYBOARD_BRIGHTNESS_HIGH                = 0x03,     /* Highest brightness           */
-};
-
-enum
-{
-    AOC_KEYBOARD_SINGLE_COLOR                   = 0x00,     /* Single color mode            */
-    AOC_KEYBOARD_RANDOM                         = 0x01,     /* Random color mode            */
-};
-
-enum
-{
-    AOC_KEYBOARD_DIRECTION_CLOCKWISE            = 0x00,     /* Clockwise direction          */
-    AOC_KEYBOARD_DIRECTION_COUNTERCLOCKWISE     = 0x01,     /* Counter-clockwise direction  */
-};
-
-
-class AOCKeyboardController
-{
-public:
-    AOCKeyboardController(hid_device* dev_handle, const char* path);
-    ~AOCKeyboardController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void SetLightingConfig
-            (
-            unsigned char   mode,
-            unsigned char   random,
-            unsigned char   brightness,
-            unsigned char   speed,
-            unsigned char   direction,
-            RGBColor*       color_data
-            );
-
-    void SetCustom
-            (
-            RGBColor*       color_data
-            );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-
-    void SendStartPacket();
-    void SendEndPacket();
-
-    void SendCustomPacket
-            (
-            RGBColor*       color_data
-            );
-
-    void SendLightingConfigPacket
-            (
-            unsigned char   mode,
-            unsigned char   random,
-            unsigned char   brightness,
-            unsigned char   speed,
-            unsigned char   direction,
-            RGBColor*       color_data
-            );
-};

Controllers/AOCKeyboardController/AOCKeyboardControllerDetect.cpp

@@ -1,34 +0,0 @@
-#include "Detector.h"
-#include "AOCKeyboardController.h"
-#include "RGBController.h"
-#include "RGBController_AOCKeyboard.h"
-
-/*-----------------------------------------------------*\
-| AOC Mousemat IDs                                      |
-\*-----------------------------------------------------*/
-#define AOC_VID                                     0x3938
-#define AOC_GK500_PID                               0x1178
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCKeyboardControllers                                                           *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Keyboard controller exists there.           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AOCKeyboardController*     controller     = new AOCKeyboardController(dev, info->path);
-        RGBController_AOCKeyboard* rgb_controller = new RGBController_AOCKeyboard(controller);
-        rgb_controller->name                      = name;
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID,   0xFF19, 0xFF19);

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp

@@ -1,370 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AOCKeyboard.cpp            |
-|                                           |
-|  Generic RGB Interface for AOC keyboard   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/10/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController_AOCKeyboard.h"
-#include "KeyboardLayoutManager.h"
-
-/**--------------------------------------------------------------------*\
-    @name AOC Keyboard
-    @category Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAOCKeyboardControllers
-    @comment
-\*---------------------------------------------------------------------*/
-
-/*---------------------------------------------------------------------*\
-|  AOC Keyboard KLM Layout                                              |
-\*---------------------------------------------------------------------*/
-layout_values aoc_keyboard_offset_values =
-{
-    {
-        /* ESC          F1    F2    F3    F4    F5    F6    F7    F8    F9   F10   F11   F12   PRSC  SCLK  PSBK                         */
-            90,         92,   77,   63,   79,   94,   81,   96,   82,   83,   98,   40,   55,   85,  100,  104,
-        /* BKTK    1     2     3     4     5     6     7     8     9     0     -     =   BSPC  INS   HOME  PGUP  NLCK   NP/   NP*  NP-  */
-            75,   76,   91,   62,   48,   64,   50,   65,   66,   67,   97,   68,   84,   70,   59,   74,   89,    58,   73,   88,  103,
-        /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   DEL   END   PGDN   NP7   NP8   NP9   NP+ */
-            60,   61,   47,   78,   33,   49,   35,   80,   51,   52,   53,   69,   99,   25,   44,   29,   14,    43,   28,   13,  102,
-        /* CPLK    A     S     D     F     G     H     J     K     L     ;     "   ENTR                           NP4   NP5   NP6       */
-            45,   46,   32,   93,   18,   34,   20,   95,   36,   37,   38,   54,   10,                            57,   72,   87,
-        /* LSFT    Z     X     C     V     B     N     M     ,     .     /   RSFT                   ARWU          NP1   NP2   NP3  NPEN */
-            30,   31,   17,    2,    3,   19,    5,    6,   21,   22,   23,   39,                     11,          42,   27,   12,  101,
-        /* LCTL  LWIN  LALT               SPC              RALT  RFNC  RMNU  RCTL              ARWL ARWD   ARWR   NP0         NP.       */
-            15,    0,    1,                4,                7,    8,   24,    9,               26,   41,   56,    71,         86
-    },
-    {
-        /* Add more regional layout fixes here */
-    }
-};
-
-
-RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "AOC Keyboard Device";
-    vendor      = "AOC";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "AOC Keyboard Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Static;
-    Static.name                     = "Static";
-    Static.value                    = AOC_KEYBOARD_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Static.brightness_min           = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Static.brightness_max           = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Static.brightness               = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Static.colors_min               = 1;
-    Static.colors_max               = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name              = "Spectrum Cycle";
-    SpectrumCycle.value             = AOC_KEYBOARD_MODE_STATIC;
-    SpectrumCycle.flags             = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    SpectrumCycle.color_mode        = MODE_COLORS_RANDOM;
-    SpectrumCycle.brightness_min    = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    SpectrumCycle.brightness_max    = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    SpectrumCycle.brightness        = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    SpectrumCycle.speed_min         = AOC_KEYBOARD_SPEED_SLOW;
-    SpectrumCycle.speed_max         = AOC_KEYBOARD_SPEED_FAST;
-    SpectrumCycle.speed             = AOC_KEYBOARD_SPEED_MEDIUM;
-    modes.push_back(SpectrumCycle);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = AOC_KEYBOARD_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.brightness_min        = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Breathing.brightness_max        = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Breathing.brightness            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Breathing.speed_min             = AOC_KEYBOARD_SPEED_SLOW;
-    Breathing.speed_max             = AOC_KEYBOARD_SPEED_FAST;
-    Breathing.speed                 = AOC_KEYBOARD_SPEED_MEDIUM;
-    Breathing.colors_min            = 1;
-    Breathing.colors_max            = 1;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
-
-    mode React;
-    React.name                      = "React";
-    React.value                     = AOC_KEYBOARD_MODE_REACT;
-    React.flags                     = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    React.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    React.brightness_min            = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    React.brightness_max            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    React.brightness                = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    React.speed_min                 = AOC_KEYBOARD_SPEED_SLOW;
-    React.speed_max                 = AOC_KEYBOARD_SPEED_FAST;
-    React.speed                     = AOC_KEYBOARD_SPEED_MEDIUM;
-    React.colors_min                = 1;
-    React.colors_max                = 1;
-    React.colors.resize(1);
-    modes.push_back(React);
-
-    mode Ripple;
-    Ripple.name                     = "Ripple";
-    Ripple.value                    = AOC_KEYBOARD_MODE_RIPPLE;
-    Ripple.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Ripple.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Ripple.brightness_min           = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Ripple.brightness_max           = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Ripple.brightness               = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Ripple.speed_min                = AOC_KEYBOARD_SPEED_SLOW;
-    Ripple.speed_max                = AOC_KEYBOARD_SPEED_FAST;
-    Ripple.speed                    = AOC_KEYBOARD_SPEED_MEDIUM;
-    Ripple.colors_min               = 1;
-    Ripple.colors_max               = 1;
-    Ripple.colors.resize(1);
-    modes.push_back(Ripple);
-
-    mode Radar;
-    Radar.name                      = "Radar";
-    Radar.value                     = AOC_KEYBOARD_MODE_RADAR;
-    Radar.flags                     = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Radar.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    Radar.brightness_min            = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Radar.brightness_max            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Radar.brightness                = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Radar.speed_min                 = AOC_KEYBOARD_SPEED_SLOW;
-    Radar.speed_max                 = AOC_KEYBOARD_SPEED_FAST;
-    Radar.speed                     = AOC_KEYBOARD_SPEED_MEDIUM;
-    Radar.colors_min                = 1;
-    Radar.colors_max                = 1;
-    Radar.colors.resize(1);
-    modes.push_back(Radar);
-
-    mode Fireworks;
-    Fireworks.name                  = "Fireworks";
-    Fireworks.value                 = AOC_KEYBOARD_MODE_FIREWORKS;
-    Fireworks.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Fireworks.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Fireworks.brightness_min        = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Fireworks.brightness_max        = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Fireworks.brightness            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Fireworks.speed_min             = AOC_KEYBOARD_SPEED_SLOW;
-    Fireworks.speed_max             = AOC_KEYBOARD_SPEED_FAST;
-    Fireworks.speed                 = AOC_KEYBOARD_SPEED_MEDIUM;
-    Fireworks.colors_min            = 1;
-    Fireworks.colors_max            = 1;
-    Fireworks.colors.resize(1);
-    modes.push_back(Fireworks);
-
-    mode Blink;
-    Blink.name                      = "Flashing";
-    Blink.value                     = AOC_KEYBOARD_MODE_BLINK;
-    Blink.flags                     = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Blink.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    Blink.brightness_min            = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Blink.brightness_max            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Blink.brightness                = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Blink.speed_min                 = AOC_KEYBOARD_SPEED_SLOW;
-    Blink.speed_max                 = AOC_KEYBOARD_SPEED_FAST;
-    Blink.speed                     = AOC_KEYBOARD_SPEED_MEDIUM;
-    Blink.colors_min                = 1;
-    Blink.colors_max                = 1;
-    Blink.colors.resize(1);
-    modes.push_back(Blink);
-
-    mode Wave;
-    Wave.name                       = "Wave";
-    Wave.value                      = AOC_KEYBOARD_MODE_WAVE;
-    Wave.flags                      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Wave.color_mode                 = MODE_COLORS_MODE_SPECIFIC;
-    Wave.brightness_min             = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Wave.brightness_max             = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Wave.brightness                 = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Wave.speed_min                  = AOC_KEYBOARD_SPEED_SLOW;
-    Wave.speed_max                  = AOC_KEYBOARD_SPEED_FAST;
-    Wave.speed                      = AOC_KEYBOARD_SPEED_MEDIUM;
-    Wave.colors_min                 = 1;
-    Wave.colors_max                 = 1;
-    Wave.colors.resize(1);
-    modes.push_back(Wave);
-
-    mode RainbowWave;
-    RainbowWave.name                = "Rainbow Wave";
-    RainbowWave.value               = AOC_KEYBOARD_MODE_WAVE;
-    RainbowWave.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    RainbowWave.color_mode          = MODE_COLORS_RANDOM;
-    RainbowWave.brightness_min      = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    RainbowWave.brightness_max      = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    RainbowWave.brightness          = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    RainbowWave.speed_min           = AOC_KEYBOARD_SPEED_SLOW;
-    RainbowWave.speed_max           = AOC_KEYBOARD_SPEED_FAST;
-    RainbowWave.speed               = AOC_KEYBOARD_SPEED_MEDIUM;
-    modes.push_back(RainbowWave);
-
-    mode ConcentricCircles;
-    ConcentricCircles.name          = "Concentric Circles";
-    ConcentricCircles.value         = AOC_KEYBOARD_MODE_CONCENTRIC_CIRCLES;
-    ConcentricCircles.flags         = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    ConcentricCircles.color_mode    = MODE_COLORS_MODE_SPECIFIC;
-    ConcentricCircles.brightness_min= AOC_KEYBOARD_BRIGHTNESS_OFF;
-    ConcentricCircles.brightness_max= AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    ConcentricCircles.brightness    = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    ConcentricCircles.speed_min     = AOC_KEYBOARD_SPEED_SLOW;
-    ConcentricCircles.speed_max     = AOC_KEYBOARD_SPEED_FAST;
-    ConcentricCircles.speed         = AOC_KEYBOARD_SPEED_MEDIUM;
-    ConcentricCircles.colors_min    = 1;
-    ConcentricCircles.colors_max    = 1;
-    ConcentricCircles.colors.resize(1);
-    modes.push_back(ConcentricCircles);
-
-    mode WWave;
-    WWave.name                      = "W Wave";
-    WWave.value                     = AOC_KEYBOARD_MODE_W_WAVE;
-    WWave.flags                     = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    WWave.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    WWave.brightness_min            = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    WWave.brightness_max            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    WWave.brightness                = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    WWave.speed_min                 = AOC_KEYBOARD_SPEED_SLOW;
-    WWave.speed_max                 = AOC_KEYBOARD_SPEED_FAST;
-    WWave.speed                     = AOC_KEYBOARD_SPEED_MEDIUM;
-    WWave.colors_min                = 1;
-    WWave.colors_max                = 1;
-    WWave.colors.resize(1);
-    modes.push_back(WWave);
-
-    mode Direct;
-    Direct.name                     = "Direct";
-    Direct.value                    = AOC_KEYBOARD_MODE_CUSTOM;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.color_mode               = MODE_COLORS_PER_LED;
-    Direct.brightness_min           = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Direct.brightness_max           = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Direct.brightness               = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    modes.push_back(Direct);
-
-    SetupZones();
-};
-
-RGBController_AOCKeyboard::~RGBController_AOCKeyboard()
-{
-    delete controller;
-}
-
-void RGBController_AOCKeyboard::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Create the keyboard zone usiung Keyboard Layout Manager   |
-    \*---------------------------------------------------------*/
-    zone new_zone;
-    new_zone.name               = ZONE_EN_KEYBOARD;
-    new_zone.type               = ZONE_TYPE_MATRIX;
-
-    KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ANSI_QWERTY, KEYBOARD_SIZE_FULL, aoc_keyboard_offset_values);
-
-    matrix_map_type * new_map   = new matrix_map_type;
-    new_zone.matrix_map         = new_map;
-    new_zone.matrix_map->height = new_kb.GetRowCount();
-    new_zone.matrix_map->width  = new_kb.GetColumnCount();
-
-    new_zone.matrix_map->map    = new unsigned int[new_map->height * new_map->width];
-    new_zone.leds_count         = new_kb.GetKeyCount();
-    new_zone.leds_min           = new_zone.leds_count;
-    new_zone.leds_max           = new_zone.leds_count;
-
-    /*---------------------------------------------------------*\
-    | Matrix map still uses declared zone rows and columns      |
-    |   as the packet structure depends on the matrix map       |
-    \*---------------------------------------------------------*/
-    new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
-
-    /*---------------------------------------------------------*\
-    | Create LEDs for the Matrix zone                           |
-    |   Place keys in the layout to populate the matrix         |
-    \*---------------------------------------------------------*/
-    for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
-    {
-        led new_led;
-
-        new_led.name                = new_kb.GetKeyNameAt(led_idx);
-        new_led.value               = new_kb.GetKeyValueAt(led_idx);
-        leds.push_back(new_led);
-    }
-
-    zones.push_back(new_zone);
-
-
-
-    SetupColors();
-}
-
-void RGBController_AOCKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AOCKeyboard::DeviceUpdateLEDs()
-{
-    if(modes[active_mode].value == AOC_KEYBOARD_MODE_CUSTOM)
-    {
-        RGBColor color_buf[120];
-
-        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-        {
-            color_buf[leds[led_idx].value] = colors[led_idx];
-        }
-
-        controller->SetCustom(&color_buf[0]);
-    }
-    else
-    {
-        DeviceUpdateMode();
-    }
-}
-
-void RGBController_AOCKeyboard::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AOCKeyboard::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AOCKeyboard::DeviceUpdateMode()
-{
-    unsigned char   aoc_direction   = AOC_KEYBOARD_DIRECTION_CLOCKWISE;
-    unsigned char   aoc_random      = AOC_KEYBOARD_SINGLE_COLOR;
-    RGBColor*       aoc_colors      = &colors[0];
-
-    if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
-    {
-        aoc_direction = AOC_KEYBOARD_DIRECTION_COUNTERCLOCKWISE;
-    }
-
-    if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
-    {
-        aoc_random = AOC_KEYBOARD_RANDOM;
-    }
-
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        aoc_colors = &modes[active_mode].colors[0];
-    }
-
-    controller->SetLightingConfig(modes[active_mode].value,
-                                  aoc_random,
-                                  modes[active_mode].brightness,
-                                  modes[active_mode].speed,
-                                  aoc_direction,
-                                  aoc_colors);
-}

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.h

@@ -1,32 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AOCKeyboard.h              |
-|                                           |
-|  Generic RGB Interface for AOC keyboard   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/10/2023   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AOCKeyboardController.h"
-
-class RGBController_AOCKeyboard : public RGBController
-{
-public:
-    RGBController_AOCKeyboard(AOCKeyboardController* controller_ptr);
-    ~RGBController_AOCKeyboard();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AOCKeyboardController*  controller;
-};

Controllers/AOCMouseController/AOCMouseController.cpp

@@ -1,130 +0,0 @@
-/*-----------------------------------------*\
-|  AOCMouseController.cpp                   |
-|                                           |
-|  Driver for AOC Mouse lighting controller |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/20/2023   |
-\*-----------------------------------------*/
-
-#include "AOCMouseController.h"
-
-#include <cstring>
-
-AOCMouseController::AOCMouseController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-AOCMouseController::~AOCMouseController()
-{
-    hid_close(dev);
-}
-
-std::string AOCMouseController::GetDeviceLocation()
-{
-    return("HID " + location);
-}
-
-std::string AOCMouseController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void AOCMouseController::SendDirect
-    (
-    RGBColor*       color_data
-    )
-{
-    SendPacket(AOC_MOUSE_MODE_STATIC_SINGLE_COLOR,
-               AOC_MOUSE_BRIGHTNESS_HIGH,
-               AOC_MOUSE_SPEED_MEDIUM,
-               AOC_MOUSE_DIRECTION_CLOCKWISE,
-               color_data);
-}
-
-void AOCMouseController::SendPacket
-    (
-    unsigned char   mode,
-    unsigned char   brightness,
-    unsigned char   speed,
-    unsigned char   direction,
-    RGBColor*       color_data
-    )
-{
-    unsigned char buf[60];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up packet                                         |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x20;
-    buf[0x01]   = 0x03;
-    buf[0x02]   = 0x01;
-    buf[0x03]   = mode;
-    buf[0x04]   = speed;
-    buf[0x05]   = brightness;
-    buf[0x06]   = direction;
-    buf[0x07]   = 0x01;
-    buf[0x08]   = 0x02;
-    buf[0x09]   = 0xFF;
-    buf[0x0D]   = 0x01;
-    buf[0x0E]   = 0x03;
-    buf[0x0F]   = 0xFF;
-    buf[0x10]   = 0x7F;
-    buf[0x13]   = 0x01;
-    buf[0x14]   = 0x04;
-    buf[0x17]   = 0xFF;
-    buf[0x19]   = 0x01;
-    buf[0x1A]   = 0x05;
-    buf[0x1C]   = 0xFF;
-    buf[0x1F]   = 0x01;
-    buf[0x20]   = 0x06;
-    buf[0x21]   = 0xFF;
-    buf[0x23]   = 0xFF;
-    buf[0x25]   = 0x01;
-    buf[0x26]   = 0x07;
-    buf[0x27]   = 0xFF;
-    buf[0x28]   = 0xFF;
-    buf[0x2C]   = 0x0A;
-    buf[0x2D]   = 0x0A;
-    buf[0x30]   = 0x14;
-    buf[0x31]   = 0x08;
-    buf[0x3A]   = 0x32;
-    buf[0x3B]   = 0x32;
-
-    /*-----------------------------------------------------*\
-    | Copy in color                                         |
-    \*-----------------------------------------------------*/
-    buf[0x33]   = RGBGetRValue(color_data[0]);
-    buf[0x34]   = RGBGetGValue(color_data[0]);
-    buf[0x35]   = RGBGetBValue(color_data[0]);
-
-    buf[0x36]   = RGBGetRValue(color_data[1]);
-    buf[0x37]   = RGBGetGValue(color_data[1]);
-    buf[0x38]   = RGBGetBValue(color_data[1]);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 60);
-}

Controllers/AOCMouseController/AOCMouseController.h

@@ -1,80 +0,0 @@
-/*-----------------------------------------*\
-|  AOCMouseController.h                     |
-|                                           |
-|  Definitions and types for AOC mouse      |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/20/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-#include <string>
-
-#pragma once
-
-/*-----------------------------------------*\
-| AOC Mousemat Modes                        |
-|   Note: The 0x80 bit is the random flag   |
-\*-----------------------------------------*/
-enum
-{
-    AOC_MOUSE_MODE_STATIC_SINGLE_COLOR          = 0x00,     /* Static single color mode     */
-    AOC_MOUSE_MODE_STATIC_RANDOM                = 0x80,     /* Static random color mode     */
-    AOC_MOUSE_MODE_BREATHING_SINGLE_COLOR       = 0x01,     /* Breathing single color mode  */
-    AOC_MOUSE_MODE_BREATHING_RANDOM             = 0x81,     /* Breathing random color mode  */
-    AOC_MOUSE_MODE_BLINK_SINGLE_COLOR           = 0x02,     /* Blink single color mode      */
-    AOC_MOUSE_MODE_BLINK_RANDOM                 = 0x82,     /* Blink random color mode      */
-    AOC_MOUSE_MODE_WAVE_SINGLE_COLOR            = 0x03,     /* Wave single color mode       */
-    AOC_MOUSE_MODE_WAVE_RANDOM                  = 0x83,     /* Wave random color mode       */
-    AOC_MOUSE_MODE_DPI                          = 0x04,     /* DPI mode                     */
-};
-
-enum
-{
-    AOC_MOUSE_SPEED_SLOW                        = 0x03,     /* Slowest speed                */
-    AOC_MOUSE_SPEED_MEDIUM                      = 0x02,     /* Medium speed                 */
-    AOC_MOUSE_SPEED_FAST                        = 0x01,     /* Fastest speed                */
-};
-
-enum
-{
-    AOC_MOUSE_BRIGHTNESS_OFF                    = 0x00,     /* Lowest brightness (off)      */
-    AOC_MOUSE_BRIGHTNESS_LOW                    = 0x01,     /* Low brightness               */
-    AOC_MOUSE_BRIGHTNESS_MEDIUM                 = 0x02,     /* Medium brightness            */
-    AOC_MOUSE_BRIGHTNESS_HIGH                   = 0x03,     /* Highest brightness           */
-};
-
-enum
-{
-    AOC_MOUSE_DIRECTION_CLOCKWISE               = 0x00,     /* Clockwise direction          */
-    AOC_MOUSE_DIRECTION_COUNTERCLOCKWISE        = 0x01,     /* Counter-clockwise direction  */
-};
-
-class AOCMouseController
-{
-public:
-    AOCMouseController(hid_device* dev_handle, const char* path);
-    ~AOCMouseController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void SendDirect
-            (
-            RGBColor*       color_data
-            );
-
-    void SendPacket
-            (
-            unsigned char   mode,
-            unsigned char   brightness,
-            unsigned char   speed,
-            unsigned char   direction,
-            RGBColor*       color_data
-            );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-};

Controllers/AOCMouseController/AOCMouseControllerDetect.cpp

@@ -1,34 +0,0 @@
-#include "Detector.h"
-#include "AOCMouseController.h"
-#include "RGBController.h"
-#include "RGBController_AOCMouse.h"
-
-/*-----------------------------------------------------*\
-| AOC Mousemat IDs                                      |
-\*-----------------------------------------------------*/
-#define AOC_VID                                     0x3938
-#define AOC_GM500_PID                               0x1179
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCMouseControllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Mouse controller exists there.              *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AOCMouseController*     controller     = new AOCMouseController(dev, info->path);
-        RGBController_AOCMouse* rgb_controller = new RGBController_AOCMouse(controller);
-        rgb_controller->name                   = name;
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR_IPU("AOC GM500",  DetectAOCMouseControllers,  AOC_VID,    AOC_GM500_PID,  1,  0xFF19, 0xFF19);

Controllers/AOCMouseController/RGBController_AOCMouse.cpp

@@ -1,215 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AOCMouse.cpp               |
-|                                           |
-|  Generic RGB Interface for AOC mouse      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/20/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController_AOCMouse.h"
-
-/**------------------------------------------------------------------*\
-    @name AOC Mouse
-    @category Mouse
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAOCMouseControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "AOC Mouse Device";
-    vendor      = "AOC";
-    type        = DEVICE_TYPE_MOUSE;
-    description = "AOC Mouse Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name                     = "Direct";
-    Direct.value                    = AOC_MOUSE_MODE_STATIC_SINGLE_COLOR;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.color_mode               = MODE_COLORS_PER_LED;
-    Direct.brightness_min           = AOC_MOUSE_BRIGHTNESS_OFF;
-    Direct.brightness_max           = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Direct.brightness               = AOC_MOUSE_BRIGHTNESS_HIGH;
-    modes.push_back(Direct);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name              = "Spectrum Cycle";
-    SpectrumCycle.value             = AOC_MOUSE_MODE_STATIC_RANDOM;
-    SpectrumCycle.flags             = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    SpectrumCycle.color_mode        = MODE_COLORS_RANDOM;
-    SpectrumCycle.brightness_min    = AOC_MOUSE_BRIGHTNESS_OFF;
-    SpectrumCycle.brightness_max    = AOC_MOUSE_BRIGHTNESS_HIGH;
-    SpectrumCycle.brightness        = AOC_MOUSE_BRIGHTNESS_HIGH;
-    SpectrumCycle.speed_min         = AOC_MOUSE_SPEED_SLOW;
-    SpectrumCycle.speed_max         = AOC_MOUSE_SPEED_FAST;
-    SpectrumCycle.speed             = AOC_MOUSE_SPEED_MEDIUM;
-    modes.push_back(SpectrumCycle);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = AOC_MOUSE_MODE_BREATHING_SINGLE_COLOR;
-    Breathing.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode            = MODE_COLORS_PER_LED;
-    Breathing.brightness_min        = AOC_MOUSE_BRIGHTNESS_OFF;
-    Breathing.brightness_max        = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Breathing.brightness            = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Breathing.speed_min             = AOC_MOUSE_SPEED_SLOW;
-    Breathing.speed_max             = AOC_MOUSE_SPEED_FAST;
-    Breathing.speed                 = AOC_MOUSE_SPEED_MEDIUM;
-    modes.push_back(Breathing);
-
-    mode Blink;
-    Blink.name                      = "Flashing";
-    Blink.value                     = AOC_MOUSE_MODE_BLINK_SINGLE_COLOR;
-    Blink.flags                     = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Blink.color_mode                = MODE_COLORS_PER_LED;
-    Blink.brightness_min            = AOC_MOUSE_BRIGHTNESS_OFF;
-    Blink.brightness_max            = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Blink.brightness                = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Blink.speed_min                 = AOC_MOUSE_SPEED_SLOW;
-    Blink.speed_max                 = AOC_MOUSE_SPEED_FAST;
-    Blink.speed                     = AOC_MOUSE_SPEED_MEDIUM;
-    modes.push_back(Blink);
-
-    mode Wave;
-    Wave.name                       = "Wave";
-    Wave.value                      = AOC_MOUSE_MODE_WAVE_SINGLE_COLOR;
-    Wave.flags                      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Wave.color_mode                 = MODE_COLORS_PER_LED;
-    Wave.brightness_min             = AOC_MOUSE_BRIGHTNESS_OFF;
-    Wave.brightness_max             = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Wave.brightness                 = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Wave.speed_min                  = AOC_MOUSE_SPEED_SLOW;
-    Wave.speed_max                  = AOC_MOUSE_SPEED_FAST;
-    Wave.speed                      = AOC_MOUSE_SPEED_MEDIUM;
-    modes.push_back(Wave);
-
-    mode RainbowWave;
-    RainbowWave.name                = "Rainbow Wave";
-    RainbowWave.value               = AOC_MOUSE_MODE_WAVE_RANDOM;
-    RainbowWave.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    RainbowWave.color_mode          = MODE_COLORS_RANDOM;
-    RainbowWave.brightness_min      = AOC_MOUSE_BRIGHTNESS_OFF;
-    RainbowWave.brightness_max      = AOC_MOUSE_BRIGHTNESS_HIGH;
-    RainbowWave.brightness          = AOC_MOUSE_BRIGHTNESS_HIGH;
-    RainbowWave.speed_min           = AOC_MOUSE_SPEED_SLOW;
-    RainbowWave.speed_max           = AOC_MOUSE_SPEED_FAST;
-    RainbowWave.speed               = AOC_MOUSE_SPEED_MEDIUM;
-    modes.push_back(RainbowWave);
-
-    mode DPI;
-    DPI.name                        = "DPI";
-    DPI.value                       = AOC_MOUSE_MODE_DPI;
-    DPI.flags                       = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    DPI.color_mode                  = MODE_COLORS_RANDOM;
-    DPI.brightness_min              = AOC_MOUSE_BRIGHTNESS_OFF;
-    DPI.brightness_max              = AOC_MOUSE_BRIGHTNESS_HIGH;
-    DPI.brightness                  = AOC_MOUSE_BRIGHTNESS_HIGH;
-    modes.push_back(DPI);
-
-    SetupZones();
-};
-
-RGBController_AOCMouse::~RGBController_AOCMouse()
-{
-    delete controller;
-}
-
-void RGBController_AOCMouse::SetupZones()
-{
-    zone logo_zone;
-    logo_zone.name                  = "Logo";
-    logo_zone.type                  = ZONE_TYPE_SINGLE;
-    logo_zone.leds_min              = 1;
-    logo_zone.leds_max              = 1;
-    logo_zone.leds_count            = 1;
-    logo_zone.matrix_map            = NULL;
-    zones.push_back(logo_zone);
-
-    led logo_led;
-    logo_led.name                   = "Logo";
-    leds.push_back(logo_led);
-
-    zone scroll_wheel_zone;
-    scroll_wheel_zone.name          = "Scroll Wheel";
-    scroll_wheel_zone.type          = ZONE_TYPE_SINGLE;
-    scroll_wheel_zone.leds_min      = 1;
-    scroll_wheel_zone.leds_max      = 1;
-    scroll_wheel_zone.leds_count    = 1;
-    scroll_wheel_zone.matrix_map    = NULL;
-    zones.push_back(scroll_wheel_zone);
-
-    led scroll_wheel_led;
-    scroll_wheel_led.name           = "Scroll Wheel";
-    leds.push_back(scroll_wheel_led);
-
-    SetupColors();
-}
-
-void RGBController_AOCMouse::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AOCMouse::DeviceUpdateLEDs()
-{
-    DeviceUpdateMode();
-}
-
-void RGBController_AOCMouse::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AOCMouse::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AOCMouse::DeviceUpdateMode()
-{
-    if(modes[active_mode].value == AOC_MOUSE_MODE_STATIC_SINGLE_COLOR)
-    {
-        controller->SendDirect(&colors[0]);
-    }
-    else
-    {
-        unsigned char   aoc_direction   = AOC_MOUSE_DIRECTION_CLOCKWISE;
-        unsigned int    aoc_mode        = modes[active_mode].value;
-
-        if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
-        {
-            aoc_direction = AOC_MOUSE_DIRECTION_COUNTERCLOCKWISE;
-        }
-
-        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
-        {
-            switch(modes[active_mode].value)
-            {
-                case AOC_MOUSE_MODE_BREATHING_SINGLE_COLOR:
-                    aoc_mode = AOC_MOUSE_MODE_BREATHING_RANDOM;
-                    break;
-
-                case AOC_MOUSE_MODE_BLINK_SINGLE_COLOR:
-                    aoc_mode = AOC_MOUSE_MODE_BLINK_RANDOM;
-                    break;
-            }
-        }
-
-        controller->SendPacket(aoc_mode,
-                               modes[active_mode].brightness,
-                               modes[active_mode].speed,
-                               aoc_direction,
-                               &colors[0]);
-    }
-}

Controllers/AOCMouseController/RGBController_AOCMouse.h

@@ -1,32 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AOCMouse.h                 |
-|                                           |
-|  Generic RGB Interface for AOC mouse      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/20/2023   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AOCMouseController.h"
-
-class RGBController_AOCMouse : public RGBController
-{
-public:
-    RGBController_AOCMouse(AOCMouseController* controller_ptr);
-    ~RGBController_AOCMouse();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AOCMouseController*  controller;
-};

Controllers/AOCMousematController/AOCMousematController.cpp

@@ -1,112 +0,0 @@
-/*-----------------------------------------*\
-|  AOCMousematController.cpp                |
-|                                           |
-|  Driver for AOC Mousemat lighting         |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/15/2023   |
-\*-----------------------------------------*/
-
-#include "AOCMousematController.h"
-
-#include <cstring>
-
-AOCMousematController::AOCMousematController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-AOCMousematController::~AOCMousematController()
-{
-    hid_close(dev);
-}
-
-std::string AOCMousematController::GetDeviceLocation()
-{
-    return("HID " + location);
-}
-
-std::string AOCMousematController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void AOCMousematController::SendDirect
-    (
-    RGBColor*       color_data
-    )
-{
-    SendPacket(AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR,
-               AOC_MOUSEMAT_BRIGHTNESS_HIGH,
-               AOC_MOUSEMAT_SPEED_MEDIUM,
-               AOC_MOUSEMAT_DIRECTION_CLOCKWISE,
-               color_data);
-}
-
-void AOCMousematController::SendPacket
-    (
-    unsigned char   mode,
-    unsigned char   brightness,
-    unsigned char   speed,
-    unsigned char   direction,
-    RGBColor*       color_data
-    )
-{
-    unsigned char buf[32];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up packet                                         |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x20;
-    buf[0x01]   = brightness;
-    buf[0x02]   = speed;
-    buf[0x03]   = direction;
-    buf[0x04]   = 0x01;
-    buf[0x05]   = mode;
-    buf[0x09]   = 0xFF;
-    buf[0x0C]   = 0xFF;
-    buf[0x0D]   = 0x3F;
-    buf[0x0F]   = 0xFF;
-    buf[0x10]   = 0xFF;
-    buf[0x13]   = 0xFF;
-    buf[0x17]   = 0xFF;
-    buf[0x19]   = 0xFF;
-    buf[0x1A]   = 0xFF;
-    buf[0x1B]   = 0xFF;
-    buf[0x1D]   = 0xFF;
-    buf[0x1E]   = 0x32;
-    buf[0x1F]   = 0x32;
-
-    /*-----------------------------------------------------*\
-    | Copy in color                                         |
-    \*-----------------------------------------------------*/
-    buf[0x06]   = RGBGetRValue(color_data[0]);
-    buf[0x07]   = RGBGetGValue(color_data[0]);
-    buf[0x08]   = RGBGetBValue(color_data[0]);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 32);
-}

Controllers/AOCMousematController/AOCMousematController.h

@@ -1,79 +0,0 @@
-/*-----------------------------------------*\
-|  AOCMousematController.h                  |
-|                                           |
-|  Definitions and types for AOC mousemat   |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/15/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-#include <string>
-
-#pragma once
-
-/*-----------------------------------------*\
-| AOC Mousemat Modes                        |
-|   Note: The 0x80 bit is the random flag   |
-\*-----------------------------------------*/
-enum
-{
-    AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR       = 0x00,     /* Static single color mode     */
-    AOC_MOUSEMAT_MODE_STATIC_RANDOM             = 0x80,     /* Static random color mode     */
-    AOC_MOUSEMAT_MODE_BREATHING_SINGLE_COLOR    = 0x01,     /* Breathing single color mode  */
-    AOC_MOUSEMAT_MODE_BREATHING_RANDOM          = 0x81,     /* Breathing random color mode  */
-    AOC_MOUSEMAT_MODE_BLINK_SINGLE_COLOR        = 0x02,     /* Blink single color mode      */
-    AOC_MOUSEMAT_MODE_BLINK_RANDOM              = 0x82,     /* Blink random color mode      */
-    AOC_MOUSEMAT_MODE_WAVE_SINGLE_COLOR         = 0x03,     /* Wave single color mode       */
-    AOC_MOUSEMAT_MODE_WAVE_RANDOM               = 0x83,     /* Wave random color mode       */
-};
-
-enum
-{
-    AOC_MOUSEMAT_SPEED_SLOW                     = 0x03,     /* Slowest speed                */
-    AOC_MOUSEMAT_SPEED_MEDIUM                   = 0x02,     /* Medium speed                 */
-    AOC_MOUSEMAT_SPEED_FAST                     = 0x01,     /* Fastest speed                */
-};
-
-enum
-{
-    AOC_MOUSEMAT_BRIGHTNESS_OFF                 = 0x00,     /* Lowest brightness (off)      */
-    AOC_MOUSEMAT_BRIGHTNESS_LOW                 = 0x01,     /* Low brightness               */
-    AOC_MOUSEMAT_BRIGHTNESS_MEDIUM              = 0x02,     /* Medium brightness            */
-    AOC_MOUSEMAT_BRIGHTNESS_HIGH                = 0x03,     /* Highest brightness           */
-};
-
-enum
-{
-    AOC_MOUSEMAT_DIRECTION_CLOCKWISE            = 0x00,     /* Clockwise direction          */
-    AOC_MOUSEMAT_DIRECTION_COUNTERCLOCKWISE     = 0x01,     /* Counter-clockwise direction  */
-};
-
-class AOCMousematController
-{
-public:
-    AOCMousematController(hid_device* dev_handle, const char* path);
-    ~AOCMousematController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void SendDirect
-            (
-            RGBColor*       color_data
-            );
-
-    void SendPacket
-            (
-            unsigned char   mode,
-            unsigned char   brightness,
-            unsigned char   speed,
-            unsigned char   direction,
-            RGBColor*       color_data
-            );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-};

Controllers/AOCMousematController/AOCMousematControllerDetect.cpp

@@ -1,34 +0,0 @@
-#include "Detector.h"
-#include "AOCMousematController.h"
-#include "RGBController.h"
-#include "RGBController_AOCMousemat.h"
-
-/*-----------------------------------------------------*\
-| AOC Mousemat IDs                                      |
-\*-----------------------------------------------------*/
-#define AOC_VID                                     0x3938
-#define AOC_AMM700_PID                              0x1162
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCMousematControllers                                                           *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Mousemat controller exists there.           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCMousematControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AOCMousematController*     controller     = new AOCMousematController(dev, info->path);
-        RGBController_AOCMousemat* rgb_controller = new RGBController_AOCMousemat(controller);
-        rgb_controller->name                      = name;
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR_IPU("AOC AGON AMM700",    DetectAOCMousematControllers,   AOC_VID,    AOC_AMM700_PID, 1,  0xFF19,  0xFF19);

Controllers/AOCMousematController/RGBController_AOCMousemat.cpp

@@ -1,192 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AOCMousemat.cpp            |
-|                                           |
-|  Generic RGB Interface for AOC mousemat   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/15/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController_AOCMousemat.h"
-
-/**------------------------------------------------------------------*\
-    @name AOC Mousemat
-    @category Mousemat
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAOCMousematControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "AOC Mousemat Device";
-    vendor      = "AOC";
-    type        = DEVICE_TYPE_MOUSEMAT;
-    description = "AOC Mousemat Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name                     = "Direct";
-    Direct.value                    = AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.color_mode               = MODE_COLORS_PER_LED;
-    Direct.brightness_min           = AOC_MOUSEMAT_BRIGHTNESS_OFF;
-    Direct.brightness_max           = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Direct.brightness               = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    modes.push_back(Direct);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name              = "Spectrum Cycle";
-    SpectrumCycle.value             = AOC_MOUSEMAT_MODE_STATIC_RANDOM;
-    SpectrumCycle.flags             = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    SpectrumCycle.color_mode        = MODE_COLORS_RANDOM;
-    SpectrumCycle.brightness_min    = AOC_MOUSEMAT_BRIGHTNESS_OFF;
-    SpectrumCycle.brightness_max    = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    SpectrumCycle.brightness        = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    SpectrumCycle.speed_min         = AOC_MOUSEMAT_SPEED_SLOW;
-    SpectrumCycle.speed_max         = AOC_MOUSEMAT_SPEED_FAST;
-    SpectrumCycle.speed             = AOC_MOUSEMAT_SPEED_MEDIUM;
-    modes.push_back(SpectrumCycle);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = AOC_MOUSEMAT_MODE_BREATHING_SINGLE_COLOR;
-    Breathing.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode            = MODE_COLORS_PER_LED;
-    Breathing.brightness_min        = AOC_MOUSEMAT_BRIGHTNESS_OFF;
-    Breathing.brightness_max        = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Breathing.brightness            = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Breathing.speed_min             = AOC_MOUSEMAT_SPEED_SLOW;
-    Breathing.speed_max             = AOC_MOUSEMAT_SPEED_FAST;
-    Breathing.speed                 = AOC_MOUSEMAT_SPEED_MEDIUM;
-    modes.push_back(Breathing);
-
-    mode Blink;
-    Blink.name                      = "Flashing";
-    Blink.value                     = AOC_MOUSEMAT_MODE_BLINK_SINGLE_COLOR;
-    Blink.flags                     = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Blink.color_mode                = MODE_COLORS_PER_LED;
-    Blink.brightness_min            = AOC_MOUSEMAT_BRIGHTNESS_OFF;
-    Blink.brightness_max            = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Blink.brightness                = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Blink.speed_min                 = AOC_MOUSEMAT_SPEED_SLOW;
-    Blink.speed_max                 = AOC_MOUSEMAT_SPEED_FAST;
-    Blink.speed                     = AOC_MOUSEMAT_SPEED_MEDIUM;
-    modes.push_back(Blink);
-
-    mode Wave;
-    Wave.name                       = "Wave";
-    Wave.value                      = AOC_MOUSEMAT_MODE_WAVE_SINGLE_COLOR;
-    Wave.flags                      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Wave.color_mode                 = MODE_COLORS_PER_LED;
-    Wave.brightness_min             = AOC_MOUSEMAT_BRIGHTNESS_OFF;
-    Wave.brightness_max             = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Wave.brightness                 = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Wave.speed_min                  = AOC_MOUSEMAT_SPEED_SLOW;
-    Wave.speed_max                  = AOC_MOUSEMAT_SPEED_FAST;
-    Wave.speed                      = AOC_MOUSEMAT_SPEED_MEDIUM;
-    modes.push_back(Wave);
-
-    mode RainbowWave;
-    RainbowWave.name                = "Rainbow Wave";
-    RainbowWave.value               = AOC_MOUSEMAT_MODE_WAVE_RANDOM;
-    RainbowWave.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    RainbowWave.color_mode          = MODE_COLORS_RANDOM;
-    RainbowWave.brightness_min      = AOC_MOUSEMAT_BRIGHTNESS_OFF;
-    RainbowWave.brightness_max      = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    RainbowWave.brightness          = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    RainbowWave.speed_min           = AOC_MOUSEMAT_SPEED_SLOW;
-    RainbowWave.speed_max           = AOC_MOUSEMAT_SPEED_FAST;
-    RainbowWave.speed               = AOC_MOUSEMAT_SPEED_MEDIUM;
-    modes.push_back(RainbowWave);
-
-    SetupZones();
-};
-
-RGBController_AOCMousemat::~RGBController_AOCMousemat()
-{
-    delete controller;
-}
-
-void RGBController_AOCMousemat::SetupZones()
-{
-    zone mousemat_zone;
-    mousemat_zone.name          = "Mousemat";
-    mousemat_zone.type          = ZONE_TYPE_SINGLE;
-    mousemat_zone.leds_min      = 1;
-    mousemat_zone.leds_max      = 1;
-    mousemat_zone.leds_count    = 1;
-    mousemat_zone.matrix_map    = NULL;
-    zones.push_back(mousemat_zone);
-
-    led mousemat_led;
-    mousemat_led.name           = "Mousemat";
-    leds.push_back(mousemat_led);
-
-    SetupColors();
-}
-
-void RGBController_AOCMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AOCMousemat::DeviceUpdateLEDs()
-{
-    DeviceUpdateMode();
-}
-
-void RGBController_AOCMousemat::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AOCMousemat::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AOCMousemat::DeviceUpdateMode()
-{
-    if(modes[active_mode].value == AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR)
-    {
-        controller->SendDirect(&colors[0]);
-    }
-    else
-    {
-        unsigned char   aoc_direction   = AOC_MOUSEMAT_DIRECTION_CLOCKWISE;
-        unsigned int    aoc_mode        = modes[active_mode].value;
-
-        if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
-        {
-            aoc_direction = AOC_MOUSEMAT_DIRECTION_COUNTERCLOCKWISE;
-        }
-
-        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
-        {
-            switch(modes[active_mode].value)
-            {
-                case AOC_MOUSEMAT_MODE_BREATHING_SINGLE_COLOR:
-                    aoc_mode = AOC_MOUSEMAT_MODE_BREATHING_RANDOM;
-                    break;
-
-                case AOC_MOUSEMAT_MODE_BLINK_SINGLE_COLOR:
-                    aoc_mode = AOC_MOUSEMAT_MODE_BLINK_RANDOM;
-                    break;
-            }
-        }
-
-        controller->SendPacket(aoc_mode,
-                               modes[active_mode].brightness,
-                               modes[active_mode].speed,
-                               aoc_direction,
-                               &colors[0]);
-    }
-}

Controllers/AOCMousematController/RGBController_AOCMousemat.h

@@ -1,32 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AOCMousemat.h              |
-|                                           |
-|  Generic RGB Interface for AOC mousemat   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/15/2023   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AOCMousematController.h"
-
-class RGBController_AOCMousemat : public RGBController
-{
-public:
-    RGBController_AOCMousemat(AOCMousematController* controller_ptr);
-    ~RGBController_AOCMousemat();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AOCMousematController*  controller;
-};

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -5,23 +5,18 @@
 |  lighting controller                      |
 |                                           |
 |  Ed Kambulow (dredvard) 12/20/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/
-#include <cstring>
-#include <stdio.h>
 
 #include "RGBController.h"
-#include "ResourceManager.h"
-#include "SettingsManager.h"
 #include "ASRockPolychromeUSBController.h"
+#include <cstring>
+#include <stdio.h>
 #include "dependencies/dmiinfo.h"
 
 #define POLYCHROME_USB_READ_ZONE_CONFIG 0x11
 #define POLYCHROME_USB_READ_HEADER      0x14
 #define POLYCHROME_USB_WRITE_HEADER     0x15
 #define POLYCHROME_USB_SET_ZONE         0x10
-#define POLYCHROME_USB_INITIAL_CHUNK    0xE3
-#define POLYCHROME_USB_SEND_CHUNK       0xE4
 #define POLYCHROME_USB_INIT             0xA4
 #define POLYCHROME_USB_COMMIT           0x12
 
@@ -34,7 +29,7 @@ const char* polychrome_USB_zone_names[] =
     "PCH",
     "IO Cover",
     "PCB",
-    "Addressable Header 3/Audio",
+    "Audio",
 };
 
 PolychromeUSBController::PolychromeUSBController(hid_device* dev_handle, const char* path)
@@ -77,7 +72,7 @@ std::string PolychromeUSBController::GetSerialString()
     {
         return("");
     }
-
+    
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());
 
@@ -87,64 +82,19 @@ std::string PolychromeUSBController::GetSerialString()
 void PolychromeUSBController::SetDeviceInfo()
 {
     PolychromeDeviceInfo newdev_info;
-
     ReadConfigTables();
 
-    /*--------------------------------------------------*\
-    | Read settings to check for configured RGSwap       |
-    \*--------------------------------------------------*/
-    const std::string detector_name     = "ASRock Polychrome USB";
-    const std::string json_rgswap       = "RGSwap";
-    SettingsManager* settings_manager   = ResourceManager::get()->GetSettingsManager();
-    json device_settings                = settings_manager->GetSettings(detector_name);
-
-    /*---------------------------------------------------------*\
-    | Get RGSwap settings from the settings manager             |
-    | If RGSwap settings are not found then write them out      |
-    | Onboard leds are set to their existing values,            |
-    | Addressable RGB and RGB headers are set to false          |
-    \*---------------------------------------------------------*/
-    if(!device_settings.contains(json_rgswap))
-    {
-        device_settings[json_rgswap][polychrome_USB_zone_names[0]] = false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[1]] = false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[2]] = false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[3]] = false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[4]] = ((configtable[8] >> 4) & 1) ? true : false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[5]] = ((configtable[8] >> 5) & 1) ? true : false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[6]] = ((configtable[8] >> 6) & 1) ? true : false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[7]] = false;
-
-        settings_manager->SetSettings(detector_name, device_settings);
-        settings_manager->SaveSettings();
-    }
-    else
-    {
-        for(std::size_t idx = 0; idx < 8; idx++)
-        {
-            if(device_settings[json_rgswap].contains(polychrome_USB_zone_names[idx]))
-            {
-                rgswapconfig[idx] = device_settings[json_rgswap][polychrome_USB_zone_names[idx]];
-            }
-        }
-    }
-
-    bool rgswap_final[8] = {0};
-
     for (unsigned int zonecnt = 0; zonecnt < POLYCHROME_USB_ZONE_MAX_NUM; zonecnt++)
     {
-        if(configtable[zonecnt] == 0x1E || !((configtable[9] >> zonecnt) & 1))
+        if(configtable[zonecnt] == 0x1E)
         {
 			/*-----------------------------------------------------------------------*\
 			| If we don't have this device type (0x1E) we will skip it and continue.  |
-            | Or if the device is not available we skip it and continue               |
 			\*-----------------------------------------------------------------------*/
             continue;
         }
 
         newdev_info.num_leds = configtable[zonecnt];
-        newdev_info.rgswap = ((configtable[8] >> zonecnt) & 1) || rgswapconfig[zonecnt];
-        rgswap_final[zonecnt] = newdev_info.rgswap;
 
 		/*--------------------------------------------------------------------------------------------------*\
 		| We will need to know what zone type this is, so that we can look up the name and make calls later. |
@@ -158,11 +108,6 @@ void PolychromeUSBController::SetDeviceInfo()
             \*-----------------------------------------*/
             case POLYCHROME_USB_ZONE_ARGB1:
             case POLYCHROME_USB_ZONE_ARGB2:
-            /*---------------------------------------------*\
-            | The last led channel is allocated to a       |
-            | third ARGB header on some newer motherboards |
-            \*---------------------------------------------*/
-            case POLYCHROME_USB_ZONE_AUDIO:
                 newdev_info.device_type = PolychromeDeviceType::ADDRESSABLE;
                 break;
 
@@ -172,9 +117,10 @@ void PolychromeUSBController::SetDeviceInfo()
             case POLYCHROME_USB_ZONE_PCH:
             case POLYCHROME_USB_ZONE_IOCOVER:
             case POLYCHROME_USB_ZONE_PCB:
+            case POLYCHROME_USB_ZONE_AUDIO:
                 newdev_info.device_type = PolychromeDeviceType::FIXED;
                 break;
-
+            
             /*-----------------------------------------*\
             | Type: Fixed                               |
             \*-----------------------------------------*/
@@ -187,26 +133,6 @@ void PolychromeUSBController::SetDeviceInfo()
 
         device_info.push_back(newdev_info);
     }
-
-    // set rgswap to match our settings
-    WriteRGSwap(rgswap_final[0], rgswap_final[1], rgswap_final[2], rgswap_final[3], rgswap_final[4], rgswap_final[5], rgswap_final[6], rgswap_final[7]);
-}
-
-void PolychromeUSBController::ResizeZone(int zone, int new_size)
-{
-    unsigned char zonecfg[POLYCHROME_USB_ZONE_MAX_NUM];
-
-    memset(zonecfg, POLYCHROME_USB_ZONE_UNAVAILABLE, POLYCHROME_USB_ZONE_MAX_NUM);
-
-    configtable[zone] = new_size;
-
-    for(unsigned int i = 0; i < POLYCHROME_USB_ZONE_MAX_NUM; i++)
-    {
-        zonecfg[i] = configtable[i];
-    }
-
-    unsigned char zonecmd = POLYCHROME_USB_LEDCOUNT_CFG;
-    WriteHeader(zonecmd, zonecfg, sizeof(zonecfg));
 }
 
 void PolychromeUSBController::WriteZone
@@ -214,13 +140,13 @@ void PolychromeUSBController::WriteZone
     unsigned char   zone,
     unsigned char   mode,
     unsigned char   speed,
-    RGBColor        rgb,
+    RGBColor        rgb, 
     bool            allzone = false
     )
 {
 
 	/*----------------------------------------------------*\
-    | Get the device info so we can look up the zone type. |
+    | Get the device info so we can look up the zone type. | 
 	\*----------------------------------------------------*/
     PolychromeDeviceInfo device_info = GetPolychromeDevices()[zone];
 
@@ -235,20 +161,10 @@ void PolychromeUSBController::WriteZone
     | Set up message packet with leading 00                  |
     \*-----------------------------------------------------*/
 	usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
-    usb_buf[0x03] = device_info.zone_type;
+    usb_buf[0x03] = device_info.zone_type; 
 	usb_buf[0x04] = mode;
-
-    if(device_info.rgswap)
-    {
-        usb_buf[0x05] = RGBGetRValue(rgb);
-        usb_buf[0x06] = RGBGetGValue(rgb);
-    }
-    else
-    {
-        usb_buf[0x05] = RGBGetGValue(rgb);
-        usb_buf[0x06] = RGBGetRValue(rgb);
-    }
-
+	usb_buf[0x05] = RGBGetRValue(rgb);
+	usb_buf[0x06] = RGBGetGValue(rgb);
 	usb_buf[0x07] = RGBGetBValue(rgb);
 	usb_buf[0x08] = speed;
 	usb_buf[0x09] = 0xFF;
@@ -263,126 +179,67 @@ void PolychromeUSBController::WriteZone
 
 void PolychromeUSBController::WriteAllZones
     (
-    const std::vector<PolychromeZoneInfo>&  /*zones_info*/,
+    const std::vector<PolychromeZoneInfo>&  zones_info,
     const std::vector<zone>&                zones
     )
 {
-    std::vector<unsigned char> combined_leds_rgb;
-    std::size_t max_led_count = 0;
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++){
-        PolychromeDeviceInfo device_info = GetPolychromeDevices()[zone_idx];
-
-        for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
-        {
-            if(device_info.rgswap)
-            {
-                combined_leds_rgb.push_back(RGBGetRValue(zones[zone_idx].colors[led_idx]));
-                combined_leds_rgb.push_back(RGBGetGValue(zones[zone_idx].colors[led_idx]));
-            }
-            else
-            {
-                combined_leds_rgb.push_back(RGBGetGValue(zones[zone_idx].colors[led_idx]));
-                combined_leds_rgb.push_back(RGBGetRValue(zones[zone_idx].colors[led_idx]));
-            }
-            combined_leds_rgb.push_back(RGBGetBValue(zones[zone_idx].colors[led_idx]));
-        }
-        max_led_count += zones[zone_idx].leds_max;
-    }
-    combined_leds_rgb.resize((max_led_count + 8) * 3, 0);
-
     unsigned char usb_buf[65];
+
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
     \*-----------------------------------------------------*/
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     /*-----------------------------------------------------*\
-    | Set up initial message packet with leading 00         |
+    | Set up message packet with leading 00                  |
     \*-----------------------------------------------------*/
     usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
-    usb_buf[0x03] = 0xFF;
-    usb_buf[0x04] = POLYCHROME_USB_INITIAL_CHUNK;
-    usb_buf[0x07] = 0xFF;
-    usb_buf[0x40] = 0x65;
+    usb_buf[0x03] = 0x07;
+    usb_buf[0x04] = zones_info[0].mode;
+    usb_buf[0x04] = 0xE2;
 
-    std::size_t initial_led_offset = 9;
-    std::size_t message_byte_capacity = 54;           // 18 leds * 3 bytes
-
-    std::size_t led_byte_idx = 0;
-
-    while(led_byte_idx < combined_leds_rgb.size())
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
-        for(std::size_t byte_idx = 0; byte_idx < message_byte_capacity; byte_idx++)
-        {
-            usb_buf[initial_led_offset + byte_idx] = combined_leds_rgb[led_byte_idx++];
-            if(led_byte_idx >= combined_leds_rgb.size())
-            {
-                break;
-            }
-        }
-
-        /*-----------------------------------------------------*\
-        | Send packet                                           |
-        \*-----------------------------------------------------*/
-        hid_write(dev, usb_buf, 65);
-
-        /*-----------------------------------------------------*\
-        | Zero out buffer                                       |
-        \*-----------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        /*-----------------------------------------------------*\
-        | Set up message packet with leading 00                  |
-        \*-----------------------------------------------------*/
-        usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
-        usb_buf[0x03] = 0xFF;
-        usb_buf[0x04] = POLYCHROME_USB_SEND_CHUNK;
-        usb_buf[0x40] = 0x65;
-
-        initial_led_offset = 5;
-        message_byte_capacity = 57;                 // 19 leds * 3 bytes
-    }
-}
-
-/*-----------------------------------------------------*\
-| If reset is true, rgswap is set to the values         |
-| specified in the settings file, otherwise set to off  |
-\*-----------------------------------------------------*/
-void PolychromeUSBController::SetRGSwap(bool reset)
-{
-    if(reset)
-    {
-        bool rg[8] = {0};
-        std::vector<PolychromeDeviceInfo> devices_info = GetPolychromeDevices();
-        for (PolychromeDeviceInfo device : devices_info)
-        {
-            rg[device.zone_type] = device.rgswap;
-        }
-        WriteRGSwap(rg[0], rg[1], rg[2], rg[3], rg[4], rg[5], rg[6], rg[7]);
-    }
-    else
-    {
-        /*-----------------------------------------------------------------*\
-        | Disable RGSwap as it causes flashing on each update in direct mode|
-        \*-----------------------------------------------------------------*/
-        WriteRGSwap(0, 0, 0, 0, 0, 0, 0, 0);
+        usb_buf[0x05 + (3 * zone_idx)    ] = RGBGetRValue(zones[zone_idx].colors[0]);
+        usb_buf[0x05 + (3 * zone_idx) + 1] = RGBGetGValue(zones[zone_idx].colors[0]);
+        usb_buf[0x05 + (3 * zone_idx) + 2] = RGBGetBValue(zones[zone_idx].colors[0]);
     }
+    
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
 }
 
 void PolychromeUSBController::WriteRGSwap
     (
-    bool hdr0,
-    bool hdr1,
-    bool ahdr0,
     bool ahdr1,
-    bool pch,
-    bool io,
-    bool pcb,
-    bool chnl8
+    bool ahdr0,
+    bool hdr1,
+    bool hdr0
     )
 {
-    unsigned char rgconfig[1] = {static_cast<unsigned char>(((chnl8 << 7) | (pcb << 6) | (io << 5) | (pch << 4) | (ahdr1 << 3) | (ahdr0 << 2) | (hdr1 << 1) | hdr0))};
-    WriteHeader(POLYCHROME_USB_RGSWAP_CFG, rgconfig, 1);
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00                 |
+    \*-----------------------------------------------------*/
+	usb_buf[0x01] = POLYCHROME_USB_WRITE_HEADER;
+
+    usb_buf[0x04] = POLYCHROME_USB_RGSWAP_CFG;
+	usb_buf[0x05] = ((ahdr1 << 3) & (ahdr0 << 2) & (hdr1 << 1) & hdr0) & 0x40;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
 }
 
 void PolychromeUSBController::WriteHeader
@@ -435,7 +292,7 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
     | Set up config table request packet                    |
     \*-----------------------------------------------------*/
     usb_buf[0x01]   = POLYCHROME_USB_READ_ZONE_CONFIG;
-    usb_buf[0x03]   = device_info.zone_type;
+    usb_buf[0x03]   = device_info.zone_type; 
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
@@ -447,28 +304,13 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
     \*-----------------------------------------------------*/
     memset(usb_buf, 0x00, sizeof(usb_buf));
     hid_read(dev, usb_buf, 64);
-
+    
     r   = usb_buf[0x05];
     g   = usb_buf[0x06];
     b   = usb_buf[0x07];
 
-    /*------------------------------------------------------*\
-    | Set Chroma mode (0xE2) & Per-Led mode (0xE3) as Direct |
-    \*------------------------------------------------------*/
-    zoneinfo.mode   = usb_buf[0x04] != 0xE2 && usb_buf[0x04] != 0xE3 && usb_buf[0x04] < 0x0F ? usb_buf[0x04] : 0x0F;
-
-    /*------------------------------------------------------*\
-    | G & R are swapped since RGSwap is disabled on init,    |
-    | Unless overwritten in settings                         |
-    \*------------------------------------------------------*/
-    if(device_info.rgswap)
-    {
-        zoneinfo.color  = ToRGBColor(r,g,b);
-    }
-    else
-    {
-        zoneinfo.color  = ToRGBColor(g,r,b);
-    }
+    zoneinfo.mode   = usb_buf[0x04] != 0xE2 ? usb_buf[0x04] : 0x0F;
+    zoneinfo.color  = ToRGBColor(r,g,b);  
     zoneinfo.speed  = usb_buf[0x08];
     zoneinfo.zone   = usb_buf[0x03];
 
@@ -479,7 +321,7 @@ void PolychromeUSBController::ReadConfigTables()
 {
     unsigned char usb_buf[65];
     unsigned char maxzoneleds[8];
-    unsigned char rgswap;
+    unsigned char rgbswap;
     unsigned char header1;
 
     /*-----------------------------------------------------*\
@@ -506,7 +348,7 @@ void PolychromeUSBController::ReadConfigTables()
 
     /*-----------------------------------------------------*\
     | Reads in format: RGB1, RGB2, ARGB1, ARGB2, PCH, IO,   |
-    | PCB, AUDIO/ARGB3                                      |
+    | PCB, AUDIO                                            |
     \*-----------------------------------------------------*/
     memcpy(&maxzoneleds,&usb_buf[0x04],8);
 
@@ -526,10 +368,10 @@ void PolychromeUSBController::ReadConfigTables()
     hid_read(dev, usb_buf, 64);
 
     /*-----------------------------------------------------*\
-    | Reads bitwise in format: AUDIO/ARGB3, PCB, IO, PCH,   |
-    | ARGB2,ARGB1, RGB2, RGB1 if available                  |
+    | Reads bitwise in format: AUDIO, PCB, IO, PCH, ARGB2,  |
+    | ARGB1, RGB2, RGB1 if available                        |
     \*-----------------------------------------------------*/
-    rgswap=usb_buf[4];
+    rgbswap=usb_buf[4];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -545,15 +387,10 @@ void PolychromeUSBController::ReadConfigTables()
     hid_write(dev, usb_buf, 64);
     memset(usb_buf, 0x00, sizeof(usb_buf));
     hid_read(dev, usb_buf, 64);
-
-    /*-----------------------------------------------------*\
-    | Reads bitwise in format: AUDIO/ARGB3, PCB, IO, PCH,   |
-    | ARGB2,ARGB1, RGB2, RGB1 if available                  |
-    \*-----------------------------------------------------*/
     header1=usb_buf[4];
 
     memcpy(configtable,&maxzoneleds,8);
-    configtable[8]=rgswap;
+    configtable[8]=rgbswap;
     configtable[9]=header1;
     return;
 }

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

@@ -5,7 +5,6 @@
 |  lighting controller                      |
 |                                           |
 |  Ed Kambulow (dredvard) 12/20/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/
 
 #include "RGBController.h"
@@ -70,7 +69,7 @@ enum
     POLYCHROME_USB_ZONE_PCH          = 0X04,  // PCH
     POLYCHROME_USB_ZONE_IOCOVER      = 0X05,  // IOCOVER
     POLYCHROME_USB_ZONE_PCB          = 0X06,  // PCB - Could be mixed swapped with 0x07
-    POLYCHROME_USB_ZONE_AUDIO        = 0X07   // AUDIO/ARGB Header 3
+    POLYCHROME_USB_ZONE_AUDIO        = 0X07   // AUDIO
 };
 
 enum class PolychromeDeviceType
@@ -92,7 +91,6 @@ struct PolychromeDeviceInfo
     unsigned char           effect_channel;
     unsigned char           num_leds;
 	unsigned char			zone_type;
-    bool        			rgswap;
     PolychromeDeviceType    device_type;
 };
 
@@ -133,31 +131,17 @@ public:
                                                     unsigned int    configsize
                                                     );
 
-    void                                        ResizeZone(int zone, int new_size);
-    void                                        SetRGSwap(bool reset);
-
 protected:
     hid_device*                         dev;
     std::vector<PolychromeDeviceInfo>   device_info;
     std::string                         location;
 
-    void WriteRGSwap
-        (
-        bool hdr0,
-        bool hdr1,
-        bool ahdr0,
-        bool ahdr1,
-        bool pch,
-        bool io,
-        bool pcb,
-        bool chnl8
-        );
+    void WriteRGSwap(bool ahdr1, bool ahdr0, bool hdr1, bool hdr0);
 
 private:
     unsigned int  led_count;
     std::string   device_name;
     unsigned char configtable[12];
-    bool          rgswapconfig[8] = { 0 };
 
     void SetDeviceInfo();    
     void ReadConfigTables();

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -5,7 +5,6 @@
 |  ASRock Polychrome USB Driver             |
 |                                           |
 |  Ed Kambulow (Dredvard) 12/26/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/
 
 #include "RGBController_ASRockPolychromeUSB.h"
@@ -23,6 +22,7 @@
     @effects :white_check_mark:
     @detectors DetectPolychromeUSBControllers
     @comment ASRock Polychrome controllers will save with each update.
+        Per ARGB LED support is not possible with these devices.
 \*-------------------------------------------------------------------*/
 
 RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr)
@@ -181,6 +181,11 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
     modes.push_back(Direct);
 
     SetupZones();
+
+    /*-------------------------------------------------*\
+    | Initialize active mode                            |
+    \*-------------------------------------------------*/
+    active_mode = GetDeviceMode(1);
 }
 
 void RGBController_PolychromeUSB::SetupZones()
@@ -233,6 +238,16 @@ void RGBController_PolychromeUSB::SetupZones()
 
     SetupColors();
 
+    /*---------------------------------------------------------*\
+    | Initialize colors for each LED                            |
+    \*---------------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        unsigned char led = (unsigned char)leds[led_idx].value;
+
+        colors[led_idx] = controller->GetZoneConfig(led).color;     // TODO Get addressable instead of zone idx
+    }
+
     /*---------------------------------------------------------*\
     | Initialize zone info to track zone, speed, mode           |
     | B550 Boards have modes, speed for each zone               |
@@ -244,37 +259,26 @@ void RGBController_PolychromeUSB::SetupZones()
         zones_info.push_back(zoneinfo);
     }
 
-     /*---------------------------------------------------------*\
-     | Initialize colors for each LED                            |
-     | We cannot currently get the individual led color so       |
-     | we use the zone color in each zone to set all leds        |
-     | !!TODO: in Per-Led mode, zone color is always black       |
-     \*---------------------------------------------------------*/
-     for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-     {
-         unsigned char led = (unsigned char)leds[led_idx].value;
-
-         colors[led_idx] = zones_info[led].color;
-     }
-
-     /*-------------------------------------------------*\
-     | Initialize active mode                            |
-     \*-------------------------------------------------*/
-     active_mode = zones_info.size() > 1 ? zones_info[0].mode : 0x0;
-
-     /*-----------------------------------------------------*\
-     | If in Direct mode, reset all Leds to match interface  |
-     \*-----------------------------------------------------*/
-     if(active_mode == 0x0F)
-     {
-        controller->WriteAllZones(zones_info, zones);
-     }
 }
 
 void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
 {
+     unsigned char zonecfg[ASROCK_USB_MAX_ZONES];
+
+    /*---------------------------------------------------------*\
+    | This device does not currently support resizing zones     |
+    \*---------------------------------------------------------*/
     zones[zone].leds_count = (unsigned char) new_size;
-    controller->ResizeZone(zones_info[zone].zone, new_size);
+
+    memset(zonecfg, POLYCHROME_USB_ZONE_UNAVAILABLE, ASROCK_USB_MAX_ZONES);
+
+    for(unsigned int i = 0; i < zones.size(); i++)
+    {
+        zonecfg[i]=zones[i].leds_count;
+    }
+
+    // unsigned char zonecmd = POLYCHROME_USB_LEDCOUNT_CFG;
+    // WriteHeader(zonecmd, zonecfg, sizeof(zonecfg));
 }
 
 void RGBController_PolychromeUSB::DeviceUpdateLEDs()
@@ -334,12 +338,6 @@ unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
 
 void RGBController_PolychromeUSB::DeviceUpdateMode()
 {
-    /*-----------------------------------------------------------------*\
-    | Disable RGSwap as it causes flashing on each update in direct mode|
-    | Otherwise, reset to values specified in settings.json             |
-    \*-----------------------------------------------------------------*/
-    controller->SetRGSwap(modes[active_mode].name != "Direct");
-
     for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
         if(zones[zone_idx].leds_count > 0)

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -5,7 +5,6 @@
 |  ASRock Polychrome USB Driver             |
 |                                           |
 |  Ed Kambulow (Dredvard) 12/26/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/
 
 #pragma once

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp

@@ -105,7 +105,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     mode Music;
     Music.name                  = "Music";
     Music.value                 = POLYCHROME_V1_MODE_MUSIC;
-    Music.flags                 = MODE_FLAG_AUTOMATIC_SAVE;
+    Music.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     Music.color_mode            = MODE_COLORS_NONE;
     modes.push_back(Music);
 
@@ -122,6 +122,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     /*---------------------------------------------------------------------*\
     | Comment out until per zone modes are working. These are only for ARGB |
     \*---------------------------------------------------------------------*/
+    /*
     mode Spring;
     Spring.name                 = "Spring";
     Spring.value                = POLYCHROME_V1_MODE_SPRING;
@@ -191,6 +192,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     Rainbow.speed               = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
     Rainbow.color_mode          = MODE_COLORS_NONE;
     modes.push_back(Rainbow);
+    */
 
     /*---------------------------------------------------------------------*\
     | This ARGB_Config section is a hack to allow users to configure the    |

Controllers/AlienwareController/AlienwareController.cpp

@@ -15,7 +15,6 @@
 #include <chrono>
 #include <algorithm>
 #include <sstream>
-#include "LogManager.h"
 
 typedef uint32_t alienware_platform_id;
 
@@ -25,10 +24,8 @@ typedef uint32_t alienware_platform_id;
 \*---------------------------------------------------------*/
 static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
 {
-    { 0x0C01,   4 },    // Dell G5 SE 5505
-    { 0x0A01,  16 },    // Dell G7 15 7500
-    { 0x0E03,   4 }     // Dell G15   5511
-
+    { 0x0C01,   4 }, // Dell G5 SE 5505
+    { 0x0A01,  16 }  // Dell G7 15 7500
 };
 
 /*---------------------------------------------------------*\
@@ -42,8 +39,7 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
                   "Light Bar 1",    "Light Bar 2",  "Light Bar 3",
                   "Light Bar 4",    "Light Bar 5",  "Light Bar 6",
                   "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
-                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
-    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } }
+                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } }
 };
 
 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
@@ -117,13 +113,10 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
 
     if(zone_names_table.count(platform_id))
     {
-        LOG_INFO("[%s] Known platform: %8X, Number of zones: %d", ALIENWARE_CONTROLLER_NAME, platform_id, number_of_zones);
         zone_names = zone_names_table.at(platform_id);
     }
     else
     {
-        LOG_WARNING("[%s] Unknown platform: %8X, Number of zones: %d", ALIENWARE_CONTROLLER_NAME, platform_id, number_of_zones);
-
         /*-------------------------------------------------*\
         | If this is an unknown controller, set the name of |
         | all regions to "Unknown"                          |
@@ -599,14 +592,13 @@ void AlienwareController::SetColor(uint8_t zone, RGBColor color)
 
 void AlienwareController::SetColor(uint8_t zone, RGBColor color1, RGBColor color2)
 {
-    if ((color1 == zones[zone].color[0]) && (color2 == zones[zone].color[1]))
-    {
-        return;
-    }
+    dirty = ((color1 != zones[zone].color[0]) || (color2 != zones[zone].color[1]));
 
-    zones[zone].color[0] = color1;
-    zones[zone].color[1] = color2;
-    dirty = true;
+	if(dirty)
+	{
+		zones[zone].color[0] = color1;
+        zones[zone].color[1] = color2;
+	}
 }
 
 void AlienwareController::SetPeriod(uint8_t zone, uint16_t period)

Controllers/AlienwareController/AlienwareController.h

@@ -19,7 +19,7 @@
 
 #define ALIENWARE_REPORT_SIZE               33
 #define HIDAPI_ALIENWARE_REPORT_SIZE        (ALIENWARE_REPORT_SIZE + 1)
-#define ALIENWARE_CONTROLLER_NAME           "AlienWare Controller"
+
 enum
 {
     ALIENWARE_COMMAND_REPORT                = 0x20,     /* Set report type to get               */

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.cpp

@@ -45,9 +45,9 @@ typedef struct
     const char *        name;
     const unsigned char zone;
     const unsigned char idx;
-} aw510k_led_type;
+} led_type;
 
-static const aw510k_led_type led_names[] =
+static const led_type led_names[] =
 {
     /* Key Label                Zone,                                      Index  */
     { KEY_EN_ESCAPE,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB0    },

Controllers/AnnePro2Controller/AnnePro2ControllerDetect.cpp

@@ -9,7 +9,6 @@
 #define ANNE_PRO_2_PID_2 0x8009
 #define ANNE_PRO_2_PID_3 0xA292
 #define ANNE_PRO_2_PID_4 0xA293
-#define ANNE_PRO_2_PID_5 0xA297
 
 /******************************************************************************************\
 *                                                                                          *
@@ -35,4 +34,3 @@ REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID,
 REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_2, 1);
 REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_3, 1);
 REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_4, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_5, 1);

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

@@ -40,9 +40,9 @@ typedef struct
 {
     const char *        name;
     const unsigned char idx;
-} annepro2_led_type;
+} led_type;
 
-static const annepro2_led_type led_names[] =
+static const led_type led_names[] =
 {
     /* Key Label                Index  */
     { KEY_EN_ESCAPE,            0       },

Controllers/ArcticController/ArcticController.cpp

@@ -1,155 +0,0 @@
-/*-----------------------------------------*\
-|  ArcticController.h                       |
-|                                           |
-|  Controller Interface for Arctic devices  |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
-
-#include "ArcticController.h"
-#include <cstring>
-
-using namespace std::chrono_literals;
-
-#define ARCTIC_COMMAND_SET_RGB          0x00
-#define ARCTIC_COMMAND_IDENTIFY         0x5C
-
-#define ARCTIC_RESPONSE_BUFFER_LENGTH   15
-#define ARCTIC_RESPONSE_COMMAND_OFFSET  0
-#define ARCTIC_RESPONSE_DATA_OFFSET     1
-#define ARCTIC_RESPONSE_DATA_LENGTH     12
-#define ARCTIC_RESPONSE_XOR_CSUM_OFFSET 13
-#define ARCTIC_RESPONSE_ADD_CSUM_OFFSET 14
-
-#define ARCTIC_COMMAND_BUFFER_LENGTH(payload_size)  (sizeof(header) + 1 + payload_size)
-#define ARCTIC_COMMAND_COMMAND_OFFSET               (sizeof(header))
-#define ARCTIC_COMMAND_PAYLOAD_OFFSET               (sizeof(header) + 1)
-
-const unsigned char header[] =
-{
-    0x01,
-    0x02,
-    0x03,
-    0xFF,
-    0x05,
-    0xFF,
-    0x02,
-    0x03
-};
-
-const unsigned char identify_payload[] =
-{
-    0x01,
-    0xFE,
-    0x01,
-    0xFE
-};
-
-ArcticController::ArcticController(const std::string &portname)
-: serialport(portname.c_str(), 250000, SERIAL_PORT_PARITY_NONE, SERIAL_PORT_SIZE_8, SERIAL_PORT_STOP_BITS_2, false)
-{
-    port_name = portname;
-    serialport.serial_set_dtr(true);
-}
-
-ArcticController::~ArcticController()
-{
-    serialport.serial_set_dtr(false);
-}
-
-static void FormatCommandBuffer(char *buffer, char command)
-{
-    std::memcpy(buffer, header, sizeof(header));
-    buffer[ARCTIC_COMMAND_COMMAND_OFFSET] = command;
-}
-
-void ArcticController::SetChannels(std::vector<RGBColor> colors)
-{
-    char* buffer = new char[ARCTIC_COMMAND_BUFFER_LENGTH(colors.size() * 3)];
-
-    FormatCommandBuffer(buffer, ARCTIC_COMMAND_SET_RGB);
-
-    for(unsigned int channel = 0; channel < colors.size(); channel++)
-    {
-        const unsigned int offset = ARCTIC_COMMAND_PAYLOAD_OFFSET + channel * 3;
-
-        buffer[offset + 0x00] = std::min<unsigned int>(254, RGBGetRValue(colors[channel]));
-        buffer[offset + 0x01] = std::min<unsigned int>(254, RGBGetGValue(colors[channel]));
-        buffer[offset + 0x02] = std::min<unsigned int>(254, RGBGetBValue(colors[channel]));
-    }
-
-    serialport.serial_write(buffer, sizeof(buffer));
-
-    delete[] buffer;
-}
-
-static char XORChecksum(char *data, int length)
-{
-    char sum = 0;
-
-    for(int i = 0; i < length; i++)
-    {
-        sum ^= data[i];
-    }
-
-    return sum;
-}
-
-static char AddChecksum(char *data, int length)
-{
-    char sum = 0;
-
-    for(int i = 0; i < length; i++)
-    {
-        sum = (char)(sum + data[i]);
-    }
-
-    return sum;
-}
-
-bool ArcticController::IsPresent()
-{
-    char buffer[ARCTIC_COMMAND_BUFFER_LENGTH(sizeof(identify_payload))];
-    char response[ARCTIC_RESPONSE_BUFFER_LENGTH];
-    int ret;
-
-    FormatCommandBuffer(buffer, ARCTIC_COMMAND_IDENTIFY);
-    std::memcpy(buffer + ARCTIC_COMMAND_PAYLOAD_OFFSET, identify_payload, sizeof(identify_payload));
-
-    serialport.serial_flush_rx();
-    ret = serialport.serial_write(buffer, sizeof(buffer));
-    if(ret != sizeof(buffer))
-    {
-        return false;
-    }
-
-    std::this_thread::sleep_for(100ms);
-
-    ret = serialport.serial_read(response, sizeof(response));
-    if(ret != sizeof(response))
-    {
-        return false;
-    }
-
-    if(response[ARCTIC_RESPONSE_COMMAND_OFFSET] != ARCTIC_COMMAND_IDENTIFY)
-    {
-        return false;
-    }
-
-    if(response[ARCTIC_RESPONSE_XOR_CSUM_OFFSET] != XORChecksum(&response[ARCTIC_RESPONSE_DATA_OFFSET], ARCTIC_RESPONSE_DATA_LENGTH))
-    {
-        return false;
-    }
-
-    if(response[ARCTIC_RESPONSE_ADD_CSUM_OFFSET] != AddChecksum(&response[ARCTIC_RESPONSE_DATA_OFFSET], ARCTIC_RESPONSE_DATA_LENGTH))
-    {
-        return false;
-    }
-
-    return true;
-}
-
-std::string ArcticController::GetLocation()
-{
-    return port_name;
-}

Controllers/ArcticController/ArcticController.h

@@ -1,29 +0,0 @@
-/*-----------------------------------------*\
-|  ArcticController.h                       |
-|                                           |
-|  Controller Interface for Arctic devices  |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
-
-#pragma once
-#include <algorithm>
-
-#include "RGBController.h"
-#include "serial_port.h"
-
-class ArcticController
-{
-public:
-    ArcticController(const std::string &portname);
-    ~ArcticController();
-
-    void SetChannels(std::vector<RGBColor> colors);
-    bool IsPresent();
-
-    std::string GetLocation();
-
-private:
-    std::string port_name;
-    serial_port serialport;
-};

Controllers/ArcticController/ArcticControllerDetect.cpp

@@ -1,48 +0,0 @@
-/*-----------------------------------------*\
-|  ArcticControllerDetect.cpp               |
-|                                           |
-|  Detect Arctic RGB controllers            |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
-
-#include "Detector.h"
-#include "ArcticController.h"
-#include "RGBController.h"
-#include "RGBController_Arctic.h"
-#include "find_usb_serial_port.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-#define CH341_VID   0x1A86
-#define CH341_PID   0x7523
-
-void DetectArcticControllers()
-{
-    std::vector<std::string *> ports = find_usb_serial_port(CH341_VID, CH341_PID);
-
-    for(unsigned int device = 0; device < ports.size(); device++)
-    {
-        ArcticController *controller = new ArcticController(*ports[device]);
-
-        if(controller->IsPresent())
-        {
-            RGBController_Arctic *rgb_controller = new RGBController_Arctic(controller);
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-        }
-        else
-        {
-            delete controller;
-        }
-
-        delete ports[device];
-    }
-}
-
-REGISTER_DETECTOR("Arctic RGB controller", DetectArcticControllers);
-/*---------------------------------------------------------------------------------------------------------*\
-| Entries for dynamic UDEV rules                                                                            |
-|                                                                                                           |
-| DUMMY_DEVICE_DETECTOR("Arctic RGB controller", DetectArcticControllers, 0x1a86, 0x7523 )                  |
-\*---------------------------------------------------------------------------------------------------------*/

Controllers/ArcticController/RGBController_Arctic.cpp

@@ -1,131 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_Arctic.h                   |
-|                                           |
-|  Generic RGB Interface for Arctic devices |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
-
-#include "RGBController_Arctic.h"
-#include <math.h>
-
-using namespace std::chrono_literals;
-
-#define ARCTIC_NUM_CHANNELS     4
-#define ARCTIC_SLEEP_THRESHOLD  100ms
-#define ARCTIC_KEEPALIVE_PERIOD 500ms  /* Device requires at least 1s */
-
-/**------------------------------------------------------------------*\
-    @name Arctic RGB Controller Devices
-    @category LEDStrip
-    @type Serial
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectArcticControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_Arctic::RGBController_Arctic(ArcticController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "Arctic RGB Controller";
-    vendor      = "Arctic";
-    description = "Arctic 4-Channel RGB Controller";
-    location    = controller->GetLocation();
-    type        = DEVICE_TYPE_LEDSTRIP;
-
-    mode DirectMode;
-    DirectMode.name         = "Direct";
-    DirectMode.value        = 0;
-    DirectMode.flags        = MODE_FLAG_HAS_PER_LED_COLOR;
-    DirectMode.color_mode   = MODE_COLORS_PER_LED;
-
-    modes.push_back(DirectMode);
-
-    SetupZones();
-
-    keepalive_thread_run = true;
-    keepalive_thread = std::thread(&RGBController_Arctic::KeepaliveThreadFunction, this);
-}
-
-RGBController_Arctic::~RGBController_Arctic()
-{
-    keepalive_thread_run = false;
-    keepalive_thread.join();
-    delete controller;
-}
-
-void RGBController_Arctic::SetupZones()
-{
-    for(int channel = 0; channel < ARCTIC_NUM_CHANNELS; channel++)
-    {
-        zone LedZone;
-        LedZone.name        = "LED Strip " + std::to_string(channel);
-        LedZone.type        = ZONE_TYPE_SINGLE;
-        LedZone.leds_count  = 1;
-        LedZone.leds_min    = 1;
-        LedZone.leds_max    = 1;
-        LedZone.matrix_map  = nullptr;
-
-        led Led;
-        Led.name    = LedZone.name + " LED";
-        Led.value   = channel;
-
-        zones.push_back(LedZone);
-        leds.push_back(Led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_Arctic::ResizeZone(int /* zone */, int /* new_size */)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_Arctic::DeviceUpdateLEDs()
-{
-    last_update_time = std::chrono::steady_clock::now();
-
-    controller->SetChannels(colors);
-}
-
-void RGBController_Arctic::UpdateZoneLEDs(int /* zone */)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_Arctic::UpdateSingleLED(int /* led */)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_Arctic::DeviceUpdateMode()
-{
-    /*---------------------------------------------------------*\
-    | This device does not support mode updates                 |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_Arctic::KeepaliveThreadFunction()
-{
-    std::chrono::nanoseconds sleep_time;
-
-    while(keepalive_thread_run.load())
-    {
-        sleep_time = ARCTIC_KEEPALIVE_PERIOD - (std::chrono::steady_clock::now() - last_update_time);
-        if(sleep_time <= ARCTIC_SLEEP_THRESHOLD)
-        {
-            UpdateLEDs();   // Already protected thru a device update thread
-            std::this_thread::sleep_for(ARCTIC_KEEPALIVE_PERIOD);
-        }
-        else
-        {
-            std::this_thread::sleep_for(sleep_time);
-        }
-    }
-}

Controllers/ArcticController/RGBController_Arctic.h

@@ -1,40 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_Arctic.h                   |
-|                                           |
-|  Generic RGB Interface for Arctic devices |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 27/08/2023         |
-\*-----------------------------------------*/
-
-#pragma once
-#include "ArcticController.h"
-#include "RGBController.h"
-#include "serial_port.h"
-#include <chrono>
-#include <thread>
-
-class RGBController_Arctic : public RGBController
-{
-public:
-    RGBController_Arctic(ArcticController* controller_ptr);
-    ~RGBController_Arctic();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-    void        KeepaliveThreadFunction();
-
-private:
-    ArcticController*                                   controller;
-    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
-    std::atomic<bool>                                   keepalive_thread_run;
-    std::thread                                         keepalive_thread;
-};
-

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -55,4 +55,3 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreContro
 REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1866);
 REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1869);
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 15",      DetectAsusAuraCoreLaptopControllers,    AURA_CORE_VID, AURA_STRIX_SCAR_15_PID,  0xFF31, 0x79);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 17",      DetectAsusAuraCoreLaptopControllers,    AURA_CORE_VID, 0x1866,                  0xFF31, 0x79);

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.cpp

@@ -9,8 +9,6 @@
 
 #include "AsusAuraCoreLaptopController.h"
 
-#include "SettingsManager.h"
-
 static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT       +
                           ASUSAURACORELAPTOP_LIGHTBARCOUNT  +
                           ASUSAURACORELAPTOP_LIDCOUNT       ] =

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.h

@@ -13,6 +13,7 @@
 #include "LogManager.h"
 #include "RGBController.h"
 #include "ResourceManager.h"
+#include "SettingsManager.h"
 #include "RGBControllerKeyNames.h"
 
 #pragma once

Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.cpp

@@ -406,8 +406,6 @@ void RGBController_AsusAuraCoreLaptop::Init_Controller()
     lightbar.leds_min           = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
     lightbar.leds_max           = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
     lightbar.leds_count         = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
-    lightbar.matrix_map         = NULL;
-
     zones.push_back(lightbar);
 
     zone lid;
@@ -416,8 +414,6 @@ void RGBController_AsusAuraCoreLaptop::Init_Controller()
     lid.leds_min                = ASUSAURACORELAPTOP_LIDCOUNT;
     lid.leds_max                = ASUSAURACORELAPTOP_LIDCOUNT;
     lid.leds_count              = ASUSAURACORELAPTOP_LIDCOUNT;
-    lid.matrix_map              = NULL;
-
     zones.push_back(lid);
 }
 

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -65,12 +65,7 @@ void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
     }
 } /* DetectAsusAuraGPUControllers() */
 
-/*-----------------------------------------*\
-|  NVidia GPUs                              |
-\*-----------------------------------------*/
-
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI 4G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1060 Strix 6G Gaming"             , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX_6G_GAMING,               0x29);
@@ -91,46 +86,38 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650S OC 4G"            , DetectAs
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660S O6G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1660 Ti OC 6G"                , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming 6G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G EVO Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G EVO Gaming"   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S 8G Gaming 8G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G EVO Gaming 8G", DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S O8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming 8G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G V2 Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G White"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A);
-
-/*-----------------------------------------*\
-|  AMD GPUs                                 |
-\*-----------------------------------------*/
-
 REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS Vega 64 Strix"                        , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 5600XT Strix O6G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix 08G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX470 O4G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 6800 TUF Gaming OC"                , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_RX6800_TUF_GAMING_OC,                  0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX480 Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX560 Gaming"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O4G Gaming OC"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O8G Gaming OC"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O8G_GAMING_OC,             0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming OC"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming TOP"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 6900XT TUF Gaming OC"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_TUF_RX6900XT_O16G_GAMING,              0x2A);

Controllers/AsusAuraUSBController/AsusAuraMainboardController.cpp

@@ -15,7 +15,6 @@ AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const c
     unsigned char num_total_mainboard_leds  = config_table[0x1B];
     unsigned char num_rgb_headers           = config_table[0x1D];
     unsigned char num_addressable_headers   = config_table[0x02];
-    unsigned char effect_channel            = 0;
 
     if(num_total_mainboard_leds < num_rgb_headers)
     {
@@ -25,18 +24,14 @@ AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const c
     /*-----------------------------------------------------*\
     | Add mainboard device                                  |
     \*-----------------------------------------------------*/
-    if(num_total_mainboard_leds > 0)
-    {
-        device_info.push_back({effect_channel, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});
-        effect_channel++;
-    }
+    device_info.push_back({0x00, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});
 
     /*-----------------------------------------------------*\
     | Add addressable devices                               |
     \*-----------------------------------------------------*/
     for(int i = 0; i < num_addressable_headers; i++)
     {
-        device_info.push_back({effect_channel, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
+        device_info.push_back({0x01, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
     }
 }
 
@@ -86,24 +81,11 @@ void AuraMainboardController::SetMode
     unsigned char   grn,
     unsigned char   blu
     )
-{
-    SetMode(channel, mode, red, grn, blu, false);
-}
-
-void AuraMainboardController::SetMode
-    (
-    unsigned char   channel,
-    unsigned char   mode,
-    unsigned char   red,
-    unsigned char   grn,
-    unsigned char   blu,
-    bool            shutdown_effect
-    )
 {
     this->mode = mode;
     RGBColor color = ToRGBColor(red, grn, blu);
 
-    SendEffect(device_info[channel].effect_channel, mode, shutdown_effect);
+    SendEffect(device_info[channel].effect_channel, mode);
     if(mode == AURA_MODE_DIRECT)
     {
         return;
@@ -129,8 +111,7 @@ void AuraMainboardController::SetMode
         channel,
         start_led,
         device_info[channel].num_leds,
-        led_data,
-        shutdown_effect
+        led_data
     );
 }
 
@@ -142,8 +123,7 @@ unsigned short AuraMainboardController::GetMask(int start, int size)
 void AuraMainboardController::SendEffect
     (
     unsigned char   channel,
-    unsigned char   mode,
-    bool            shutdown_effect
+    unsigned char   mode
     )
 {
     unsigned char usb_buf[65];
@@ -160,7 +140,7 @@ void AuraMainboardController::SendEffect
     usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT;
     usb_buf[0x02]   = channel;
     usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = shutdown_effect ? 0x01 : 0x00;
+    usb_buf[0x04]   = 0x00;
     usb_buf[0x05]   = mode;
 
     /*-----------------------------------------------------*\
@@ -174,8 +154,7 @@ void AuraMainboardController::SendColor
     unsigned char   /*channel*/,
     unsigned char   start_led,
     unsigned char   led_count,
-    unsigned char*  led_data,
-    bool            shutdown_effect
+    unsigned char*  led_data
     )
 {
     unsigned short  mask = GetMask(start_led, led_count);
@@ -193,7 +172,7 @@ void AuraMainboardController::SendColor
     usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT_COLOR;
     usb_buf[0x02]   = mask >> 8;
     usb_buf[0x03]   = mask & 0xff;
-    usb_buf[0x04]   = shutdown_effect ? 0x01 : 0x00;
+    usb_buf[0x04]   = 0x00;
 
     /*-----------------------------------------------------*\
     | Copy in color data bytes                              |

Controllers/AsusAuraUSBController/AsusAuraMainboardController.h

@@ -44,28 +44,15 @@ public:
         unsigned char   blu
         );
 
-    void SetMode
-        (
-        unsigned char   channel,
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu,
-        bool            shutdown_effect
-        );
-
-    void SendCommit();
-
 private:
     unsigned int mode;
 
     unsigned short GetMask(int start, int size);
-
+    
     void SendEffect
         (
         unsigned char   channel,
-        unsigned char   mode,
-        bool            shutdown_effect
+        unsigned char   mode
         );
 
     void SendColor
@@ -73,7 +60,8 @@ private:
         unsigned char   channel,
         unsigned char   start_led,
         unsigned char   led_count,
-        unsigned char*  led_data,
-        bool            shutdown_effect
+        unsigned char*  led_data
         );
+
+    void SendCommit();
 };

Controllers/AsusAuraUSBController/AsusAuraMonitorController.cpp

@@ -83,19 +83,17 @@ void AuraMonitorController::UpdateLed
     usb_buf[0x02]   = 0xA1;
     usb_buf[0x03]   = 0x80;
 
-    unsigned char offset = (device_pid == AURA_ROG_STRIX_XG279Q_PID) ? 0 : 16;
-
-    usb_buf[0x04]   = offset + led * 3;
+    usb_buf[0x04]   = 16 + led * 3;
     usb_buf[0x05]   = red;
     
     hid_send_feature_report(dev, usb_buf, 8);
 
-    usb_buf[0x04]   = offset + led * 3 + 1;
+    usb_buf[0x04]   = 16 + led * 3 + 1;
     usb_buf[0x05]   = blue;
     
     hid_send_feature_report(dev, usb_buf, 8);
 
-    usb_buf[0x04]   = offset + led * 3 + 2;
+    usb_buf[0x04]   = 16 + led * 3 + 2;
     usb_buf[0x05]   = green;
     
     hid_send_feature_report(dev, usb_buf, 8);

Controllers/AsusAuraUSBController/AsusAuraMonitorController.h

@@ -15,11 +15,9 @@
 
 enum
 {
-    AURA_ROG_STRIX_XG27AQ_PID   = 0x198C,
-    AURA_ROG_STRIX_XG27AQM_PID  = 0x19BB,
-    AURA_ROG_STRIX_XG279Q_PID   = 0x1919,
-    AURA_ROG_STRIX_XG27W_PID    = 0x1933,
-    AURA_ROG_PG32UQ_PID         = 0x19B9,
+    AURA_ROG_STRIX_XG27AQ_PID    = 0x198C,
+    AURA_ROG_STRIX_XG27W_PID     = 0x1933,
+    AURA_ROG_PG32UQ_PID          = 0x19B9,
 };
 
 

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

@@ -67,17 +67,15 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
             break;
 
         case 1:
-        case 2:
             {
                 char version[9];
-                int wireless_offset = (protocol == 2 ? 14 : 13);
-                int offset = (wireless ? wireless_offset : 4);
+                int offset = (wireless ? 13 : 4);
                 snprintf(version, 9, "%2X.%02X.%02X", usb_buf_out[offset + 2], usb_buf_out[offset + 1], usb_buf_out[offset]);
                 str = std::string(version);
             }
             break;
 
-        case 3:
+        case 2:
             {
                 unsigned char* offset = usb_buf_out + (wireless ? 13 : 4);
                 str = std::string(offset, offset + 4);
@@ -85,7 +83,7 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
             }
             break;
 
-        case 4:
+        case 3:
             {
                 char version[16];
                 int offset = (wireless ? 13 : 4);

Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h

@@ -18,18 +18,12 @@
 #define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID          0x18B1
 #define AURA_ROG_GLADIUS_II_WIRELESS_1_PID          0x189E
 #define AURA_ROG_GLADIUS_II_WIRELESS_2_PID          0x18A0
-#define AURA_ROG_GLADIUS_III_PID                    0x197B
 #define AURA_ROG_GLADIUS_III_WIRELESS_USB_PID       0x197D
 #define AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID       0x197F
 #define AURA_ROG_GLADIUS_III_WIRELESS_BT_PID        0x1981
 #define AURA_ROG_CHAKRAM_WIRELESS_PID               0x18E5
 #define AURA_ROG_CHAKRAM_WIRED_1_PID                0x18E3
 #define AURA_ROG_CHAKRAM_CORE_PID                   0x1958
-#define AURA_ROG_CHAKRAM_X_USB_PID                  0x1A18
-#define AURA_ROG_CHAKRAM_X_2_4_PID                  0x1A1A
-#define AURA_ROG_SPATHA_X_USB_PID                   0x1977
-#define AURA_ROG_SPATHA_X_2_4_PID                   0x1979
-#define AURA_ROG_SPATHA_X_DOCK_PID                  0x1979
 #define AURA_ROG_PUGIO_PID                          0x1846
 #define AURA_ROG_PUGIO_II_WIRED_PID                 0x1906
 #define AURA_ROG_PUGIO_II_WIRELESS_PID              0x1908
@@ -47,15 +41,12 @@
 #define AURA_TUF_M3_PID                             0x1910
 #define AURA_TUF_M5_PID                             0x1898
 
-#define AURA_ROG_SPATHA_X_DOCK_FAKE_PID             0xFFFF
-
 enum
 {
     AURA_MOUSE_ZONE_LOGO        = 0,
     AURA_MOUSE_ZONE_SCROLL      = 1,
     AURA_MOUSE_ZONE_UNDERGLOW   = 2,
     AURA_MOUSE_ZONE_ALL         = 3,
-    AURA_MOUSE_ZONE_DOCK        = 4,
 };
 
 enum
@@ -183,26 +174,13 @@ static std::map<int,mouse_type> aura_mouse_devices =
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
     },
-    {
-        AURA_ROG_GLADIUS_III_PID, // ROG Gladius III
-        {
-            255,
-            1,
-            0,
-            100,
-            false,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
     {
         AURA_ROG_GLADIUS_III_WIRELESS_USB_PID, // ROG Gladius III Wireless USB
         {
             255,
             1,
             0,
-            100,
+            64,
             false,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -215,7 +193,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             255,
             1,
             0,
-            100,
+            64,
             true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -228,7 +206,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             255,
             1,
             0,
-            100,
+            64,
             true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -274,58 +252,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
     },
-    {
-        AURA_ROG_CHAKRAM_X_USB_PID, // ROG Chakram X USB
-        {
-            15, // technically until 255, but unusably slow after 15
-            1,
-            0,
-            100,
-            false,
-            2,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_CHAKRAM_X_2_4_PID, // ROG Chakram X 2.4GHz Dongle
-        {
-            15, // technically until 255, but unusably slow after 15
-            1,
-            0,
-            100,
-            true,
-            2,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_SPATHA_X_USB_PID, // ROG Spatha X USB
-        {
-            15, // technically until 255, but unusably slow after 15
-            1,
-            0,
-            100,
-            false,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_SPATHA_X_2_4_PID, // ROG Spatha X 2.4GHz Dock
-        {
-            15, // technically until 255, but unusably slow after 15
-            1,
-            0,
-            100,
-            true,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
     {
         AURA_ROG_PUGIO_PID, // ROG Pugio
         {
@@ -373,9 +299,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             4,
             false,
-            4,
+            3,
             { AURA_MOUSE_ZONE_LOGO },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM }
         }
     },
     {
@@ -529,22 +455,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             4,
             false,
-            3,
+            2,
             { AURA_MOUSE_ZONE_LOGO },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
     },
-    {
-        AURA_ROG_SPATHA_X_DOCK_FAKE_PID, // Asus ROG Spatha X Dock (only in wireless mode)
-        {
-            0,
-            0,
-            0,
-            100,
-            false,
-            1,
-            { AURA_MOUSE_ZONE_DOCK },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
 };

Controllers/AsusAuraUSBController/AsusAuraMousematController.cpp

@@ -55,8 +55,8 @@ std::string AuraMousematController::GetVersion()
     unsigned char usb_buf_out[65];
     hid_read(dev, usb_buf_out, 65);
 
-    char version[9];
-    snprintf(version, 9, "%X.%02X.%02X", usb_buf_out[6], usb_buf_out[7], usb_buf_out[8]);
+    char version[5];
+    snprintf(version, 5, "%04X", (usb_buf_out[6] << 8) | usb_buf_out[7]);
     return std::string(version);
 }
 
@@ -116,7 +116,7 @@ void AuraMousematController::UpdateDevice
         usb_buf[0x0b + i * 3]   = RGBGetGValue(colors[i]);
         usb_buf[0x0c + i * 3]   = RGBGetBValue(colors[i]);
     }
-
+    
     hid_write(dev, usb_buf, 65);
 }
 
@@ -128,7 +128,7 @@ void AuraMousematController::SaveMode()
 
     usb_save_buf[0x00]   = 0xEE;
     usb_save_buf[0x01]   = 0x50;
-    usb_save_buf[0x02]   = 0x03;
+    usb_save_buf[0x02]   = 0x55;
 
     hid_write(dev, usb_save_buf, 65);
 }

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

@@ -17,14 +17,11 @@
 #include <string.h>
 #include <cmath>
 
-AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version)
+AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid)
 {
     dev         = dev_handle;
     location    = path;
     device_pid  = pid;
-    rev_version = version;
-
-    is_per_led_keyboard = (pid != AURA_TUF_K1_GAMING_PID && pid != AURA_TUF_K5_GAMING_PID);
 }
 
 AuraTUFKeyboardController::~AuraTUFKeyboardController()
@@ -37,26 +34,6 @@ std::string AuraTUFKeyboardController::GetDeviceLocation()
     return("HID: " + location);
 }
 
-std::string clean_serial(const std::wstring& wstr)
-{
-    // Skip non-ASCII, trailing garbage in serial numbers. Required by the
-    // Scope II 96, whose original firmware outputs garbage, which even differs
-    // after computer reboots and therefore breaks OpenRGB profile matching.
-    std::string result;
-    for(auto c : wstr)
-    {
-        // Forbid control chars and anything above final printable low-ASCII.
-        if(c < 32 || c > 126)
-        {
-            break;
-        }
-
-        result += c;
-    }
-
-    return(result);
-}
-
 std::string AuraTUFKeyboardController::GetSerialString()
 {
     wchar_t serial_string[128];
@@ -67,166 +44,65 @@ std::string AuraTUFKeyboardController::GetSerialString()
         return("");
     }
 
-    std::wstring serial_wstring = serial_string;
-    std::string return_string = clean_serial(serial_wstring);
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
 
     return(return_string);
 }
 
 std::string AuraTUFKeyboardController::GetVersion()
-{
-    if(device_pid != AURA_ROG_CLAYMORE_PID)
-    {
-        unsigned char usb_buf[65];
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0x00]   = 0x00;
-        usb_buf[0x01]   = 0x12;
-        usb_buf[0x02]   = 0x00;
-
-        ClearResponses();
-
-        hid_write(dev, usb_buf, 65);
-
-        unsigned char usb_buf_out[65];
-        hid_read(dev, usb_buf_out, 65);
-
-        char version[9];
-        
-        switch(device_pid)
-        {
-            case AURA_TUF_K3_GAMING_PID:
-            case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
-            case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
-                snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
-                break;
-            default:
-                snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
-        }
-
-        return std::string(version);
-    }
-    else
-    {
-        unsigned char usb_buf[65];
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-        usb_buf[0x00]   = 0x00;
-        usb_buf[0x01]   = 0x10;
-        usb_buf[0x02]   = 0x01;
-        usb_buf[0x03]   = 0x00;
-        usb_buf[0x04]   = 0x00;
-        usb_buf[0x05]   = 0x00; // set to 1 to get firmware version of numpad
-
-        ClearResponses();
-        hid_write(dev, usb_buf, 65);
-        AwaitResponse(20);
-
-        unsigned char usb_buf1[65];
-        memset(usb_buf1, 0x00, sizeof(usb_buf1));
-        usb_buf1[0x00]   = 0x00;
-        usb_buf1[0x01]   = 0x12;
-        usb_buf1[0x02]   = 0x22;
-
-        ClearResponses();
-        hid_write(dev, usb_buf1, 65);
-
-        unsigned char usb_buf_out[65];
-        hid_read(dev, usb_buf_out, 65);
-
-        char version[9];
-        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[8], usb_buf_out[9], usb_buf_out[10]);
-
-        return std::string(version);
-    }
-}
-
-int AuraTUFKeyboardController::GetLayout()
-{
-    if(device_pid != AURA_ROG_CLAYMORE_PID)
-    {
-        unsigned char usb_buf[65];
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0x00]   = 0x00;
-        usb_buf[0x01]   = 0x12;
-        usb_buf[0x02]   = 0x12;
-
-        ClearResponses();
-        hid_write(dev, usb_buf, 65);
-
-        unsigned char usb_buf_out[65];
-        hid_read(dev, usb_buf_out, 65);
-
-        return(usb_buf_out[4] * 100 + usb_buf_out[5]);
-    }
-    else
-    {
-        switch(rev_version >> 0b1100)
-        {
-            case 1:
-                return 117;
-            case 2:
-                return 204;
-            case 3:
-                return 221;
-            case 4:
-                return 117;
-            default:
-                return 117;
-        }
-    }
-}
-
-/*---------------------------------------------------------*\
-| only needed for Claymore                                  |
-\*---------------------------------------------------------*/
-int AuraTUFKeyboardController::GetNumpadLocation()
 {
     unsigned char usb_buf[65];
     memset(usb_buf, 0x00, sizeof(usb_buf));
-
     usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x40;
-    usb_buf[0x02]   = 0x60;
+    usb_buf[0x01]   = 0x12;
+    usb_buf[0x02]   = 0x00;
 
-    ClearResponses();
     hid_write(dev, usb_buf, 65);
 
     unsigned char usb_buf_out[65];
     hid_read(dev, usb_buf_out, 65);
 
-    return(usb_buf_out[5] * 2 + usb_buf_out[4]);
+    char version[9];
+    if (device_pid == AURA_TUF_K3_GAMING_PID)
+    {
+        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
+    }
+    else
+    {
+        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
+    }
+    
+    return std::string(version);
+}
+
+int AuraTUFKeyboardController::GetLayout()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x12;
+    usb_buf[0x02]   = 0x12;
+
+    hid_write(dev, usb_buf, 65);
+
+    unsigned char usb_buf_out[65];
+    hid_read(dev, usb_buf_out, 65);
+
+    return(usb_buf_out[4] * 100 + usb_buf_out[5]);
 }
 
 void AuraTUFKeyboardController::SaveMode()
 {
     unsigned char usb_save_buf[65];
+
     memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
 
     usb_save_buf[0x00]   = 0x00;
     usb_save_buf[0x01]   = 0x50;
     usb_save_buf[0x02]   = 0x55;
 
-    ClearResponses();
     hid_write(dev, usb_save_buf, 65);
-    AwaitResponse(60);
-}
-
-/*---------------------------------------------------------*\
-| only needed for Claymore                                  |
-\*---------------------------------------------------------*/
-void AuraTUFKeyboardController::AllowRemoteControl(unsigned char type)
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x41;
-    usb_buf[0x02]   = type;
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
 }
 
 void AuraTUFKeyboardController::UpdateSingleLed
@@ -241,10 +117,11 @@ void AuraTUFKeyboardController::UpdateSingleLed
     | Set up message packet for single LED                  |
     \*-----------------------------------------------------*/
     unsigned char usb_buf[65];
+
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     usb_buf[0] = 0x00;
-    usb_buf[1] = 0xC0;
+    usb_buf[1] = 0xc0;
     usb_buf[2] = 0x81;
     usb_buf[3] = 0x01;
     usb_buf[4] = 0x00;
@@ -252,306 +129,146 @@ void AuraTUFKeyboardController::UpdateSingleLed
     /*-----------------------------------------------------*\
     | Convert LED index                                     |
     \*-----------------------------------------------------*/
-    usb_buf[5] = led;
+    usb_buf[5] = floor(led/6)*8 + led%6;
     usb_buf[6] = red;
     usb_buf[7] = green;
     usb_buf[8] = blue;
 
-    ClearResponses();
     hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
 }
 
 void AuraTUFKeyboardController::UpdateLeds
     (
-    std::vector<led_color>    colors
+    std::vector<RGBColor>    colors
     )
 {
-    int packets = ceil((float) colors.size() / 15);
-
-    for(int i = 0; i < packets; i++)
+    /*-----------------------------------------------------*\
+    | Loop over every column (optimisation needed)          |
+    \*-----------------------------------------------------*/
+    for(unsigned int i = 0; i < 192; i += 16)
     {
-        unsigned char usb_buf[65];
+        unsigned char usb_buf[69];
+
         memset(usb_buf, 0x00, sizeof(usb_buf));
 
-        int remaining = colors.size() - i * 15;
-
-        int leds = (remaining > 0x0F) ? 0x0F : remaining;
-
         usb_buf[0] = 0x00;
-        usb_buf[1] = 0xC0;
+        usb_buf[1] = 0xc0;
         usb_buf[2] = 0x81;
-        usb_buf[3] = leds;
+        usb_buf[3] = (138 - i / 16 * 12);
         usb_buf[4] = 0x00;
 
-        for(int j = 0; j < leds; j++)
+        for(unsigned int n = 0; n < 6; n++)
         {
-            usb_buf[j * 4 + 5] = (is_per_led_keyboard) ? colors[i * 15 + j].value : 0x00;
-            usb_buf[j * 4 + 6] = RGBGetRValue(colors[i * 15 + j].color);
-            usb_buf[j * 4 + 7] = RGBGetGValue(colors[i * 15 + j].color);
-            usb_buf[j * 4 + 8] = RGBGetBValue(colors[i * 15 + j].color);
+            usb_buf[n * 4 + 5] = i + n;
+            usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n]);
+            usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n]);
+            usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n]);
         }
 
-        ClearResponses();
-        hid_write(dev, usb_buf, 65);
-        AwaitResponse(20);
+        for(unsigned int n = 6; n < 8; n++)
+        {
+            usb_buf[n * 4 + 5] = i + n;
+            usb_buf[n * 4 + 6] = 0;
+            usb_buf[n * 4 + 7] = 0;
+            usb_buf[n * 4 + 8] = 0;
+        }
+
+        if(i != 176)
+        {
+            for(unsigned int n = 8; n < 14; n++)
+            {
+                usb_buf[n * 4 + 5] = i + n;
+                usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n-2]);
+                usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n-2]);
+                usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n-2]);
+            }
+
+            for(unsigned int n = 14; n < 16; n++)
+            {
+                usb_buf[n * 4 + 5] = i + n;
+                usb_buf[n * 4 + 6] = 0;
+                usb_buf[n * 4 + 7] = 0;
+                usb_buf[n * 4 + 8] = 0;
+            }
+        }
+
+        hid_write(dev, usb_buf, 69);
     }
 }
 
-void AuraTUFKeyboardController::UpdateK1Wave
-    (
-    std::vector<RGBColor>   colors,
-    unsigned char           direction,
-    unsigned char           speed,
-    unsigned char           brightness
-    )
-{
-    unsigned char usb_buf[65];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x2C;
-    usb_buf[0x03]   = 0x03;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = speed;
-    usb_buf[0x06]   = brightness;
-    usb_buf[0x07]   = 0x00;
-    usb_buf[0x08]   = direction;
-    usb_buf[0x09]   = 0x00;
-
-    usb_buf[10] = 5;
-    usb_buf[11] = RGBGetRValue(colors[4]);
-    usb_buf[12] = RGBGetGValue(colors[4]);
-    usb_buf[13] = RGBGetBValue(colors[4]);
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-
-    for(unsigned int i = 0; i < 4; i ++)
-    {
-        usb_buf[10 + i * 4] = i + 1;
-        usb_buf[11 + i * 4] = RGBGetRValue(colors[i]);
-        usb_buf[12 + i * 4] = RGBGetGValue(colors[i]);
-        usb_buf[13 + i * 4] = RGBGetBValue(colors[i]);
-    }
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-}
-
 void AuraTUFKeyboardController::UpdateDevice
     (
     unsigned char           mode,
     std::vector<RGBColor>   colors,
-    unsigned char           direction,
+    unsigned char           dir,
     unsigned char           color_mode,
     unsigned char           speed,
     unsigned char           brightness
     )
 {
-    if(device_pid == AURA_TUF_K1_GAMING_PID && mode == AURA_KEYBOARD_MODE_WAVE)
-    {
-        return UpdateK1Wave(colors, direction, speed, brightness);
-    }
-
     unsigned char usb_buf[65];
+
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     usb_buf[0x00]   = 0x00;
     usb_buf[0x01]   = 0x51;
     usb_buf[0x02]   = 0x2C;
+    usb_buf[0x03]   = mode;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = brightness;
+    usb_buf[0x07]   = color_mode;
+    usb_buf[0x08]   = dir;
+    usb_buf[0x09]   = 0x02;
 
-    if(device_pid != AURA_ROG_CLAYMORE_PID)
+    if(mode == 4 || mode == 5)
     {
-        usb_buf[0x03]   = mode;
-        usb_buf[0x04]   = 0x00;
-        usb_buf[0x05]   = speed;
-        usb_buf[0x06]   = brightness;
-        usb_buf[0x07]   = color_mode;
-        usb_buf[0x08]   = direction;
+        /*-----------------------------------------------------*\
+        | If mode is Rainbow or Ripple                          |
+        \*-----------------------------------------------------*/
+        usb_buf[0x0A]   = colors.size();
 
-        if(is_per_led_keyboard)
+        /*-----------------------------------------------------*\
+        | Loop over every color given                           |
+        \*-----------------------------------------------------*/
+        for(unsigned int i = 0; i / 4 < colors.size(); i += 4)
         {
-            usb_buf[0x09]   = 0x02;
-
-            if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
+            if(colors[i / 4])
             {
-                usb_buf[0x0A]   = colors.size();
-
-                /*-----------------------------------------------------*\
-                | Loop over every color given                           |
-                \*-----------------------------------------------------*/
-                for(unsigned int i = 0; i < colors.size(); i ++)
-                {
-                    if(colors[i])
-                    {
-                        usb_buf[11 + i * 4] = 100/(double)colors.size()*(i+1);
-                        usb_buf[12 + i * 4] = RGBGetRValue(colors[i]);
-                        usb_buf[13 + i * 4] = RGBGetGValue(colors[i]);
-                        usb_buf[14 + i * 4] = RGBGetBValue(colors[i]);
-                    }
-                }
-            }
-            else
-            {
-                /*-----------------------------------------------------*\
-                | Loop over Color1, Color2 and Background if there      |
-                \*-----------------------------------------------------*/
-                for(unsigned int i = 0; i != colors.size(); i++)
-                {
-                    if(colors[i])
-                    {
-                        usb_buf[10 + i * 3] = RGBGetRValue(colors[i]);
-                        usb_buf[11 + i * 3] = RGBGetGValue(colors[i]);
-                        usb_buf[12 + i * 3] = RGBGetBValue(colors[i]);
-                    }
-                }
-                    
-            }
-        }
-        else
-        {
-            /*-----------------------------------------------------------------*\
-            | Only handles K5 Rainbow.                                          |
-            | K1 is filtered out earlier and is executed in `UpdateK1Wave()`    |
-            \*-----------------------------------------------------------------*/
-            if(mode == AURA_KEYBOARD_MODE_WAVE)
-            {
-                usb_buf[0x09]   = 0x05;
-
-                for(unsigned int i = 0; i < 5; i ++)
-                {
-                    usb_buf[10 + i * 4] = i + 1;
-                    usb_buf[11 + i * 4] = RGBGetRValue(colors[i]);
-                    usb_buf[12 + i * 4] = RGBGetGValue(colors[i]);
-                    usb_buf[13 + i * 4] = RGBGetBValue(colors[i]);
-                }
-            }
-            else
-            {
-                /*-----------------------------------------------------*\
-                | Loop over Color1, Color2 and Background if there      |
-                \*-----------------------------------------------------*/
-                for(unsigned int i = 0; i != colors.size(); i++)
-                {
-                    if(colors[i])
-                    {
-                        usb_buf[ 9 + i * 3] = RGBGetRValue(colors[i]);
-                        usb_buf[10 + i * 3] = RGBGetGValue(colors[i]);
-                        usb_buf[11 + i * 3] = RGBGetBValue(colors[i]);
-                    }
-                }
+                usb_buf[11 + i] = 100/(double)colors.size()*(i/4+1);
+                usb_buf[12 + i] = RGBGetRValue(colors[i/4]);
+                usb_buf[13 + i] = RGBGetGValue(colors[i/4]);
+                usb_buf[14 + i] = RGBGetBValue(colors[i/4]);
             }
         }
     }
     else
     {
-        usb_buf[0x03]   = 0x00;
-        usb_buf[0x04]   = 0x00;
-        usb_buf[0x05]   = mode;
-        usb_buf[0x06]   = speed;
-
-        bool random     = (color_mode == 1);
-        bool pattern    = (color_mode == 2);
-
-        usb_buf[0x07]   = random * 128 + pattern * 32 + direction;
-        usb_buf[0x08]   = 0xFF; // "byteExt1" unknown usage
-        usb_buf[0x09]   = 0xFF; // "byteExt2" unknown usage
-        usb_buf[0x0A]   = (mode == 2) ? 0x80 : 0xFF; // "Lightness" (not Brightness)
-
-        if(mode == 7)
+        /*-----------------------------------------------------*\
+        | Loop over Color1, Color2 and Background if there      |
+        \*-----------------------------------------------------*/
+        for(unsigned int i = 0; i / 3 != colors.size(); i += 3)
         {
-            UpdateQuicksandColors(colors);
-        }
-        else
-        {
-            if(mode == 4 && color_mode == 0)
+            if(colors[i / 3])
             {
-                usb_buf[11] = 0xFF;
-                usb_buf[12] = 0xFF;
-                usb_buf[13] = 0xFF;
-            }
-
-            for(unsigned int i = 0; i < colors.size(); i ++)
-            {
-                if(colors[i])
-                {
-                    usb_buf[11 + i * 3] = RGBGetRValue(colors[i]);
-                    usb_buf[12 + i * 3] = RGBGetGValue(colors[i]);
-                    usb_buf[13 + i * 3] = RGBGetBValue(colors[i]);
-                }
+                usb_buf[10 + i] = RGBGetRValue(colors[i/3]);
+                usb_buf[11 + i] = RGBGetGValue(colors[i/3]);
+                usb_buf[12 + i] = RGBGetBValue(colors[i/3]);
             }
         }
-
-        for(int i = 1; i < 5; i++)
-        {
-            usb_buf[5 + i * 12] = 0xFF;
-        }
+            
     }
 
-    ClearResponses();
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
 }
 
-/*---------------------------------------------------------*\
-| only needed for Claymore                                  |
-\*---------------------------------------------------------*/
-void AuraTUFKeyboardController::UpdateQuicksandColors
-    (
-    std::vector<RGBColor>   colors
-    )
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x91;
-
-    for(unsigned int i = 0; i < 6; i++)
-    {
-        if(colors[i])
-        {
-            usb_buf[5 + i * 3] = RGBGetRValue(colors[i]);
-            usb_buf[6 + i * 3] = RGBGetGValue(colors[i]);
-            usb_buf[7 + i * 3] = RGBGetBValue(colors[i]);
-        }
-    }
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-}
-
-/*---------------------------------------------------------*\
-| only needed for Claymore                                  |
-\*---------------------------------------------------------*/
-void AuraTUFKeyboardController::UpdateMode(unsigned char mode)
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x28;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = mode;
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-}
-
-void AuraTUFKeyboardController::AwaitResponse(int ms)
+void AuraTUFKeyboardController::AwaitResponse()
 {
     unsigned char usb_buf_out[65];
-    hid_read_timeout(dev, usb_buf_out, 65, ms);
+    hid_read(dev, usb_buf_out, 65);
 }
 
 void AuraTUFKeyboardController::ClearResponses()
@@ -560,7 +277,7 @@ void AuraTUFKeyboardController::ClearResponses()
     unsigned char usb_buf_flush[65];
     while(result > 0)
     {
-        result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
+      result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
     }
 }
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h

@@ -16,6 +16,14 @@
 
 #pragma once
 
+enum
+{
+    AURA_KEYBOARD_ZONE_LOGO         = 0,
+    AURA_KEYBOARD_ZONE_SCROLL       = 1,
+    AURA_KEYBOARD_ZONE_UNDERGLOW    = 2,
+    AURA_KEYBOARD_ZONE_ALL          = 3,
+};
+
 enum
 {
     AURA_KEYBOARD_MODE_STATIC       =  0,
@@ -33,41 +41,22 @@ enum
 
 enum
 {
-    AURA_ROG_STRIX_FLARE_PID                     = 0x1875,
-    AURA_ROG_STRIX_FLARE_PNK_LTD_PID             = 0x18CF,
-    AURA_ROG_STRIX_FLARE_COD_BO4_PID             = 0x18AF,
-    AURA_ROG_FALCHION_WIRED_PID                  = 0x193C,
-    AURA_ROG_FALCHION_WIRELESS_PID               = 0x193E,
-    AURA_ROG_STRIX_SCOPE_PID                     = 0x18F8,
-    AURA_ROG_STRIX_SCOPE_RX_PID                  = 0x1951,
-    AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID  = 0x1AAE,
-    AURA_ROG_STRIX_FLARE_II_ANIMATE_PID          = 0x19FC,
-    AURA_TUF_K1_GAMING_PID                       = 0x1945,
-    AURA_TUF_K3_GAMING_PID                       = 0x194B,
-    AURA_TUF_K5_GAMING_PID                       = 0x1899,
-    AURA_TUF_K7_GAMING_PID                       = 0x18AA,
-    AURA_ROG_CLAYMORE_PID                        = 0x184D,
+    AURA_TUF_K7_GAMING_PID          = 0x18AA,
+    AURA_TUF_K3_GAMING_PID          = 0x194B,
 };
 
-struct led_color
-{
-    unsigned int    value;
-    RGBColor        color;
-};
 
 class AuraTUFKeyboardController
 {
 public:
-    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version);
+    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid);
     ~AuraTUFKeyboardController();
 
     std::string GetDeviceLocation();
     std::string GetSerialString();
     std::string GetVersion();
     int         GetLayout();
-    int         GetNumpadLocation();
     void        SaveMode();
-    void        AllowRemoteControl(unsigned char type);
 
     void UpdateSingleLed
         (
@@ -79,37 +68,25 @@ public:
 
     void UpdateLeds
         (
-        std::vector<led_color>    colors
-        );
-
-    void UpdateK1Wave
-        (
-        std::vector<RGBColor>   colors,
-        unsigned char           direction,
-        unsigned char           speed,
-        unsigned char           brightness
+        std::vector<RGBColor>    colors
         );
 
     void UpdateDevice
         (
         unsigned char           mode,
         std::vector<RGBColor>   colors,
-        unsigned char           direction,
+        unsigned char           dir,
         unsigned char           color_mode,
         unsigned char           speed,
         unsigned char           brightness
         );
-    void UpdateQuicksandColors(std::vector<RGBColor> colors);
-    void UpdateMode(unsigned char mode);
-    void AwaitResponse(int ms);
+    void AwaitResponse();
     void ClearResponses();
 
     uint16_t                    device_pid;
-    bool                        is_per_led_keyboard;
 
 private:
     hid_device*                 dev;
     std::string                 location;
-    unsigned short              rev_version;
 };
 

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -6,7 +6,6 @@
 #include "AsusAuraMainboardController.h"
 #include "AsusAuraMouseController.h"
 #include "AsusAuraMousematController.h"
-#include "AsusROGAllyController.h"
 #include "AsusAuraStrixEvolveController.h"
 #include "AsusAuraMonitorController.h"
 #include "AsusAuraRyuoAIOController.h"
@@ -15,10 +14,8 @@
 #include "RGBController_AsusAuraHeadsetStand.h"
 #include "RGBController_AsusAuraKeyboard.h"
 #include "RGBController_AsusAuraTUFKeyboard.h"
-#include "RGBController_AsusAuraMainboard.h"
 #include "RGBController_AsusAuraMouse.h"
 #include "RGBController_AsusAuraMousemat.h"
-#include "RGBController_AsusROGAlly.h"
 #include "RGBController_ROGStrixLC_Controller.h"
 #include "RGBController_AsusAuraStrixEvolve.h"
 #include "RGBController_AsusAuraMonitor.h"
@@ -27,82 +24,75 @@
 #include <hidapi/hidapi.h>
 #include "dependencies/dmiinfo.h"
 
-#define AURA_USB_VID                                  0x0B05
+#define AURA_USB_VID                            0x0B05
 
 /*-----------------------------------------------------------------*\
 |  MOTHERBOARDS                                                     |
 \*-----------------------------------------------------------------*/
-#define AURA_ADDRESSABLE_1_PID                        0x1867
-#define AURA_ADDRESSABLE_2_PID                        0x1872
-#define AURA_ADDRESSABLE_3_PID                        0x18A3
-#define AURA_ADDRESSABLE_4_PID                        0x18A5
-#define AURA_MOTHERBOARD_1_PID                        0x18F3
-#define AURA_MOTHERBOARD_2_PID                        0x1939
-#define AURA_MOTHERBOARD_3_PID                        0x19AF
+#define AURA_ADDRESSABLE_1_PID                  0x1867
+#define AURA_ADDRESSABLE_2_PID                  0x1872
+#define AURA_ADDRESSABLE_3_PID                  0x18A3
+#define AURA_ADDRESSABLE_4_PID                  0x18A5
+#define AURA_MOTHERBOARD_1_PID                  0x18F3
+#define AURA_MOTHERBOARD_2_PID                  0x1939
+#define AURA_MOTHERBOARD_3_PID                  0x19AF
 
 /*-----------------------------------------------------------------*\
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
-#define AURA_ROG_FALCHION_WIRED_PID                   0x193C
-#define AURA_ROG_FALCHION_WIRELESS_PID                0x193E
-#define AURA_ROG_STRIX_FLARE_PID                      0x1875
-#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID              0x18CF
-#define AURA_ROG_STRIX_FLARE_COD_BO4_PID              0x18AF
-#define AURA_ROG_STRIX_FLARE_II_ANIMATE_PID           0x19FC
-#define AURA_ROG_STRIX_SCOPE_PID                      0x18F8
-#define AURA_ROG_STRIX_SCOPE_RX_PID                   0x1951
-#define AURA_ROG_STRIX_SCOPE_TKL_PID                  0x190C
-#define AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID        0x1A05
-#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID          0x1954
-#define AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID   0x1AAE
-#define AURA_ROG_CLAYMORE_PID                         0x184D
-#define AURA_TUF_K1_GAMING_PID                        0x1945
-#define AURA_TUF_K3_GAMING_PID                        0x194B
-#define AURA_TUF_K5_GAMING_PID                        0x1899
-#define AURA_TUF_K7_GAMING_PID                        0x18AA
+#define AURA_ROG_FALCHION_WIRED_PID             0x193C
+#define AURA_ROG_FALCHION_WIRELESS_PID          0x193E
+#define AURA_ROG_STRIX_FLARE_PID                0x1875
+#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID        0x18CF
+#define AURA_ROG_STRIX_SCOPE_PID                0x18F8
+#define AURA_ROG_STRIX_SCOPE_RX_PID             0x1951
+#define AURA_ROG_STRIX_SCOPE_TKL_PID            0x190C
+#define AURA_TUF_K7_GAMING_PID                  0x18AA
+#define AURA_TUF_K3_GAMING_PID                  0x194B
 
 /*-----------------------------------------------------------------*\
 |  MICE - defined in AsusAuraMouseDevices.h                         |
 \*-----------------------------------------------------------------*/
 
-#define AURA_ROG_STRIX_EVOLVE_PID                     0x185B
+#define AURA_ROG_STRIX_EVOLVE_PID               0x185B
 
 /*-----------------------------------------------------------------*\
 | MOUSEMATS                                                         |
 \*-----------------------------------------------------------------*/
-#define AURA_ROG_BALTEUS_PID                          0x1891
-#define AURA_ROG_BALTEUS_QI_PID                       0x1890
+#define AURA_ROG_BALTEUS_PID                    0x1891
+#define AURA_ROG_BALTEUS_QI_PID                 0x1890
 
 /*-----------------------------------------------------------------*\
 | MONITORS                                                          |
 \*-----------------------------------------------------------------*/
 
-#define AURA_ROG_STRIX_XG27AQ_PID                     0x198C
-#define AURA_ROG_STRIX_XG27AQM_PID                    0x19BB
-#define AURA_ROG_STRIX_XG279Q_PID                     0x1919
-#define AURA_ROG_STRIX_XG27W_PID                      0x1933
-#define AURA_ROG_PG32UQ_PID                           0x19B9
+#define AURA_ROG_STRIX_XG27AQ_PID               0x198C
+#define AURA_ROG_STRIX_XG27W_PID                0x1933
+#define AURA_ROG_PG32UQ_PID                     0x19B9
 
 /*-----------------------------------------------------------------*\
 | HEADSETSTANDS                                                     |
 \*-----------------------------------------------------------------*/
 
-#define AURA_ROG_THRONE_PID                           0x18D9
-#define AURA_ROG_THRONE_QI_PID                        0x18C5
-#define AURA_ROG_THRONE_QI_GUNDAM_PID                 0x1994
+#define AURA_ROG_THRONE_PID                     0x18D9
+#define AURA_ROG_THRONE_QI_PID                  0x18C5
+#define AURA_ROG_THRONE_QI_GUNDAM_PID           0x1994
 
 /*-----------------------------------------------------------------*\
 |  OTHER                                                            |
 \*-----------------------------------------------------------------*/
-#define AURA_TERMINAL_PID                             0x1889
-#define ROG_STRIX_LC120_PID                           0x879E
-#define AURA_RYUO_AIO_PID                             0x1887
-#define ASUS_ROG_ALLY_PID                             0x1ABE
+#define AURA_TERMINAL_PID                       0x1889
+#define ROG_STRIX_LC120_PID                     0x879E
+#define AURA_RYUO_AIO_PID                       0x1887
 
 AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
 {
     switch(pid)
     {
+        case AURA_ROG_STRIX_FLARE_PID:
+        case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
+            return FLARE_LAYOUT;
+
         case AURA_ROG_STRIX_SCOPE_PID:
             return SCOPE_LAYOUT;
 
@@ -110,10 +100,12 @@ AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
             return SCOPE_RX_LAYOUT;
 
         case AURA_ROG_STRIX_SCOPE_TKL_PID:
-        case AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID:
-        case AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID:
             return SCOPE_TKL_LAYOUT;
 
+        case AURA_ROG_FALCHION_WIRED_PID:
+        case AURA_ROG_FALCHION_WIRELESS_PID:
+            return FALCHION_LAYOUT;
+
         default:
             return FLARE_LAYOUT;
     }
@@ -156,7 +148,7 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*n
         {
             DMIInfo dmi;
             AuraMainboardController* controller             = new AuraMainboardController(dev, info->path);
-            RGBController_AuraMainboard*   rgb_controller   = new RGBController_AuraMainboard(controller);
+            RGBController_AuraUSB*   rgb_controller         = new RGBController_AuraUSB(controller);
             rgb_controller->name                            = "ASUS " + dmi.getMainboard();
             ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
@@ -188,8 +180,7 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        uint16_t pid = (name == "Asus ROG Spatha X Dock") ? AURA_ROG_SPATHA_X_DOCK_FAKE_PID : info->product_id;
-        AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, pid);
+        AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, info->product_id);
         RGBController_AuraMouse* rgb_controller             = new RGBController_AuraMouse(controller);
         rgb_controller->name                                = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -267,7 +258,7 @@ void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name
 
     if(dev)
     {
-        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number);
+        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id);
         RGBController_AuraTUFKeyboard* rgb_controller       = new RGBController_AuraTUFKeyboard(controller);
         rgb_controller->name                                = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -287,19 +278,6 @@ void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
     }
 }
 
-void DetectAsusROGAlly(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        ROGAllyController*         controller           = new ROGAllyController(dev, info->path);
-        RGBController_AsusROGAlly* rgb_controller       = new RGBController_AsusROGAlly(controller);
-        rgb_controller->name                            = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
 /*-----------------------------------------------------------------*\
 |  MOTHERBOARDS                                                     |
 \*-----------------------------------------------------------------*/
@@ -314,23 +292,15 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAs
 /*-----------------------------------------------------------------*\
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",                   DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,                  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,               1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                     1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,             1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                     1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",                     DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,                  1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",                    DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX TKL Wireless Deluxe", DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID,       1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL PNK LTD",            DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID,         1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Claymore",                           DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_CLAYMORE_PID,                        1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                        DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                     1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,             1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare CoD Black Ops 4 Edition",DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_COD_BO4_PID,             1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",                   DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,                  1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",                DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,               1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare II Animate",             DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_ANIMATE_PID,          1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K1",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K1_GAMING_PID,                       2,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                       1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K5",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K5_GAMING_PID,                       2,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                        DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                     1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",                     DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,                  1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                       1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II 96 Wireless USB",     DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID,  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                       1,  0xFF00);
 
 /*-----------------------------------------------------------------*\
 |  MICE                                                             |
@@ -342,22 +312,16 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",          DetectAs
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,           2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,           1,  0xFF13);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,           2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III",                        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_PID,                     0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID,        0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID,        0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth",     DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID,         0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,                0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,                 0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID,                    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X USB",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_X_USB_PID,                   0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X 2.4GHz",                   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_X_2_4_PID,                   0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X USB",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_SPATHA_X_USB_PID,                    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X 2.4GHz",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_SPATHA_X_2_4_PID,                    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X Dock",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_SPATHA_X_DOCK_PID,                   0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_PID,                           2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",                   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,                  0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,               0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID,                    2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID,                    0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID,                 0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Gundam",             DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID,          0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Electro Punk",       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PUNK_PID,            0,  0xFF01);
@@ -383,8 +347,6 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi",                         DetectAs
 | MONITORS                                                          |
 \*-----------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQ",                       DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27AQ_PID,                    0xFFA0, 1);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQM",                      DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27AQM_PID,                   0xFFA0, 1);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG279Q",                       DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG279Q_PID,                    0xFFA0, 1);
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27W",                        DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27W_PID,                     0xFFA0, 1);
 REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ",                             DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_PG32UQ_PID,                          0xFFA0, 1);
 
@@ -397,4 +359,3 @@ REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryuo AIO",                          DetectAs
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne",                            DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_PID,                          0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI",                         DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID,                       0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI GUNDAM",                  DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID,                0);
-REGISTER_HID_DETECTOR_IPU("ASUS ROG Ally",                              DetectAsusROGAlly,              AURA_USB_VID, ASUS_ROG_ALLY_PID,                            2,  0xFF31, 0x0076);

Controllers/AsusAuraUSBController/AsusROGAllyController.cpp

@@ -1,127 +0,0 @@
-/*-----------------------------------------*\
-|  AsusROGAllyController.cpp                |
-|                                           |
-|  Driver for ASUS ROG Ally lighting        |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/12/2023   |
-\*-----------------------------------------*/
-
-#include "AsusROGAllyController.h"
-#include <cstring>
-
-ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-ROGAllyController::~ROGAllyController()
-{
-    hid_close(dev);
-}
-
-std::string ROGAllyController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string ROGAllyController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-std::string ROGAllyController::GetVersion()
-{
-    return("");
-}
-
-void ROGAllyController::UpdateLeds
-    (
-    std::vector<RGBColor>    colors
-    )
-{
-    unsigned char usb_buf[64];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x5A;
-    usb_buf[0x01]   = 0xD1;
-    usb_buf[0x02]   = 0x08;
-    usb_buf[0x03]   = 0x0C;
-
-    for(unsigned int color_idx = 0; color_idx < colors.size(); color_idx++)
-    {
-        usb_buf[color_idx * 3 + 4]  = RGBGetRValue(colors[color_idx]);
-        usb_buf[color_idx * 3 + 5]  = RGBGetGValue(colors[color_idx]);
-        usb_buf[color_idx * 3 + 6]  = RGBGetBValue(colors[color_idx]);
-    }
-
-    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
-}
-
-void ROGAllyController::UpdateDevice
-    (
-    unsigned char           mode,
-    std::vector<RGBColor>   colors,
-    unsigned char           speed,
-    unsigned char           /*brightness*/,
-    unsigned char           direction
-    )
-{
-    unsigned char usb_buf[64];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x5A;
-    usb_buf[0x01]   = 0xB3;
-    usb_buf[0x02]   = 0x00;
-    usb_buf[0x03]   = mode;
-    if(colors.size() > 0)
-    {
-        usb_buf[0x04]   = RGBGetRValue(colors[0]);
-        usb_buf[0x05]   = RGBGetGValue(colors[0]);
-        usb_buf[0x06]   = RGBGetBValue(colors[0]);
-    }
-    usb_buf[0x07]   = speed;
-    usb_buf[0x08]   = direction;
-    if(colors.size() > 1)
-    {
-        usb_buf[0x0A]   = RGBGetRValue(colors[1]);
-        usb_buf[0x0B]   = RGBGetGValue(colors[1]);
-        usb_buf[0x0C]   = RGBGetBValue(colors[1]);
-    }
-
-    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x5A;
-    usb_buf[0x01]   = 0xB5;
-
-    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
-}
-
-void ROGAllyController::SaveMode()
-{
-    unsigned char usb_buf[64];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x5A;
-    usb_buf[0x01]   = 0xB4;
-
-    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
-}
-

Controllers/AsusAuraUSBController/AsusROGAllyController.h

@@ -1,67 +0,0 @@
-/*-----------------------------------------*\
-|  AsusROGAllyController.h                  |
-|                                           |
-|  Definitions and types for ASUS ROG Ally  |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/12/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    ROG_ALLY_MODE_STATIC           = 0,
-    ROG_ALLY_MODE_BREATHING        = 1,
-    ROG_ALLY_MODE_COLOR_CYCLE      = 2,
-    ROG_ALLY_MODE_RAINBOW          = 3,
-    ROG_ALLY_MODE_STROBING         = 10,
-    ROG_ALLY_MODE_DIRECT           = 0xFF,
-};
-
-enum
-{
-    ROG_ALLY_SPEED_MIN              = 0xE1,
-    ROG_ALLY_SPEED_MED              = 0xEB,
-    ROG_ALLY_SPEED_MAX              = 0xF5
-};
-
-enum
-{
-    ROG_ALLY_DIRECTION_RIGHT        = 0x00,
-    ROG_ALLY_DIRECTION_LEFT         = 0x01
-};
-
-class ROGAllyController
-{
-public:
-    ROGAllyController(hid_device* dev_handle, const char* path);
-    virtual ~ROGAllyController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-    std::string GetVersion();
-
-    void UpdateLeds
-        (
-            std::vector<RGBColor>    colors
-            );
-
-    void UpdateDevice
-        (
-            unsigned char           mode,
-            std::vector<RGBColor>   colors,
-            unsigned char           speed,
-            unsigned char           brightness,
-            unsigned char           direction
-            );
-
-    void SaveMode();
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-};

Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp

@@ -44,7 +44,7 @@ static unsigned int falchion_matrix_map[5][16] =
       {   3,  NA,  12,  17,  21,  25,  29,  34,  38,  42,  47,  52,  56,  NA,  61,  66 },
       {   4,   8,  13,  NA,  NA,  NA,  30,  NA,  NA,  NA,  43,  48,  53,  57,  62,  67 } };
 
-static const std::vector<aura_keyboard_led> default_led_names =
+static const std::vector<led_type> default_led_names =
 {
     /* Key Label                Index  */
     { KEY_EN_ESCAPE,            0x00    },
@@ -153,7 +153,7 @@ static const std::vector<aura_keyboard_led> default_led_names =
     { KEY_EN_NUMPAD_ENTER,      0xB4    },
 };
 
-static const std::vector<aura_keyboard_led> default_tkl_led_names =
+static const std::vector<led_type> default_tkl_led_names =
 {
     /* Key Label                Index  */
     { KEY_EN_ESCAPE,            0x00    },
@@ -270,7 +270,7 @@ static const std::vector<aura_keyboard_led> default_tkl_led_names =
     { "Underglow 26",           0xCE    },
 };
 
-static const std::vector<aura_keyboard_led> default_65pct_led_names =
+static const std::vector<led_type> default_65pct_led_names =
 {
     /* Key Label                Index  */
     { KEY_EN_ESCAPE,            0x00    },
@@ -395,7 +395,7 @@ void RGBController_AuraKeyboard::SetupZones()
     | Set up zones                                              |
     \*---------------------------------------------------------*/
     std::vector<led_zone> led_zones;
-    std::vector<aura_keyboard_led> led_names;
+    std::vector<led_type> led_names;
 
     switch(layout)
     {

Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.h

@@ -24,7 +24,7 @@ typedef struct
 {
     const char*         name;
     unsigned char       idx;
-} aura_keyboard_led;
+} led_type;
 
 typedef struct
 {

Controllers/AsusAuraUSBController/RGBController_AsusAuraMainboard.cpp

@@ -1,78 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMainboard.cpp      |
-|                                           |
-|  RGB controller for Asus Aura USB         |
-|  mainboards                               |
-|                                           |
-|  rytypete 8/30/2023                       |
-|  based on RGBController_AsusAuraUSB.cpp   |
-|  code                                     |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraMainboard.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus Aura USB Mainboard
-    @category Motherboard
-    @type USB
-    @save :white_check_mark:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBMotherboards
-    @comment The Asus Aura USB Mainboard controller applies to most
-        AMD and Intel mainboards from the x570 chipset onwards.
-\*-------------------------------------------------------------------*/
-
-RGBController_AuraMainboard::RGBController_AuraMainboard(AuraMainboardController* controller_ptr) :
-    RGBController_AuraUSB(controller_ptr)
-{
-    name        = "ASUS Aura USB Mainboard";
-    description = "ASUS Aura USB Mainboard Device";
-
-    /*-------------------------------------------------------*\
-    | Add manual save flag to all modes except direct mode    |
-    \*-------------------------------------------------------*/
-    for(unsigned int mode_idx = 0; mode_idx < modes.size(); mode_idx++)
-    {
-        mode Mode = modes[mode_idx];
-        if(Mode.value != AURA_MODE_DIRECT)
-        {
-            Mode.flags |= MODE_FLAG_MANUAL_SAVE;
-            modes[mode_idx] = Mode;
-        }
-    }
-}
-
-void RGBController_AuraMainboard::DeviceUpdateShutdownEffect()
-{
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
-
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        red = RGBGetRValue(modes[active_mode].colors[0]);
-        grn = RGBGetGValue(modes[active_mode].colors[0]);
-        blu = RGBGetBValue(modes[active_mode].colors[0]);
-    }
-
-    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx];
-
-        /*---------------------------------------------------*\
-        | Shutdown effect only works with onboard lighting    |
-        \*---------------------------------------------------*/
-        if(device_info.device_type == AuraDeviceType::FIXED && zones[zone_idx].leds_count > 0)
-        {
-            ((AuraMainboardController*) controller)->SetMode(zone_idx, modes[active_mode].value, red, grn, blu, true);
-        }
-    }
-}
-
-void RGBController_AuraMainboard::DeviceSaveMode()
-{
-    DeviceUpdateMode();
-    DeviceUpdateShutdownEffect();
-    ((AuraMainboardController*) controller)->SendCommit();
-}

Controllers/AsusAuraUSBController/RGBController_AsusAuraMainboard.h

@@ -1,25 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMainboard.h        |
-|                                           |
-|  RGB controller for Asus Aura USB         |
-|  mainboards                               |
-|                                           |
-|  rytypete 8/30/2023                       |
-|  based on RGBController_AsusAuraUSB.h     |
-|  code                                     |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController_AsusAuraUSB.h"
-#include "AsusAuraMainboardController.h"
-
-class RGBController_AuraMainboard : public RGBController_AuraUSB
-{
-public:
-    RGBController_AuraMainboard(AuraMainboardController* controller_ptr);
-
-    void        DeviceSaveMode();
-
-private:
-    void        DeviceUpdateShutdownEffect();
-};

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

@@ -9,13 +9,11 @@
 
 #include "RGBController_AsusAuraMouse.h"
 
-static std::string aura_mouse_zone_names[5]
+static std::string aura_mouse_zone_names[3]
 {
     "Logo",
     "Scroll Wheel",
-    "Underglow",
-    "All",
-    "Dock"
+    "Underglow"
 };
 
 /**------------------------------------------------------------------*\
@@ -31,9 +29,9 @@ static std::string aura_mouse_zone_names[5]
 
 RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller_ptr)
 {
-    controller = controller_ptr;
+    controller              = controller_ptr;
 
-    pid = controller->device_pid;
+    uint16_t pid            = controller->device_pid;
 
     name                    = "ASUS Aura Mouse";
     vendor                  = "ASUS";
@@ -170,6 +168,8 @@ RGBController_AuraMouse::~RGBController_AuraMouse()
 
 void RGBController_AuraMouse::SetupZones()
 {
+    uint16_t pid                = controller->device_pid;
+
     for(std::vector<uint8_t>::iterator zone_it = aura_mouse_devices[pid].mouse_zones.begin(); zone_it != aura_mouse_devices[pid].mouse_zones.end(); zone_it++)
     {
         zone mouse_zone;
@@ -207,9 +207,9 @@ void RGBController_AuraMouse::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AuraMouse::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
 {
-    DeviceUpdateLEDs();
+    UpdateSingleLED(zone);
 }
 
 void RGBController_AuraMouse::UpdateSingleLED(int led)
@@ -240,22 +240,7 @@ void RGBController_AuraMouse::DeviceUpdateMode()
             blu = RGBGetBValue(modes[active_mode].colors[0]);
         }
 
-
-        if(pid == AURA_ROG_SPATHA_X_DOCK_FAKE_PID)
-        {
-            controller->SendUpdate(AURA_MOUSE_ZONE_DOCK, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
-        }
-        else if(pid == AURA_ROG_STRIX_IMPACT_PID)
-        {
-            /*-----------------------------------------------------------------*\
-            | The ROG Impact doesn't accept AURA_MOUSE_ZONE_ALL                 |
-            \*-----------------------------------------------------------------*/
-            controller->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
-        }
-        else
-        {
-            controller->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
-        }
+        controller->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
     }
 }
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.h

@@ -30,5 +30,4 @@ public:
 
 private:
     AuraMouseController*  controller;
-    uint16_t              pid;
 };

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -24,366 +24,178 @@
 
 RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr)
 {
-    controller = controller_ptr;
+    controller  = controller_ptr;
 
-    pid = controller->device_pid;
+    name        = "ASUS Aura Keyboard";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "ASUS Aura Keyboard Device";
+    version     = controller->GetVersion();
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
 
-    if(pid != AURA_ROG_CLAYMORE_PID)
-    {
-        name        = "ASUS Aura Keyboard";
-        vendor      = "ASUS";
-        type        = DEVICE_TYPE_KEYBOARD;
-        description = "ASUS Aura Keyboard Device";
-        version     = controller->GetVersion();
-        location    = controller->GetDeviceLocation();
-        serial      = controller->GetSerialString();
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
 
-        unsigned char AURA_KEYBOARD_SPEED_MIN     = 0;
-        unsigned char AURA_KEYBOARD_SPEED_MAX     = 0;
-        unsigned char AURA_KEYBOARD_SPEED_DEFAULT = 0;
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = AURA_KEYBOARD_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Static.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Static.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);
 
-        switch(pid)
-        {
-            case AURA_TUF_K1_GAMING_PID:
-                AURA_KEYBOARD_SPEED_MIN          = 0;
-                AURA_KEYBOARD_SPEED_MAX          = 2;
-                AURA_KEYBOARD_SPEED_DEFAULT      = 1;
-                break;
-            case AURA_ROG_STRIX_FLARE_PID:
-            case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
-            case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
-            case AURA_TUF_K3_GAMING_PID:
-            case AURA_TUF_K7_GAMING_PID:
-                AURA_KEYBOARD_SPEED_MIN          = 15;
-                AURA_KEYBOARD_SPEED_MAX          = 0;
-                AURA_KEYBOARD_SPEED_DEFAULT      = 8;
-                break;
-            case AURA_ROG_FALCHION_WIRED_PID:
-            case AURA_ROG_FALCHION_WIRELESS_PID:
-            case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
-            case AURA_ROG_STRIX_SCOPE_RX_PID:
-            case AURA_ROG_STRIX_SCOPE_PID:
-            case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
-            case AURA_TUF_K5_GAMING_PID:
-                AURA_KEYBOARD_SPEED_MIN          = 255;
-                AURA_KEYBOARD_SPEED_MAX          = 0;
-                AURA_KEYBOARD_SPEED_DEFAULT      = 30;
-                break;
-            default:
-                AURA_KEYBOARD_SPEED_MIN          = 15;
-                AURA_KEYBOARD_SPEED_MAX          = 0;
-                AURA_KEYBOARD_SPEED_DEFAULT      = 8;
-        }
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+    Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+    Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+    Breathing.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Breathing.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 2;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);
 
-        mode Direct;
-        Direct.name                 = "Direct";
-        Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
-        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode           = MODE_COLORS_PER_LED;
-        modes.push_back(Direct);
+    mode Color_Cycle;
+    Color_Cycle.name            = "Spectrum Cycle";
+    Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
+    Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Color_Cycle.speed_min       = AURA_KEYBOARD_SPEED_MIN;
+    Color_Cycle.speed_max       = AURA_KEYBOARD_SPEED_MAX;
+    Color_Cycle.speed           = AURA_KEYBOARD_SPEED_DEFAULT;
+    Color_Cycle.brightness_min  = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Color_Cycle.brightness_max  = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Color_Cycle.brightness      = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Color_Cycle.color_mode      = MODE_COLORS_NONE;
+    modes.push_back(Color_Cycle);
 
-        mode Static;
-        Static.name                 = "Static";
-        Static.value                = AURA_KEYBOARD_MODE_STATIC;
-        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Static.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Static.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Static.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Static.colors_min           = 1;
-        Static.colors_max           = 1;
-        Static.colors.resize(1);
-        modes.push_back(Static);
+    mode Wave;
+    Wave.name                   = "Rainbow Wave";
+    Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
+    Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
+    Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
+    Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
+    Wave.brightness_min         = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Wave.brightness_max         = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Wave.brightness             = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Wave.direction              = MODE_DIRECTION_LEFT;
+    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Wave.colors_min             = 1;
+    Wave.colors_max             = 7;
+    Wave.colors.resize(7);
+    modes.push_back(Wave);
 
-        mode Breathing;
-        Breathing.name              = "Breathing";
-        Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
-        Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        if(controller->is_per_led_keyboard) Breathing.flags |= MODE_FLAG_HAS_RANDOM_COLOR;
+    mode Ripple;
+    Ripple.name                 = "Ripple";
+    Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
+    Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Ripple.speed_min            = AURA_KEYBOARD_SPEED_MIN;
+    Ripple.speed_max            = AURA_KEYBOARD_SPEED_MAX;
+    Ripple.speed                = AURA_KEYBOARD_SPEED_DEFAULT;
+    Ripple.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Ripple.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Ripple.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Ripple.colors_min           = 1;
+    Ripple.colors_max           = 8;
+    Ripple.colors.resize(7);
+    modes.push_back(Ripple);
 
-        Breathing.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-        Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-        Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-        Breathing.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Breathing.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Breathing.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Breathing.colors_min        = 1;
-        Breathing.colors_max        = 2;
-        Breathing.colors.resize(1);
-        modes.push_back(Breathing);
+    mode Reactive;
+    Reactive.name               = "Reactive";
+    Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
+    Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Reactive.speed_min          = AURA_KEYBOARD_SPEED_MIN;
+    Reactive.speed_max          = AURA_KEYBOARD_SPEED_MAX;
+    Reactive.speed              = AURA_KEYBOARD_SPEED_DEFAULT;
+    Reactive.brightness_min     = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Reactive.brightness_max     = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Reactive.brightness         = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Reactive.colors_min         = 1;
+    Reactive.colors_max         = 2;
+    Reactive.colors.resize(1);
+    modes.push_back(Reactive);
 
-        mode Color_Cycle;
-        Color_Cycle.name            = "Spectrum Cycle";
-        Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
-        Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Color_Cycle.speed_min       = AURA_KEYBOARD_SPEED_MIN;
-        Color_Cycle.speed_max       = AURA_KEYBOARD_SPEED_MAX;
-        Color_Cycle.speed           = AURA_KEYBOARD_SPEED_DEFAULT;
-        Color_Cycle.brightness_min  = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Color_Cycle.brightness_max  = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Color_Cycle.brightness      = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Color_Cycle.color_mode      = MODE_COLORS_NONE;
-        modes.push_back(Color_Cycle);
+    mode Starry_Night;
+    Starry_Night.name           = "Starry Night";
+    Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
+    Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Starry_Night.speed_min      = AURA_KEYBOARD_SPEED_MIN;
+    Starry_Night.speed_max      = AURA_KEYBOARD_SPEED_MAX;
+    Starry_Night.speed          = AURA_KEYBOARD_SPEED_DEFAULT;
+    Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Starry_Night.brightness     = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Starry_Night.colors_min     = 1;
+    Starry_Night.colors_max     = 3;
+    Starry_Night.colors.resize(1);
+    modes.push_back(Starry_Night);
 
-        mode Wave;
-        Wave.name                   = "Rainbow Wave";
-        Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
-        Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        if(controller->is_per_led_keyboard) Wave.flags |= MODE_FLAG_HAS_DIRECTION_UD;
-        
-        Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
-        Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
-        Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
-        Wave.brightness_min         = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Wave.brightness_max         = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Wave.brightness             = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Wave.direction              = MODE_DIRECTION_LEFT;
-        Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    mode Quicksand;
+    Quicksand.name              = "Quicksand";
+    Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
+    Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Quicksand.direction         = MODE_DIRECTION_DOWN;
+    Quicksand.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+    Quicksand.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+    Quicksand.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+    Quicksand.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Quicksand.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Quicksand.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Quicksand.colors_min        = 6;
+    Quicksand.colors_max        = 6;
+    Quicksand.colors.resize(6);
+    modes.push_back(Quicksand);
 
-        if(!controller->is_per_led_keyboard)
-        {
-            Wave.colors_min             = 5;
-            Wave.colors_max             = 5;
-        }
-        else
-        {
-            Wave.colors_min             = 1;
-            Wave.colors_max             = 7;
-        }
+    mode Current;
+    Current.name                = "Current";
+    Current.value               = AURA_KEYBOARD_MODE_CURRENT;
+    Current.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Current.speed_min           = AURA_KEYBOARD_SPEED_MIN;
+    Current.speed_max           = AURA_KEYBOARD_SPEED_MAX;
+    Current.speed               = AURA_KEYBOARD_SPEED_DEFAULT;
+    Current.brightness_min      = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Current.brightness_max      = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Current.brightness          = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Current.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Current.colors_min          = 1;
+    Current.colors_max          = 3;
+    Current.colors.resize(1);
+    modes.push_back(Current);
 
-        Wave.colors.resize(Wave.colors_max);
-        modes.push_back(Wave);
-
-        if(controller->is_per_led_keyboard)
-        {
-            mode Reactive;
-            Reactive.name               = "Reactive";
-            Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
-            Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-            Reactive.speed_min          = AURA_KEYBOARD_SPEED_MIN;
-            Reactive.speed_max          = AURA_KEYBOARD_SPEED_MAX;
-            Reactive.speed              = AURA_KEYBOARD_SPEED_DEFAULT;
-            Reactive.brightness_min     = AURA_KEYBOARD_BRIGHTNESS_MIN;
-            Reactive.brightness_max     = AURA_KEYBOARD_BRIGHTNESS_MAX;
-            Reactive.brightness         = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-            Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-            Reactive.colors_min         = 1;
-            Reactive.colors_max         = 2;
-            Reactive.colors.resize(1);
-            modes.push_back(Reactive);
-
-            mode Ripple;
-            Ripple.name                 = "Ripple";
-            Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
-            Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-            Ripple.speed_min            = AURA_KEYBOARD_SPEED_MIN;
-            Ripple.speed_max            = AURA_KEYBOARD_SPEED_MAX;
-            Ripple.speed                = AURA_KEYBOARD_SPEED_DEFAULT;
-            Ripple.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
-            Ripple.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
-            Ripple.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-            Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-            Ripple.colors_min           = 1;
-            Ripple.colors_max           = 8;
-            Ripple.colors.resize(7);
-            modes.push_back(Ripple);
-
-            mode Starry_Night;
-            Starry_Night.name           = "Starry Night";
-            Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
-            Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-            Starry_Night.speed_min      = AURA_KEYBOARD_SPEED_MIN;
-            Starry_Night.speed_max      = AURA_KEYBOARD_SPEED_MAX;
-            Starry_Night.speed          = AURA_KEYBOARD_SPEED_DEFAULT;
-            Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
-            Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
-            Starry_Night.brightness     = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-            Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-            Starry_Night.colors_min     = 1;
-            Starry_Night.colors_max     = 3;
-            Starry_Night.colors.resize(1);
-            modes.push_back(Starry_Night);
-
-            mode Quicksand;
-            Quicksand.name              = "Quicksand";
-            Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
-            Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-            Quicksand.direction         = MODE_DIRECTION_DOWN;
-            Quicksand.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-            Quicksand.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-            Quicksand.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-            Quicksand.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-            Quicksand.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-            Quicksand.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-            Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-            Quicksand.colors_min        = 6;
-            Quicksand.colors_max        = 6;
-            Quicksand.colors.resize(6);
-            modes.push_back(Quicksand);
-
-            mode Current;
-            Current.name                = "Current";
-            Current.value               = AURA_KEYBOARD_MODE_CURRENT;
-            Current.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-            Current.speed_min           = AURA_KEYBOARD_SPEED_MIN;
-            Current.speed_max           = AURA_KEYBOARD_SPEED_MAX;
-            Current.speed               = AURA_KEYBOARD_SPEED_DEFAULT;
-            Current.brightness_min      = AURA_KEYBOARD_BRIGHTNESS_MIN;
-            Current.brightness_max      = AURA_KEYBOARD_BRIGHTNESS_MAX;
-            Current.brightness          = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-            Current.color_mode          = MODE_COLORS_MODE_SPECIFIC;
-            Current.colors_min          = 1;
-            Current.colors_max          = 3;
-            Current.colors.resize(1);
-            modes.push_back(Current);
-
-            mode Rain_Drop;
-            Rain_Drop.name              = "Rain Drop";
-            Rain_Drop.value             = AURA_KEYBOARD_MODE_RAIN_DROP;
-            Rain_Drop.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-            Rain_Drop.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-            Rain_Drop.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-            Rain_Drop.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-            Rain_Drop.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-            Rain_Drop.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-            Rain_Drop.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-            Rain_Drop.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-            Rain_Drop.colors_min        = 1;
-            Rain_Drop.colors_max        = 3;
-            Rain_Drop.colors.resize(1);
-            modes.push_back(Rain_Drop);
-        }
-    }
-    else
-    {
-
-        name        = "ASUS ROG Claymore";
-        vendor      = "ASUS";
-        type        = DEVICE_TYPE_KEYBOARD;
-        description = "ASUS Aura Keyboard Device";
-        version     = controller->GetVersion();
-        location    = controller->GetDeviceLocation();
-        serial      = controller->GetSerialString();
-
-        mode Direct;
-        Direct.name                 = "Direct";
-        Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
-        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode           = MODE_COLORS_PER_LED;
-        modes.push_back(Direct);
-
-        mode Static;
-        Static.name                 = "Static";
-        Static.value                = AURA_KEYBOARD_MODE_STATIC;
-        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Static.colors_min           = 1;
-        Static.colors_max           = 1;
-        Static.colors.resize(1);
-        modes.push_back(Static);
-
-        mode Breathing;
-        Breathing.name              = "Breathing";
-        Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
-        Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Breathing.speed_min         = AURA_CLAYMORE_SPEED_MIN;
-        Breathing.speed_max         = AURA_CLAYMORE_SPEED_MAX;
-        Breathing.speed             = AURA_CLAYMORE_SPEED_DEFAULT_BREATHING;
-        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Breathing.colors_min        = 1;
-        Breathing.colors_max        = 2;
-        Breathing.colors.resize(2);
-        modes.push_back(Breathing);
-
-        mode Color_Cycle;
-        Color_Cycle.name            = "Spectrum Cycle";
-        Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
-        Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Color_Cycle.speed_min       = AURA_CLAYMORE_SPEED_MIN;
-        Color_Cycle.speed_max       = AURA_CLAYMORE_SPEED_MAX;
-        Color_Cycle.speed           = AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE;
-        Color_Cycle.color_mode      = MODE_COLORS_NONE;
-        modes.push_back(Color_Cycle);
-
-        mode Reactive;
-        Reactive.name               = "Reactive";
-        Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
-        Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Reactive.speed_min          = AURA_CLAYMORE_SPEED_MIN;
-        Reactive.speed_max          = AURA_CLAYMORE_SPEED_MAX;
-        Reactive.speed              = AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE;
-        Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-        Reactive.colors_min         = 1;
-        Reactive.colors_max         = 2;
-        Reactive.colors.resize(2);
-        modes.push_back(Reactive);
-
-        mode Wave;
-        Wave.name                   = "Rainbow Wave";
-        Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
-        Wave.flags                  = MODE_COLORS_NONE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
-        Wave.speed_min              = AURA_CLAYMORE_SPEED_MIN;
-        Wave.speed_max              = AURA_CLAYMORE_SPEED_MAX;
-        Wave.speed                  = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
-        Wave.direction              = MODE_DIRECTION_LEFT;
-        Wave.color_mode             = MODE_COLORS_NONE;
-        modes.push_back(Wave);
-
-        mode Color_Wave;
-        Color_Wave.name             = "Color Wave";
-        Color_Wave.value            = AURA_KEYBOARD_MODE_WAVE;
-        Color_Wave.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
-        Color_Wave.speed_min        = AURA_CLAYMORE_SPEED_MIN;
-        Color_Wave.speed_max        = AURA_CLAYMORE_SPEED_MAX;
-        Color_Wave.speed            = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
-        Color_Wave.direction        = MODE_DIRECTION_LEFT;
-        Color_Wave.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Color_Wave.colors_min       = 1;
-        Color_Wave.colors_max       = 2;
-        Color_Wave.colors.resize(2);
-        modes.push_back(Color_Wave);
-
-        mode Ripple;
-        Ripple.name                 = "Ripple";
-        Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
-        Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Ripple.speed_min            = AURA_CLAYMORE_SPEED_MIN;
-        Ripple.speed_max            = AURA_CLAYMORE_SPEED_MAX;
-        Ripple.speed                = AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE;
-        Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Ripple.colors_min           = 1;
-        Ripple.colors_max           = 2;
-        Ripple.colors.resize(2);
-        modes.push_back(Ripple);
-
-        mode Starry_Night;
-        Starry_Night.name           = "Starry Night";
-        Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
-        Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Starry_Night.speed_min      = AURA_CLAYMORE_SPEED_MIN;
-        Starry_Night.speed_max      = AURA_CLAYMORE_SPEED_MAX;
-        Starry_Night.speed          = AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT;
-        Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-        Starry_Night.colors_min     = 1;
-        Starry_Night.colors_max     = 2;
-        Starry_Night.colors.resize(2);
-        modes.push_back(Starry_Night);
-
-        mode Quicksand;
-        Quicksand.name              = "Quicksand";
-        Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
-        Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Quicksand.direction         = MODE_DIRECTION_DOWN;
-        Quicksand.speed_min         = AURA_CLAYMORE_SPEED_MIN;
-        Quicksand.speed_max         = AURA_CLAYMORE_SPEED_MAX;
-        Quicksand.speed             = AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND;
-        Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Quicksand.colors_min        = 6;
-        Quicksand.colors_max        = 6;
-        Quicksand.colors.resize(6);
-        modes.push_back(Quicksand);
-    }
+    mode Rain_Drop;
+    Rain_Drop.name              = "Rain Drop";
+    Rain_Drop.value             = AURA_KEYBOARD_MODE_RAIN_DROP;
+    Rain_Drop.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Rain_Drop.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+    Rain_Drop.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+    Rain_Drop.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+    Rain_Drop.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Rain_Drop.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Rain_Drop.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Rain_Drop.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Rain_Drop.colors_min        = 1;
+    Rain_Drop.colors_max        = 3;
+    Rain_Drop.colors.resize(1);
+    modes.push_back(Rain_Drop);
 
     SetupZones();
 }
@@ -395,68 +207,10 @@ RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
 
 void RGBController_AuraTUFKeyboard::SetupZones()
 {
-    std::map<int,layout_info> * keyboard_ptr;
+    int layout = controller->GetLayout();
 
-    switch(pid)
+    if(AsusTUFK7Layouts.find(layout % 100) == AsusTUFK7Layouts.end())
     {
-        case AURA_ROG_STRIX_FLARE_PID:
-        case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
-        case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
-            keyboard_ptr = &AsusROGStrixFlareLayouts;
-            break;
-        case AURA_TUF_K3_GAMING_PID:
-        case AURA_TUF_K7_GAMING_PID:
-            keyboard_ptr = &AsusTUFK7Layouts;
-            break;
-        case AURA_ROG_STRIX_SCOPE_PID:
-        case AURA_ROG_STRIX_SCOPE_RX_PID:
-            keyboard_ptr = &AsusROGStrixScopeLayouts;
-            break;
-        case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
-            keyboard_ptr = &AsusROGStrixScopeII96WirelessLayouts;
-            break;
-        case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
-            keyboard_ptr = &AsusROGStrixFlareIILayouts;
-            break;
-        case AURA_ROG_FALCHION_WIRED_PID:
-        case AURA_ROG_FALCHION_WIRELESS_PID:
-            keyboard_ptr = &AsusFalchionLayouts;
-            break;
-        case AURA_ROG_CLAYMORE_PID:
-            unsigned char numpad;
-            numpad = controller->GetNumpadLocation();
-            switch(numpad)
-            {
-                case 0:
-                    keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
-                    break;
-                case 2:
-                    keyboard_ptr = &AsusClaymoreNumpadRightLayouts;
-                    break;
-                case 3:
-                    keyboard_ptr = &AsusClaymoreNumpadLeftLayouts;
-                    break;
-                default:
-                    keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
-            }
-            break;
-        case AURA_TUF_K1_GAMING_PID:
-        case AURA_TUF_K5_GAMING_PID:
-            keyboard_ptr = &AsusTufK1Layouts;
-            break;
-        default:
-            keyboard_ptr = &AsusTUFK7Layouts;
-    }
-
-    std::map<int,layout_info> & keyboard = *keyboard_ptr;
-
-    unsigned char layout = controller->GetLayout();
-
-    if(keyboard.find(layout % 100) == keyboard.end())
-    {
-        /*---------------------------------------------------------*\
-        | If Layout not found, take uk or us                        |
-        \*---------------------------------------------------------*/
         layout = std::floor(layout/100) == 2 ? ASUS_TUF_K7_LAYOUT_UK : ASUS_TUF_K7_LAYOUT_US;
     }
     else
@@ -464,32 +218,33 @@ void RGBController_AuraTUFKeyboard::SetupZones()
         layout = layout % 100;
     }
 
-    zone keyboard_zone;
-    keyboard_zone.name               = "Keyboard";
-    keyboard_zone.type               = ZONE_TYPE_MATRIX;
-    keyboard_zone.leds_min           = keyboard[layout].size;
-    keyboard_zone.leds_max           = keyboard[layout].size;
-    keyboard_zone.leds_count         = keyboard[layout].size;
-    keyboard_zone.matrix_map         = new matrix_map_type;
-    keyboard_zone.matrix_map->height = keyboard[layout].rows;
-    keyboard_zone.matrix_map->width  = keyboard[layout].cols;
-    keyboard_zone.matrix_map->map    = keyboard[layout].matrix_map;
-    zones.push_back(keyboard_zone);
+    unsigned int total_led_count = 0;
 
-    for(int led_id = 0; led_id < keyboard[layout].size; led_id++)
+    int zone_size = 138;
+
+    zone keyboard;
+    keyboard.name               = ZONE_EN_KEYBOARD;
+    keyboard.type               = ZONE_TYPE_MATRIX;
+    keyboard.leds_min           = zone_size;
+    keyboard.leds_max           = zone_size;
+    keyboard.leds_count         = zone_size;
+    keyboard.matrix_map         = new matrix_map_type;
+    keyboard.matrix_map->height = 6;
+    keyboard.matrix_map->width  = 23;
+    keyboard.matrix_map->map    = AsusTUFK7Layouts[layout].matrix_map;
+    zones.push_back(keyboard);
+
+    total_led_count += zone_size;
+
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
     {
         led new_led;
-        new_led.name  = keyboard[layout].led_names[led_id].name;
-        new_led.value = keyboard[layout].led_names[led_id].id;
+        new_led.name = AsusTUFK7Layouts[layout].led_names[led_idx];
         leds.push_back(new_led);
     }
 
     SetupColors();
-
-    /*---------------------------------------------------------*\
-    | sends the init packet for the default mode (direct)       |
-    \*---------------------------------------------------------*/
-    DeviceUpdateMode();
 }
 
 void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
@@ -499,133 +254,86 @@ void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 {
-    std::vector<led_color> led_color_list = {};
-
-    for(size_t i = 0; i < colors.size(); i++)
-    {
-        led_color_list.push_back({ leds[i].value, colors[i] });
-    }
-
-    controller->UpdateLeds(led_color_list);
+    DeviceUpdateMode();
 }
 
 void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
 {
-    DeviceUpdateLEDs();
+    controller->UpdateLeds(colors);
 }
 
 void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
 {
-    if(!controller->is_per_led_keyboard)
-    {
-        return DeviceUpdateLEDs();
-    }
-
     unsigned char red   = RGBGetRValue(colors[led]);
     unsigned char green = RGBGetGValue(colors[led]);
     unsigned char blue  = RGBGetBValue(colors[led]);
 
-    controller->UpdateSingleLed(leds[led].value, red, green, blue);
+    controller->UpdateSingleLed(led, red, green, blue);
 }
 
-static const uint8_t direction_map[2][6] =
-{
-    { 4,  0,  6,  2,  8,  1 },          // Default directions Left, Right, Up, Down, Horizontal, Vertical
-    { 0,  4,  6,  2,  0xFF,  0xFF },    // AURA_ROG_CLAYMORE directions Left, Right, Up, Down
-};
-
 void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
 {
-    if(pid == AURA_ROG_CLAYMORE_PID)
-    {
-        controller->AllowRemoteControl(1);
-    }
-
-    unsigned char color_mode    = 0;
-    unsigned char direction     = 0;
-    unsigned char brightness    = 0;
+    unsigned char color_mode;
+    std::vector<RGBColor> mode_colors;
 
     if(modes[active_mode].value == AURA_KEYBOARD_MODE_DIRECT)
     {
-        if(pid == AURA_ROG_CLAYMORE_PID) controller->AllowRemoteControl(3);
-        return;
-    };
-
-    if(pid != AURA_ROG_CLAYMORE_PID)
-    {
-        brightness = modes[active_mode].brightness * 25;
-
-        switch(modes[active_mode].value)
-        {
-            case AURA_KEYBOARD_MODE_BREATHING:
-            case AURA_KEYBOARD_MODE_REACTIVE:
-            case AURA_KEYBOARD_MODE_STARRY_NIGHT:
-            case AURA_KEYBOARD_MODE_CURRENT:
-            case AURA_KEYBOARD_MODE_RAIN_DROP:
-                if(!controller->is_per_led_keyboard && modes[active_mode].colors.size() > 1)
-                {
-                    color_mode = 1;
-                    break;
-                }
-
-                bool color_is_black = (modes[active_mode].colors.size() > 1 && modes[active_mode].colors[1] == 000);
-
-                if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && !color_is_black)
-                {
-                    color_mode = 16;
-                }
-                break;
-        }
-
-        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
-        {
-            color_mode = 1;
-        }
-
-        if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE || modes[active_mode].value == AURA_KEYBOARD_MODE_QUICKSAND)
-        {
-            /*----------------------------------------------------------*\
-            | converting openrgb direction value to keyboard directions  |
-            \*----------------------------------------------------------*/
-            direction  = direction_map[0][modes[active_mode].direction];
-        }
+        controller->UpdateLeds(colors);
     }
     else
     {
-        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
+        bool mode_with_double = (modes[active_mode].value == 1 || modes[active_mode].value == 3 || modes[active_mode].value == 6 || modes[active_mode].value == 8 || modes[active_mode].value == 9);
+
+        if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && mode_with_double && modes[active_mode].colors.size() > 1)
         {
-            color_mode = 1;
+            if(modes[active_mode].colors[1] == 000)
+            {
+                color_mode = 0;
+            }
+            else
+            {
+                color_mode = 16;
+            }
+        }
+        else
+        {
+            color_mode = modes[active_mode].color_mode == MODE_COLORS_RANDOM ? 1 : 0;
         }
 
-        if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE) {
-            if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) color_mode = 2;
+        int direction = 0;
 
-            /*----------------------------------------------------------*\
-            | converting openrgb direction value to keyboard directions  |
-            \*----------------------------------------------------------*/
-            direction = direction_map[1][modes[active_mode].direction];
+        switch (modes[active_mode].direction)
+        {
+            case MODE_DIRECTION_LEFT:
+                direction = 0;
+                break;
+            case MODE_DIRECTION_RIGHT:
+                direction = 4;
+                break;
+            case MODE_DIRECTION_UP:
+                direction = 6;
+                break;
+            case MODE_DIRECTION_DOWN:
+                direction = 2;
+                break;
+            case MODE_DIRECTION_HORIZONTAL:
+                direction = 8;
+                break;
+            case MODE_DIRECTION_VERTICAL:
+                direction = 1;
+                break;
         }
-    }
 
+        mode_colors = modes[active_mode].color_mode == MODE_COLORS_PER_LED ? std::vector<RGBColor>(colors) : std::vector<RGBColor>(modes[active_mode].colors);
 
-    controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), direction, color_mode, modes[active_mode].speed, brightness);
-
-    if(pid == AURA_ROG_CLAYMORE_PID)
-    {
-        controller->UpdateMode(modes[active_mode].value);
-        controller->SaveMode();
-        controller->AllowRemoteControl(0);
+        controller->UpdateDevice(modes[active_mode].value, mode_colors, direction, color_mode, (15 - modes[active_mode].speed), modes[active_mode].brightness * 25);
     }
 }
 
 void RGBController_AuraTUFKeyboard::DeviceSaveMode()
 {
-    /*----------------------------------------------------------*\
-    | not available for Claymore                                 |
-    \*----------------------------------------------------------*/
-    if(pid != AURA_ROG_CLAYMORE_PID)
-    {
-        DeviceUpdateMode();
-        controller->SaveMode();
-    }
+    controller->ClearResponses();
+    DeviceUpdateMode();
+    controller->AwaitResponse();
+    controller->SaveMode();
 }

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h

@@ -13,23 +13,12 @@
 
 enum
 {
+    AURA_KEYBOARD_SPEED_MIN          = 0,
+    AURA_KEYBOARD_SPEED_MAX          = 15,
+    AURA_KEYBOARD_SPEED_DEFAULT      = 8,
     AURA_KEYBOARD_BRIGHTNESS_MIN     = 0,
     AURA_KEYBOARD_BRIGHTNESS_MAX     = 4,
-    AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4,
-};
-
-enum
-{
-    AURA_CLAYMORE_SPEED_MIN                     = 254,
-    AURA_CLAYMORE_SPEED_MAX                     = 0,
-    AURA_CLAYMORE_SPEED_DEFAULT_STATIC          = 0,
-    AURA_CLAYMORE_SPEED_DEFAULT_BREATHING       = 107,
-    AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE     = 121,
-    AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE        = 56,
-    AURA_CLAYMORE_SPEED_DEFAULT_WAVE            = 50,
-    AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE          = 108,
-    AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT    = 54,
-    AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND       = 103
+    AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4
 };
 
 class RGBController_AuraTUFKeyboard : public RGBController
@@ -51,5 +40,4 @@ public:
 
 private:
     AuraTUFKeyboardController*  controller;
-    uint16_t                    pid;
 };

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -16,9 +16,9 @@
     @save :x:
     @direct :white_check_mark:
     @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable
+    @detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable,DetectAsusAuraUSBMotherboards
     @comment The Asus Aura USB controller applies to most AMD and
-        Intel mainboards from the x470 and z390 chipset generations.
+        Intel mainboards from the x470 and z390 chipsets onwards.
 \*-------------------------------------------------------------------*/
 
 RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr) :

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.h

@@ -29,10 +29,8 @@ public:
 
     void        DeviceUpdateMode();
 
-protected:
-    AuraUSBController*          controller;
-
 private:
+    AuraUSBController*          controller;
     std::vector<unsigned int>   leds_channel;
     std::vector<unsigned int>   zones_channel;
     bool                        initializedMode;

Controllers/AsusAuraUSBController/RGBController_AsusROGAlly.cpp

@@ -1,196 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusROGAlly.cpp            |
-|                                           |
-|  Generic RGB Interface for Asus ROG Ally  |
-|  controller driver                        |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/12/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusROGAlly.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus ROG Ally
-    @category Gamepad
-    @type USB
-    @save :white_check_mark:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusROGAlly
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controller_ptr)
-{
-    controller                  = controller_ptr;
-
-    name                        = "ASUS ROG Ally";
-    vendor                      = "ASUS";
-    type                        = DEVICE_TYPE_GAMEPAD;
-    description                 = "ASUS ROG Ally Device";
-    version                     = controller->GetVersion();
-    location                    = controller->GetDeviceLocation();
-    serial                      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = ROG_ALLY_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = ROG_ALLY_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
-    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min           = 1;
-    Static.colors_max           = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = ROG_ALLY_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.speed_min         = ROG_ALLY_SPEED_MIN;
-    Breathing.speed_max         = ROG_ALLY_SPEED_MAX;
-    Breathing.speed             = ROG_ALLY_SPEED_MED;
-    Breathing.colors_min        = 2;
-    Breathing.colors_max        = 2;
-    Breathing.colors.resize(2);
-    modes.push_back(Breathing);
-
-    mode ColorCycle;
-    ColorCycle.name             = "Spectrum Cycle";
-    ColorCycle.value            = ROG_ALLY_MODE_COLOR_CYCLE;
-    ColorCycle.flags            = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED;
-    ColorCycle.color_mode       = MODE_COLORS_RANDOM;
-    ColorCycle.speed_min        = ROG_ALLY_SPEED_MIN;
-    ColorCycle.speed_max        = ROG_ALLY_SPEED_MAX;
-    ColorCycle.speed            = ROG_ALLY_SPEED_MED;
-    modes.push_back(ColorCycle);
-
-    mode Rainbow;
-    Rainbow.name                = "Rainbow Wave";
-    Rainbow.value               = ROG_ALLY_MODE_RAINBOW;
-    Rainbow.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Rainbow.color_mode          = MODE_COLORS_RANDOM;
-    Rainbow.speed_min           = ROG_ALLY_SPEED_MIN;
-    Rainbow.speed_max           = ROG_ALLY_SPEED_MAX;
-    Rainbow.speed               = ROG_ALLY_SPEED_MED;
-    modes.push_back(Rainbow);
-
-    mode Strobing;
-    Strobing.name               = "Strobing";
-    Strobing.value              = ROG_ALLY_MODE_STROBING;
-    Strobing.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
-    Strobing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-    Strobing.colors_min         = 1;
-    Strobing.colors_max         = 1;
-    Strobing.colors.resize(1);
-    modes.push_back(Strobing);
-
-    SetupZones();
-}
-
-RGBController_AsusROGAlly::~RGBController_AsusROGAlly()
-{
-    delete controller;
-}
-
-void RGBController_AsusROGAlly::SetupZones()
-{
-    zone left_stick_zone;
-
-    left_stick_zone.name         = "Left Stick";
-    left_stick_zone.type         = ZONE_TYPE_SINGLE;
-    left_stick_zone.leds_min     = 2;
-    left_stick_zone.leds_max     = 2;
-    left_stick_zone.leds_count   = 2;
-    left_stick_zone.matrix_map   = NULL;
-
-    zones.push_back(left_stick_zone);
-
-    for(unsigned int i = 0; i < 2; i++)
-    {
-        led left_stick_led;
-
-        left_stick_led.name      = "Left Stick LED " + std::to_string(i);
-
-        leds.push_back(left_stick_led);
-    }
-
-    zone right_stick_zone;
-
-    right_stick_zone.name         = "Right Stick";
-    right_stick_zone.type         = ZONE_TYPE_SINGLE;
-    right_stick_zone.leds_min     = 2;
-    right_stick_zone.leds_max     = 2;
-    right_stick_zone.leds_count   = 2;
-    right_stick_zone.matrix_map   = NULL;
-
-    zones.push_back(right_stick_zone);
-
-    for(unsigned int i = 0; i < 2; i++)
-    {
-        led right_stick_led;
-
-        right_stick_led.name      = "Right Stick LED " + std::to_string(i);
-
-        leds.push_back(right_stick_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AsusROGAlly::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AsusROGAlly::DeviceUpdateLEDs()
-{
-    if(modes[active_mode].value == ROG_ALLY_MODE_DIRECT)
-    {
-        controller->UpdateLeds(std::vector<RGBColor>(colors));
-    }
-}
-
-void RGBController_AsusROGAlly::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AsusROGAlly::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AsusROGAlly::DeviceUpdateMode()
-{
-    if(modes[active_mode].value == ROG_ALLY_MODE_DIRECT)
-    {
-        DeviceUpdateLEDs();
-    }
-    else
-    {
-        unsigned int rog_ally_direction = ROG_ALLY_DIRECTION_RIGHT;
-
-        if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && (modes[active_mode].direction == MODE_DIRECTION_LEFT))
-        {
-            rog_ally_direction = ROG_ALLY_DIRECTION_LEFT;
-        }
-
-        controller->UpdateDevice(modes[active_mode].value, modes[active_mode].colors, modes[active_mode].speed, modes[active_mode].brightness, rog_ally_direction);
-    }
-}
-
-void RGBController_AsusROGAlly::DeviceSaveMode()
-{
-    DeviceUpdateMode();
-    controller->SaveMode();
-}

Controllers/AsusAuraUSBController/RGBController_AsusROGAlly.h

@@ -1,34 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusROGAlly.cpp            |
-|                                           |
-|  Generic RGB Interface for Asus ROG Ally  |
-|  controller driver                        |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/12/2023   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AsusROGAllyController.h"
-
-class RGBController_AsusROGAlly : public RGBController
-{
-public:
-    RGBController_AsusROGAlly(ROGAllyController* controller_ptr);
-    ~RGBController_AsusROGAlly();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-    void        DeviceSaveMode();
-
-private:
-    ROGAllyController* controller;
-};

Controllers/AsusAuraUSBController/ROGStrixLC_Controller.cpp

@@ -23,7 +23,7 @@ ROGStrixLC_Controller::ROGStrixLC_Controller(hid_device* dev_handle, const char*
 
 ROGStrixLC_Controller::~ROGStrixLC_Controller()
 {
-    // Device will close at AuraUSBController destructor
+    hid_close(dev);
 }
 
 std::string ROGStrixLC_Controller::GetLocation()

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.cpp

@@ -1,198 +0,0 @@
-/*-----------------------------------------*\
-|  AsusCerberusKeyboardController.cpp       |
-|                                           |
-|  Driver for ASUS Cerberus USB lighting    |
-|  controller                               |
-|                                           |
-|  Mola19 05/28/2022                        |
-\*-----------------------------------------*/
-
-#include "AsusCerberusKeyboardController.h"
-
-#include <cstring>
-#include <string>
-#include <vector>
-#include <math.h>
-#include <stdio.h>
-#include <string.h>
-#include <cmath>
-
-#define ASUS_CERBERUS_KB_PACKET_SIZE 8
-
-AsusCerberusKeyboardController::AsusCerberusKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version)
-{
-    dev         = dev_handle;
-    location    = path;
-    version     = rev_version;
-}
-
-AsusCerberusKeyboardController::~AsusCerberusKeyboardController()
-{
-    hid_close(dev);
-}
-
-std::string AsusCerberusKeyboardController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AsusCerberusKeyboardController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-std::string AsusCerberusKeyboardController::GetVersion()
-{
-    char versionstr[5];
-    snprintf(versionstr, 5, "%X", version);
-    return(std::string(versionstr));
-}
-
-void AsusCerberusKeyboardController::SetProfile
-    (
-    uint8_t           profile
-    )
-{
-    uint8_t usb_buf[ASUS_CERBERUS_KB_PACKET_SIZE];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00] = 0x07;
-    usb_buf[0x01] = 0x03;
-    usb_buf[0x02] = profile;
-
-    hid_send_feature_report(dev, usb_buf, ASUS_CERBERUS_KB_PACKET_SIZE);
-}
-
-void AsusCerberusKeyboardController::SetPerLEDColor
-    (
-    uint8_t           key,
-    uint8_t           red,
-    uint8_t           green,
-    uint8_t           blue
-    )
-{
-    uint8_t profile = 1;
-
-    uint8_t usb_buf[ASUS_CERBERUS_KB_PACKET_SIZE];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00] = 0x07;
-    usb_buf[0x01] = 0x0D;
-    usb_buf[0x02] = profile;
-    usb_buf[0x03] = key;
-    usb_buf[0x04] = red;
-    usb_buf[0x05] = green;
-    usb_buf[0x06] = blue;
-
-    hid_send_feature_report(dev, usb_buf, ASUS_CERBERUS_KB_PACKET_SIZE);
-}
-
-void AsusCerberusKeyboardController::SendPerLEDColorEnd()
-{
-    SetPerLEDColor(255, 0, 0, 0);
-}
-
-void AsusCerberusKeyboardController::SetPerLEDMode
-    (
-    uint8_t           mode
-    )
-{
-    /*------------------------------------------------------------------------------------------------------*\
-    | this device has 6 different profiles, but there is no way to fetch them from the device,               |
-    | hence this device always sends to the first profile until a better solution is implemented in OpenRGB  |
-    \*------------------------------------------------------------------------------------------------------*/
-    uint8_t profile = 1;
-
-    /*--------------------------------------------------------------------------------*\
-    | 8 booleans per byte, each boolean controls one key                               |
-    | 0 = static, 1 = breathing                                                        |
-    | since openrgb doesn't support per led modes, either all static or all breathing  |
-    \*--------------------------------------------------------------------------------*/
-
-    uint8_t modebyte = (mode == 1) ? 0xFF : 0x00;
-
-    for(int i = 0; i < 4; i++)
-    {
-        uint8_t usb_buf[ASUS_CERBERUS_KB_PACKET_SIZE];
-
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0x00] = 0x07;
-        usb_buf[0x01] = 0x0E;
-        usb_buf[0x02] = profile;
-        usb_buf[0x03] = i;
-        usb_buf[0x04] = modebyte;
-        usb_buf[0x05] = modebyte;
-        usb_buf[0x06] = modebyte;
-        usb_buf[0x07] = modebyte;
-
-        hid_send_feature_report(dev, usb_buf, ASUS_CERBERUS_KB_PACKET_SIZE);
-    }
-}
-
-void AsusCerberusKeyboardController::SetMode
-    (
-    uint8_t           mode,
-    uint8_t           red,
-    uint8_t           green,
-    uint8_t           blue,
-    uint8_t           direction,
-    uint8_t           brightness
-    )
-{
-    /*------------------------------------------------------------------------------------------------------*\
-    | this device has 6 different profiles, but there is no way to fetch them from the device,               |
-    | hence this device always sends to the first profile until a better solution is implemented in OpenRGB  |
-    \*------------------------------------------------------------------------------------------------------*/
-    uint8_t profile = 1;
-
-    uint8_t usb_buf_1[ASUS_CERBERUS_KB_PACKET_SIZE];
-
-    memset(usb_buf_1, 0x00, sizeof(usb_buf_1));
-
-    usb_buf_1[0x00] = 0x07;
-    usb_buf_1[0x01] = 0x0A;
-    usb_buf_1[0x02] = profile;
-    usb_buf_1[0x03] = mode;
-    usb_buf_1[0x04] = direction;
-
-    hid_send_feature_report(dev, usb_buf_1, ASUS_CERBERUS_KB_PACKET_SIZE);
-
-    uint8_t usb_buf_2[ASUS_CERBERUS_KB_PACKET_SIZE];
-
-    memset(usb_buf_2, 0x00, sizeof(usb_buf_2));
-
-    usb_buf_2[0x00] = 0x07;
-    usb_buf_2[0x01] = 0x0B;
-    usb_buf_2[0x02] = profile;
-    usb_buf_2[0x03] = mode;
-    usb_buf_2[0x04] = red;
-    usb_buf_2[0x05] = green;
-    usb_buf_2[0x06] = blue;
-
-    hid_send_feature_report(dev, usb_buf_2, ASUS_CERBERUS_KB_PACKET_SIZE);
-
-    uint8_t usb_buf_3[ASUS_CERBERUS_KB_PACKET_SIZE];
-
-    memset(usb_buf_3, 0x00, sizeof(usb_buf_3));
-
-    usb_buf_3[0x00] = 0x07;
-    usb_buf_3[0x01] = 0x0C;
-    usb_buf_3[0x02] = profile;
-    usb_buf_3[0x03] = brightness;
-
-    hid_send_feature_report(dev, usb_buf_3, ASUS_CERBERUS_KB_PACKET_SIZE);
-}

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.h

@@ -1,51 +0,0 @@
-/*-----------------------------------------*\
-|  AsusCerberusKeyboardController.h         |
-|                                           |
-|  Definitions and types for ASUS Cerberus  |
-|  USB RGB lighting controller              |
-|                                           |
-|  Mola19 03/03/2021                        |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    CERBERUS_KEYBOARD_MODE_STATIC       = 0,
-    CERBERUS_KEYBOARD_MODE_BREATHING    = 1,
-    CERBERUS_KEYBOARD_MODE_REACTIVE     = 2,
-    CERBERUS_KEYBOARD_MODE_EXPLOSION    = 3,
-    CERBERUS_KEYBOARD_MODE_COLOR_CYCLE  = 4,
-    CERBERUS_KEYBOARD_MODE_WAVE         = 6,
-    CERBERUS_KEYBOARD_MODE_CUSTOM       = 7,
-};
-
-
-class AsusCerberusKeyboardController
-{
-public:
-    AsusCerberusKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version);
-    ~AsusCerberusKeyboardController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-    std::string GetVersion();
-
-    void SetProfile(uint8_t profile);
-    void SetPerLEDColor(uint8_t key, uint8_t red, uint8_t green, uint8_t blue);
-    void SendPerLEDColorEnd();
-    void SetPerLEDMode(uint8_t mode);
-    void SetMode(uint8_t mode, uint8_t red, uint8_t green, uint8_t blue, uint8_t direction, uint8_t brightness);
-
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-    unsigned short              version;
-};

Controllers/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp

@@ -1,48 +1,15 @@
 #include "Detector.h"
-#include "AsusCerberusKeyboardController.h"
-#include "AsusSagarisKeyboardController.h"
 #include "AsusStrixClawController.h"
 #include "RGBController.h"
-#include "RGBController_AsusCerberusKeyboard.h"
-#include "RGBController_AsusSagarisKeyboard.h"
 #include "RGBController_AsusStrixClaw.h"
 #include <stdexcept>
 #include <hidapi/hidapi.h>
 #include "dependencies/dmiinfo.h"
 
 #define ASUS_LEGACY_USB_VID         0x195D
-#define ASUS_USB_VID                0x0B05
 
-#define ASUS_CERBERUS_MECH_PID      0x2047
-#define ASUS_SAGARIS_GK1100_PID     0x1835
 #define ASUS_ROG_STRIX_CLAW_PID     0x1016
 
-void DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AsusCerberusKeyboardController*     controller          = new AsusCerberusKeyboardController(dev, info->path, info->release_number);
-        RGBController_AsusCerberusKeyboard* rgb_controller      = new RGBController_AsusCerberusKeyboard(controller);
-        rgb_controller->name                                = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAsusSagarisKeyboard(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AsusSagarisKeyboardController*     controller          = new AsusSagarisKeyboardController(dev, info->path, info->release_number);
-        RGBController_AsusSagarisKeyboard* rgb_controller      = new RGBController_AsusSagarisKeyboard(controller);
-        rgb_controller->name                                = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
 void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -56,7 +23,4 @@ void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
     }
 }
 
-REGISTER_HID_DETECTOR_IPU("ASUS Cerberus Mech",  DetectAsusCerberusMech,  ASUS_LEGACY_USB_VID, ASUS_CERBERUS_MECH_PID,  1, 0xFF01, 1);
-REGISTER_HID_DETECTOR_IPU("ASUS Sagaris GK1100", DetectAsusSagarisKeyboard,       ASUS_USB_VID,        ASUS_SAGARIS_GK1100_PID, 1, 0xFF02, 2);
-
-REGISTER_HID_DETECTOR_IPU("ASUS ROG Strix Claw", DetectAsusStrixClaw,     ASUS_LEGACY_USB_VID, ASUS_ROG_STRIX_CLAW_PID, 0, 0xFF01, 1);
+REGISTER_HID_DETECTOR_IPU("ASUS ROG Strix Claw", DetectAsusStrixClaw,  ASUS_LEGACY_USB_VID, ASUS_ROG_STRIX_CLAW_PID, 0, 0xFF01, 1);

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.cpp

@@ -1,197 +0,0 @@
-/*-----------------------------------------*\
-|  AsusSagarisKeyboardController.cpp       |
-|                                           |
-|  Driver for ASUS Sagaris USB lighting    |
-|  controller                               |
-|                                           |
-|  Mola19 08/20/2023                        |
-\*-----------------------------------------*/
-
-#include "AsusSagarisKeyboardController.h"
-
-#include <cstring>
-#include <string>
-#include <math.h>
-#include <vector>
-#include <string.h>
-
-#include "LogManager.h"
-
-#define ASUS_SAGARIS_KB_PACKET_SIZE 65
-
-AsusSagarisKeyboardController::AsusSagarisKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version)
-{
-    dev         = dev_handle;
-    location    = path;
-    version     = rev_version;
-}
-
-AsusSagarisKeyboardController::~AsusSagarisKeyboardController()
-{
-    hid_close(dev);
-}
-
-std::string AsusSagarisKeyboardController::GetVersion()
-{
-    return std::to_string((int) floor(version / 0x100)) + "." + std::to_string(version % 0x100);
-}
-
-std::string AsusSagarisKeyboardController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AsusSagarisKeyboardController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-sagaris_mode AsusSagarisKeyboardController::GetMode()
-{
-    ClearResponses();
-
-    uint8_t usb_buf_out[ASUS_SAGARIS_KB_PACKET_SIZE];
-    memset(usb_buf_out, 0x00, sizeof(usb_buf_out));
-
-    usb_buf_out[0x00] = 0x06;
-    usb_buf_out[0x01] = 0x0B;
-    usb_buf_out[0x02] = 0x03;
-
-    hid_write(dev, usb_buf_out, ASUS_SAGARIS_KB_PACKET_SIZE);
-
-    unsigned char usb_buf_in[ASUS_SAGARIS_KB_PACKET_SIZE];
-    memset(usb_buf_in, 0x00, sizeof(usb_buf_in));
-    int return_length = hid_read_timeout(dev, usb_buf_in, ASUS_SAGARIS_KB_PACKET_SIZE, 100);
-
-    if(return_length == -1)
-    {
-        LOG_DEBUG("[Asus Sagaris GK1100]: Could not fetch mode");
-        sagaris_mode default_mode;
-        default_mode.mode       = SAGARIS_KEYBOARD_MODE_STATIC;
-        default_mode.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-        default_mode.speed      = 0;
-        default_mode.colorIndex = 0;
-
-        return default_mode;
-    }
-
-    sagaris_mode current_mode;
-    current_mode.mode       = usb_buf_in[3];
-    current_mode.brightness = usb_buf_in[4];
-    current_mode.speed      = usb_buf_in[5];
-    current_mode.colorIndex = usb_buf_in[6];
-
-    return current_mode;
-}
-
-std::vector<RGBColor> AsusSagarisKeyboardController::GetColors()
-{
-    ClearResponses();
-
-    uint8_t usb_buf_out[ASUS_SAGARIS_KB_PACKET_SIZE];
-    memset(usb_buf_out, 0x00, sizeof(usb_buf_out));
-
-    usb_buf_out[0x00] = 0x06;
-    usb_buf_out[0x01] = 0x0B;
-    usb_buf_out[0x02] = 0x05;
-
-    hid_write(dev, usb_buf_out, ASUS_SAGARIS_KB_PACKET_SIZE);
-
-    std::vector<RGBColor> colors;
-    colors.resize(7);
-
-    for(int i = 0; i < 7; i++)
-    {
-        unsigned char usb_buf_in[ASUS_SAGARIS_KB_PACKET_SIZE];
-        memset(usb_buf_in, 0x00, sizeof(usb_buf_in));
-        int return_length = hid_read_timeout(dev, usb_buf_in, ASUS_SAGARIS_KB_PACKET_SIZE, 100);
-
-        if(return_length == -1)
-        {
-           LOG_DEBUG("[Asus Sagaris GK1100]: Could not fetch color %i", i);
-           colors[i] = ToRGBColor(0, 0, 0);
-           continue;
-        }
-
-        colors[i] = ToRGBColor(usb_buf_in[4] * 16, usb_buf_in[5] * 16, usb_buf_in[6] * 16);
-    }
-
-    return colors;
-}
-
-void AsusSagarisKeyboardController::SetColor
-    (
-    uint8_t           index,
-    uint8_t           red,
-    uint8_t           green,
-    uint8_t           blue
-    )
-{
-    uint8_t usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00] = 0x06;
-    usb_buf[0x01] = 0x0B;
-    usb_buf[0x02] = 0x04;
-    usb_buf[0x03] = 0x00;
-    usb_buf[0x04] = index;
-    usb_buf[0x05] = red;
-    usb_buf[0x06] = green;
-    usb_buf[0x07] = blue;
-
-    hid_write(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE);
-}
-
-void AsusSagarisKeyboardController::SetMode
-    (
-    uint8_t           mode,
-    uint8_t           brightness,
-    uint8_t           speed,
-    uint8_t           colorIndex
-    )
-{
-    ClearResponses();
-
-    uint8_t usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00] = 0x06;
-    usb_buf[0x01] = 0x0B;
-    usb_buf[0x02] = 0x01;
-    usb_buf[0x03] = mode;
-    usb_buf[0x04] = brightness;
-    usb_buf[0x05] = speed;
-    usb_buf[0x06] = colorIndex;
-
-    hid_write(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE);
-
-    AwaitResponse(20);
-}
-
-void AsusSagarisKeyboardController::AwaitResponse(int ms)
-{
-    unsigned char usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
-    hid_read_timeout(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE, ms);
-}
-
-void AsusSagarisKeyboardController::ClearResponses()
-{
-    int result = 1;
-    unsigned char usb_buf_flush[65];
-    while(result > 0)
-    {
-        result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
-    }
-}

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.h

@@ -1,76 +0,0 @@
-/*-----------------------------------------*\
-|  AsusSagarisKeyboardController.h         |
-|                                           |
-|  Definitions and types for ASUS Sagaris  |
-|  USB RGB lighting controller              |
-|                                           |
-|  Mola19 08/20/2023                        |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    SAGARIS_KEYBOARD_MODE_OFF           = 0,
-    SAGARIS_KEYBOARD_MODE_STATIC        = 1,
-    SAGARIS_KEYBOARD_MODE_SPRIAL        = 2,
-    SAGARIS_KEYBOARD_MODE_CUSTOM        = 3,
-    SAGARIS_KEYBOARD_MODE_BREATHING     = 4,
-    SAGARIS_KEYBOARD_MODE_REACTIVE      = 5,
-    SAGARIS_KEYBOARD_MODE_STARRY_NIGHT  = 6,
-    SAGARIS_KEYBOARD_MODE_LASER         = 7,
-};
-
-enum
-{
-    SAGARIS_KEYBOARD_BRIGHTNESS_MIN     = 0,
-    SAGARIS_KEYBOARD_BRIGHTNESS_MAX     = 3,
-    SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT = 3
-};
-
-enum
-{
-    SAGARIS_KEYBOARD_SPEED_MIN     = 0,
-    SAGARIS_KEYBOARD_SPEED_MAX     = 3,
-    SAGARIS_KEYBOARD_SPEED_DEFAULT = 2
-};
-
-typedef struct
-{
-    uint8_t                 mode;
-    uint8_t                 brightness;
-    uint8_t                 speed;
-    uint8_t                 colorIndex;
-} sagaris_mode;
-
-
-class AsusSagarisKeyboardController
-{
-public:
-    AsusSagarisKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version);
-    ~AsusSagarisKeyboardController();
-
-    std::string GetVersion();
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    sagaris_mode          GetMode();
-    std::vector<RGBColor> GetColors();
-
-    void SetMode(uint8_t mode, uint8_t brightness, uint8_t speed, uint8_t colorIndex);
-    void SetColor(uint8_t index, uint8_t red, uint8_t green, uint8_t blue);
-
-    void AwaitResponse(int ms);
-    void ClearResponses();
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-    unsigned short              version;
-};

Controllers/AsusLegacyUSBController/RGBController_AsusCerberusKeyboard.cpp

@@ -1,391 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusCerberusKeyboard.cpp   |
-|                                           |
-|  Generic RGB Interface for Asus Cerberus  |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 05/28/2022                        |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusCerberusKeyboard.h"
-#include <vector>
-#include <cmath>
-#include "RGBControllerKeyNames.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus Cerberus Mech Keyboard
-    @category Keyboard
-    @type USB
-    @save :robot:
-    @direct :x:
-    @effects :white_check_mark:
-    @detectors DetectAsusCerberusMech
-    @comment
-\*-------------------------------------------------------------------*/
-
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-
-static unsigned int matrix_map[6][24] = {
-    {   0,  NA,   9,  15,  20,  25,  NA,  35,  40,  45,  50,  56,  62,  67,  72,  NA,  75,  79,  84,  NA,  NA,  NA,  NA,  NA },
-    {   1,   6,  10,  16,  21,  26,  30,  36,  41,  46,  51,  57,  63,  68,  NA,  NA,  76,  80,  85,  NA,  88,  93,  97, 102 },
-    {   2,  NA,  11,  17,  22,  27,  31,  37,  42,  47,  52,  58,  64,  69,  NA,  NA,  77,  81,  86,  NA,  89,  94,  98, 103 },
-    {   3,  NA,  12,  18,  23,  28,  32,  38,  43,  48,  53,  59,  65,  70,  73,  NA,  NA,  NA,  NA,  NA,  90,  95,  99,  NA },
-    {   4,   7,  13,  19,  24,  29,  33,  39,  44,  49,  54,  60,  NA,  71,  NA,  NA,  NA,  82,  NA,  NA,  91,  96, 100, 104 },
-    {   5,   8,  14,  NA,  NA,  NA,  34,  NA,  NA,  NA,  55,  61,  66,  NA,  74,  NA,  78,  83,  87,  NA,  92,  NA, 101,  NA }
-};
-
-struct led_value
-{
-    const char*     name;
-    uint8_t         id;
-};
-
-static const std::vector<led_value> led_names =
-{
-    { KEY_EN_ESCAPE,              0x0B },
-    { KEY_EN_BACK_TICK,           0x0E },
-    { KEY_EN_TAB,                 0x09 },
-    { KEY_EN_CAPS_LOCK,           0x11 },
-    { KEY_EN_LEFT_SHIFT,          0x79 },
-    { KEY_EN_LEFT_CONTROL,        0x06 },
-
-    { KEY_EN_1,                   0x0F },
-    { KEY_EN_ISO_BACK_SLASH,      0x13 },
-    { KEY_EN_LEFT_WINDOWS,        0x7C },
-
-    { KEY_EN_F1,                  0x16 },
-    { KEY_EN_2,                   0x17 },
-    { KEY_EN_Q,                   0x08 },
-    { KEY_EN_A,                   0x0A },
-    { KEY_EN_Z,                   0x0C },
-    { KEY_EN_LEFT_ALT,            0x4B },
-
-    { KEY_EN_F2,                  0x1E },
-    { KEY_EN_3,                   0x1F },
-    { KEY_EN_W,                   0x10 },
-    { KEY_EN_S,                   0x12 },
-    { KEY_EN_X,                   0x14 },
-
-    { KEY_EN_F3,                  0x19 },
-    { KEY_EN_4,                   0x27 },
-    { KEY_EN_E,                   0x18 },
-    { KEY_EN_D,                   0x1A },
-    { KEY_EN_C,                   0x1C },
-
-    { KEY_EN_F4,                  0x1B },
-    { KEY_EN_5,                   0x26 },
-    { KEY_EN_R,                   0x20 },
-    { KEY_EN_F,                   0x22 },
-    { KEY_EN_V,                   0x24 },
-
-    { KEY_EN_6,                   0x2E },
-    { KEY_EN_T,                   0x21 },
-    { KEY_EN_G,                   0x23 },
-    { KEY_EN_B,                   0x25 },
-    { KEY_EN_SPACE,               0x5B },
-
-    { KEY_EN_F5,                  0x07 },
-    { KEY_EN_7,                   0x2F },
-    { KEY_EN_Y,                   0x29 },
-    { KEY_EN_H,                   0x2B },
-    { KEY_EN_N,                   0x2D },
-
-    { KEY_EN_F6,                  0x33 },
-    { KEY_EN_8,                   0x37 },
-    { KEY_EN_U,                   0x28 },
-    { KEY_EN_J,                   0x2A },
-    { KEY_EN_M,                   0x2C },
-
-    { KEY_EN_F7,                  0x39 },
-    { KEY_EN_9,                   0x3F },
-    { KEY_EN_I,                   0x30 },
-    { KEY_EN_K,                   0x32 },
-    { KEY_EN_COMMA,               0x34 },
-
-    { KEY_EN_F8,                  0x3E },
-    { KEY_EN_0,                   0x47 },
-    { KEY_EN_O,                   0x38 },
-    { KEY_EN_L,                   0x3A },
-    { KEY_EN_PERIOD,              0x3C },
-    { KEY_EN_RIGHT_ALT,           0x4D },
-
-    { KEY_EN_F9,                  0x56 },
-    { KEY_EN_MINUS,               0x46 },
-    { KEY_EN_P,                   0x40 },
-    { KEY_EN_SEMICOLON,           0x42 },
-    { KEY_EN_FORWARD_SLASH,       0x45 },
-    { KEY_EN_RIGHT_FUNCTION,      0x7D },
-
-    { KEY_EN_F10,                 0x57 },
-    { KEY_EN_EQUALS,              0x36 },
-    { KEY_EN_LEFT_BRACKET,        0x41 },
-    { KEY_EN_QUOTE,               0x43 },
-    { KEY_EN_MENU,                0x3D },
-
-    { KEY_EN_F11,                 0x53 },
-    { KEY_EN_BACKSPACE,           0x51 },
-    { KEY_EN_RIGHT_BRACKET,       0x31 },
-    { KEY_EN_POUND,               0x44 },
-    { KEY_EN_RIGHT_SHIFT,         0x7A },
-
-    { KEY_EN_F12,                 0x55 },
-    { KEY_EN_ISO_ENTER,           0x54 },
-    { KEY_EN_RIGHT_CONTROL,       0x04 },
-    { KEY_EN_PRINT_SCREEN,        0x4F },
-
-    { KEY_EN_INSERT,              0x66 },
-    { KEY_EN_DELETE,              0x5E },
-    { KEY_EN_LEFT_ARROW,          0x75 },
-
-    { KEY_EN_SCROLL_LOCK,         0x48 },
-    { KEY_EN_HOME,                0x76 },
-    { KEY_EN_END,                 0x77 },
-    { KEY_EN_UP_ARROW,            0x73 },
-    { KEY_EN_DOWN_ARROW,          0x5D },
-
-    { KEY_EN_PAUSE_BREAK,         0x00 },
-    { KEY_EN_PAGE_UP,             0x6E },
-    { KEY_EN_PAGE_DOWN,           0x6F },
-    { KEY_EN_RIGHT_ARROW,         0x65 },
-
-    { KEY_EN_NUMPAD_LOCK,         0x5C },
-    { KEY_EN_NUMPAD_7,            0x58 },
-    { KEY_EN_NUMPAD_4,            0x59 },
-    { KEY_EN_NUMPAD_1,            0x5A },
-    { KEY_EN_NUMPAD_0,            0x63 },
-
-    { KEY_EN_NUMPAD_DIVIDE,       0x64 },
-    { KEY_EN_NUMPAD_8,            0x60 },
-    { KEY_EN_NUMPAD_5,            0x61 },
-    { KEY_EN_NUMPAD_2,            0x62 },
-
-    { KEY_EN_NUMPAD_TIMES,        0x6C },
-    { KEY_EN_NUMPAD_9,            0x68 },
-    { KEY_EN_NUMPAD_6,            0x69 },
-    { KEY_EN_NUMPAD_3,            0x6A },
-    { KEY_EN_NUMPAD_PERIOD,       0x6B },
-
-    { KEY_EN_NUMPAD_MINUS,        0x6D },
-    { KEY_EN_NUMPAD_PLUS,         0x70 },
-    { KEY_EN_NUMPAD_ENTER,        0x72 }
-};
-
-RGBController_AsusCerberusKeyboard::RGBController_AsusCerberusKeyboard(AsusCerberusKeyboardController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    /*------------------------------------------------------------------------------------------------------*\
-    | this device has 6 different profiles, but there is no way to fetch them from the device,               |
-    | hence this device always sends to the first profile until a better solution is implemented in OpenRGB  |
-    \*------------------------------------------------------------------------------------------------------*/
-
-    controller->SetProfile(1);
-
-    name        = "ASUS Cerberus Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "ASUS Cerberus Keyboard Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-    version     = controller->GetVersion();
-
-    mode Custom;
-    Custom.name                     = "Custom";
-    Custom.value                    = CERBERUS_KEYBOARD_MODE_STATIC;
-    Custom.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Custom.brightness_min           = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Custom.brightness_max           = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Custom.brightness               = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Custom.color_mode               = MODE_COLORS_PER_LED;
-    modes.push_back(Custom);
-
-    mode Static;
-    Static.name                     = "Static";
-    Static.value                    = CERBERUS_KEYBOARD_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.brightness_min           = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Static.brightness_max           = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Static.brightness               = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min               = 1;
-    Static.colors_max               = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = CERBERUS_KEYBOARD_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.brightness_min        = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Breathing.brightness_max        = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Breathing.brightness            = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors_min            = 1;
-    Breathing.colors_max            = 1;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
-
-    mode Reactive;
-    Reactive.name                   = "Reactive";
-    Reactive.value                  = CERBERUS_KEYBOARD_MODE_REACTIVE;
-    Reactive.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Reactive.brightness_min         = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Reactive.brightness_max         = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Reactive.brightness             = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Reactive.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    Reactive.colors_min             = 1;
-    Reactive.colors_max             = 1;
-    Reactive.colors.resize(1);
-    modes.push_back(Reactive);
-
-    mode Explosion;
-    Explosion.name                  = "Explosion";
-    Explosion.value                 = CERBERUS_KEYBOARD_MODE_EXPLOSION;
-    Explosion.flags                 = MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Explosion.brightness_min        = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Explosion.brightness_max        = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Explosion.brightness            = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Explosion.direction             = MODE_DIRECTION_VERTICAL;
-    Explosion.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Explosion.colors_min            = 1;
-    Explosion.colors_max            = 1;
-    Explosion.colors.resize(1);
-    modes.push_back(Explosion);
-
-    mode Color_Cycle;
-    Color_Cycle.name                = "Spectrum Cycle";
-    Color_Cycle.value               = CERBERUS_KEYBOARD_MODE_COLOR_CYCLE;
-    Color_Cycle.flags               = MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Color_Cycle.brightness_min      = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Color_Cycle.brightness_max      = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Color_Cycle.brightness          = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Color_Cycle.direction           = MODE_DIRECTION_HORIZONTAL;
-    Color_Cycle.color_mode          = MODE_COLORS_NONE;
-    modes.push_back(Color_Cycle);
-
-    mode Wave;
-    Wave.name                       = "Rainbow Wave";
-    Wave.value                      = CERBERUS_KEYBOARD_MODE_WAVE;
-    Wave.flags                      = MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Wave.brightness_min             = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Wave.brightness_max             = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Wave.brightness                 = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Wave.direction                  = MODE_DIRECTION_LEFT;
-    Wave.color_mode                 = MODE_COLORS_NONE;
-    modes.push_back(Wave);
-
-    SetupZones();
-}
-
-RGBController_AsusCerberusKeyboard::~RGBController_AsusCerberusKeyboard()
-{
-    delete controller;
-}
-
-void RGBController_AsusCerberusKeyboard::SetupZones()
-{
-    int zone_size = 105;
-
-    zone keyboard;
-    keyboard.name               = "Keyboard";
-    keyboard.type               = ZONE_TYPE_MATRIX;
-    keyboard.leds_min           = zone_size;
-    keyboard.leds_max           = zone_size;
-    keyboard.leds_count         = zone_size;
-    keyboard.matrix_map         = new matrix_map_type;
-    keyboard.matrix_map->height = 6;
-    keyboard.matrix_map->width  = 24;
-    keyboard.matrix_map->map    = *matrix_map;
-    zones.push_back(keyboard);
-
-    for(int led_id = 0; led_id < zone_size; led_id++)
-    {
-        led new_led;
-        new_led.name  = led_names[led_id].name;
-        new_led.value = led_names[led_id].id;
-
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AsusCerberusKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
-void RGBController_AsusCerberusKeyboard::DeviceUpdateLEDs()
-{
-    for(unsigned int i = 0; i < colors.size(); i++)
-    {
-        uint8_t red   = RGBGetRValue(colors[i]);
-        uint8_t green = RGBGetGValue(colors[i]);
-        uint8_t blue  = RGBGetBValue(colors[i]);
-
-        controller->SetPerLEDColor(led_names[i].id, red, green, blue);
-    }
-    controller->SendPerLEDColorEnd();
-}
-
-void RGBController_AsusCerberusKeyboard::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AsusCerberusKeyboard::UpdateSingleLED(int led)
-{
-    uint8_t red   = RGBGetRValue(colors[led]);
-    uint8_t green = RGBGetGValue(colors[led]);
-    uint8_t blue  = RGBGetBValue(colors[led]);
-
-
-    controller->SetPerLEDColor(led_names[led].id, red, green, blue);
-    controller->SendPerLEDColorEnd();
-}
-
-void RGBController_AsusCerberusKeyboard::DeviceUpdateMode()
-{
-    uint8_t direction   = 0;
-    uint8_t red         = 0;
-    uint8_t green       = 0;
-    uint8_t blue        = 0;
-
-    uint8_t mode        = modes[active_mode].value;
-
-
-    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
-    {
-        mode        = CERBERUS_KEYBOARD_MODE_CUSTOM;
-        direction   = 1;
-
-        controller->SetPerLEDMode(modes[active_mode].value);
-    }
-
-    switch(modes[active_mode].value)
-    {
-        case CERBERUS_KEYBOARD_MODE_EXPLOSION:
-            direction = (modes[active_mode].direction == MODE_DIRECTION_HORIZONTAL) ? 1 : 0;
-            break;
-
-        case CERBERUS_KEYBOARD_MODE_COLOR_CYCLE:
-            direction = (modes[active_mode].direction == MODE_DIRECTION_HORIZONTAL) ? 0 : 1;
-            break;
-
-        case CERBERUS_KEYBOARD_MODE_WAVE:
-            direction = modes[active_mode].direction;
-            break;
-    }
-
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        red     = RGBGetRValue(modes[active_mode].colors[0]);
-        green   = RGBGetGValue(modes[active_mode].colors[0]);
-        blue    = RGBGetBValue(modes[active_mode].colors[0]);
-    }
-
-    controller->SetMode(mode, red, green, blue, direction, modes[active_mode].brightness);
-}

Controllers/AsusLegacyUSBController/RGBController_AsusCerberusKeyboard.h

@@ -1,39 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusCerberusKeyboard.h     |
-|                                           |
-|  Generic RGB Interface for Asus Cerberus  |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 03/03/2021                        |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusCerberusKeyboardController.h"
-
-enum
-{
-    CERBERUS_MECH_BRIGHTNESS_MIN     = 0,
-    CERBERUS_MECH_BRIGHTNESS_MAX     = 4,
-    CERBERUS_MECH_BRIGHTNESS_DEFAULT = 4
-};
-
-class RGBController_AsusCerberusKeyboard : public RGBController
-{
-public:
-    RGBController_AsusCerberusKeyboard(AsusCerberusKeyboardController* controller_ptr);
-    ~RGBController_AsusCerberusKeyboard();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AsusCerberusKeyboardController*  controller;
-};

Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.cpp

@@ -1,246 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusSagarisKeyboard.cpp    |
-|                                           |
-|  Generic RGB Interface for Asus Sagaris   |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 08/20/2023                        |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusSagarisKeyboard.h"
-#include <vector>
-
-/**------------------------------------------------------------------*\
-    @name Asus Sagaris Keyboard
-    @category Keyboard
-    @type USB
-    @save :robot:
-    @direct :x:
-    @effects :white_check_mark:
-    @detectors DetectAsusSagarisKeyboard
-    @comment Missing controls for modifier keys, as they have independent lighting
-\*-------------------------------------------------------------------*/
-
-#include <iostream>
-
-RGBController_AsusSagarisKeyboard::RGBController_AsusSagarisKeyboard(AsusSagarisKeyboardController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "ASUS Sagaris Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "ASUS Sagaris Keyboard Device";
-    version    = controller->GetVersion();
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Off;
-    Off.name                     = "Off";
-    Off.value                    = SAGARIS_KEYBOARD_MODE_OFF;
-    Off.flags                    = MODE_FLAG_AUTOMATIC_SAVE;
-    Off.color_mode               = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    mode Static;
-    Static.name                  = "Static";
-    Static.value                 = SAGARIS_KEYBOARD_MODE_STATIC;
-    Static.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.brightness_min        = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Static.brightness_max        = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Static.brightness            = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Static.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min            = 1;
-    Static.colors_max            = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Spiral;
-    Spiral.name                  = "Spiral";
-    Spiral.value                 = SAGARIS_KEYBOARD_MODE_SPRIAL;
-    Spiral.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Spiral.brightness_min        = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Spiral.brightness_max        = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Spiral.brightness            = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Spiral.speed_min             = SAGARIS_KEYBOARD_SPEED_MIN;
-    Spiral.speed_max             = SAGARIS_KEYBOARD_SPEED_MAX;
-    Spiral.speed                 = SAGARIS_KEYBOARD_SPEED_DEFAULT;
-    Spiral.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Spiral.colors_min            = 7;
-    Spiral.colors_max            = 7;
-    Spiral.colors.resize(7);
-    modes.push_back(Spiral);
-
-    mode Custom;
-    Custom.name                  = "Custom";
-    Custom.value                 = SAGARIS_KEYBOARD_MODE_CUSTOM;
-    Custom.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Custom.brightness_min        = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Custom.brightness_max        = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Custom.brightness            = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Custom.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Custom.colors_min            = 7;
-    Custom.colors_max            = 7;
-    Custom.colors.resize(7);
-    modes.push_back(Custom);
-
-    mode Breathing;
-    Breathing.name               = "Breathing";
-    Breathing.value              = SAGARIS_KEYBOARD_MODE_BREATHING;
-    Breathing.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED;
-    Breathing.speed_min          = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Breathing.speed_max          = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Breathing.speed              = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Breathing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors_min         = 7;
-    Breathing.colors_max         = 7;
-    Breathing.colors.resize(7);
-    modes.push_back(Breathing);
-
-    mode Reactive;
-    Reactive.name                = "Reactive";
-    Reactive.value               = SAGARIS_KEYBOARD_MODE_REACTIVE;
-    Reactive.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Reactive.brightness_min      = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Reactive.brightness_max      = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Reactive.brightness          = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Reactive.speed_min           = SAGARIS_KEYBOARD_SPEED_MIN;
-    Reactive.speed_max           = SAGARIS_KEYBOARD_SPEED_MAX;
-    Reactive.speed               = SAGARIS_KEYBOARD_SPEED_DEFAULT;
-    Reactive.color_mode          = MODE_COLORS_MODE_SPECIFIC;
-    Reactive.colors_min          = 1;
-    Reactive.colors_max          = 1;
-    Reactive.colors.resize(1);
-    modes.push_back(Reactive);
-
-    mode Starry_Night;
-    Starry_Night.name            = "Starry Night";
-    Starry_Night.value           = SAGARIS_KEYBOARD_MODE_STARRY_NIGHT;
-    Starry_Night.flags           = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Starry_Night.brightness_min  = SAGARIS_KEYBOARD_SPEED_MIN;
-    Starry_Night.brightness_max  = SAGARIS_KEYBOARD_SPEED_MAX;
-    Starry_Night.brightness      = SAGARIS_KEYBOARD_SPEED_DEFAULT;
-    Starry_Night.speed_min       = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Starry_Night.speed_max       = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Starry_Night.speed           = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Starry_Night.color_mode      = MODE_COLORS_MODE_SPECIFIC;
-    Starry_Night.colors_min      = 7;
-    Starry_Night.colors_max      = 7;
-    Starry_Night.colors.resize(7);
-    modes.push_back(Starry_Night);
-
-    mode Laser;
-    Laser.name                   = "Laser";
-    Laser.value                  = SAGARIS_KEYBOARD_MODE_LASER;
-    Laser.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Laser.brightness_min         = SAGARIS_KEYBOARD_SPEED_MIN;
-    Laser.brightness_max         = SAGARIS_KEYBOARD_SPEED_MAX;
-    Laser.brightness             = SAGARIS_KEYBOARD_SPEED_DEFAULT;
-    Laser.speed_min              = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Laser.speed_max              = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Laser.speed                  = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Laser.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    Laser.colors_min             = 7;
-    Laser.colors_max             = 7;
-    Laser.colors.resize(7);
-    modes.push_back(Laser);
-
-    SetupZones();
-
-    sagaris_mode current_mode = controller->GetMode();
-
-    active_mode = current_mode.mode;
-    last_mode   = current_mode.mode;
-    modes[active_mode].brightness = current_mode.brightness;
-    modes[active_mode].speed      = current_mode.speed;
-
-    current_colors = controller->GetColors();
-
-    for(int i = 0; i < modes[active_mode].colors.size(); i++)
-    {
-        modes[active_mode].colors[i] = current_colors[i];
-    }
-}
-
-RGBController_AsusSagarisKeyboard::~RGBController_AsusSagarisKeyboard()
-{
-    delete controller;
-}
-
-void RGBController_AsusSagarisKeyboard::SetupZones()
-{
-    zone keyboard;
-    keyboard.name               = "Keyboard";
-    keyboard.type               = ZONE_TYPE_SINGLE;
-    keyboard.leds_min           = 1;
-    keyboard.leds_max           = 1;
-    keyboard.leds_count         = 1;
-    keyboard.matrix_map         = nullptr;
-
-    SetupColors();
-}
-
-void RGBController_AsusSagarisKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
-void RGBController_AsusSagarisKeyboard::DeviceUpdateLEDs()
-{
-
-}
-
-void RGBController_AsusSagarisKeyboard::UpdateZoneLEDs(int /*zone*/)
-{
-
-}
-
-void RGBController_AsusSagarisKeyboard::UpdateSingleLED(int led)
-{
-    
-}
-
-void RGBController_AsusSagarisKeyboard::DeviceUpdateMode()
-{
-    if(last_mode != active_mode)
-    {
-        last_mode = active_mode;
-        for(int i = 0; i < modes[active_mode].colors.size(); i++)
-        {
-            modes[active_mode].colors[i] = current_colors[i];
-        }
-    }
-    else
-    {
-        for(int i = 0; i < modes[active_mode].colors.size(); i++)
-        {
-            current_colors[i] = modes[active_mode].colors[i];
-        }
-
-        for(int i = 0; i < modes[active_mode].colors.size(); i++)
-        {
-            /*-----------------------------------------*\
-            | This device uses 4bit colorValues (0-16)  |
-            \*-----------------------------------------*/
-            uint8_t red     = RGBGetRValue(modes[active_mode].colors[i]) / 16;
-            uint8_t green   = RGBGetGValue(modes[active_mode].colors[i]) / 16;
-            uint8_t blue    = RGBGetBValue(modes[active_mode].colors[i]) / 16;
-
-            controller->SetColor(i, red, green, blue);
-        }
-    }
-
-    /*------------------------------------------------------------------------------------------------------*\
-    | This device uses a global color storage for 7 colors,                                                  |
-    | each time a mode is selected, it is specified which color is chosen (some use all).                    |
-    | As OpenRGB doesn't support selecting the color index, color 1 is used for single color modes.          |
-    \*------------------------------------------------------------------------------------------------------*/
-
-    uint8_t colorIndex = 0;
-
-    uint8_t mode = modes[active_mode].value;
-
-    if(mode == SAGARIS_KEYBOARD_MODE_STARRY_NIGHT) colorIndex = 7;
-
-    controller->SetMode(mode, modes[active_mode].brightness, modes[active_mode].speed, colorIndex);
-}

Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.h

@@ -1,34 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusSagarisKeyboard.h     |
-|                                           |
-|  Generic RGB Interface for Asus Sagaris  |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 08/20/2023                        |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusSagarisKeyboardController.h"
-
-class RGBController_AsusSagarisKeyboard : public RGBController
-{
-public:
-    RGBController_AsusSagarisKeyboard(AsusSagarisKeyboardController* controller_ptr);
-    ~RGBController_AsusSagarisKeyboard();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AsusSagarisKeyboardController*  controller;
-    std::vector<RGBColor>           current_colors;
-    uint8_t                         last_mode;
-};

Controllers/AsusTUFLaptopController/AsusTUFLaptopController.cpp

@@ -1,330 +0,0 @@
-#ifdef _WIN32
-
-#include "AsusTUFLaptopController.h"
-
-#include <Objbase.h>
-#include <setupapi.h>
-#include <comdef.h>
-#include <Wbemidl.h>
-
-#include <cstdint>
-#include <cstring>
-#include <cstdio>
-
-static bool coInitialized = 0;
-
-static GUID CLSID_GUID_DEVCLASS_SYSTEM = { 0x4D36E97D, 0xE325, 0x11CE, {0xBF, 0xC1, 0x08, 0x00, 0x2B, 0xE1, 0x03, 0x18 } };
-
-int AsusTUFLaptopController::checkWMIType()
-{
-    int n;
-    int v6;
-    int result = 0;
-    struct _SP_DEVINFO_DATA DeviceInfoData;
-    const int bufsize = 260;
-    wchar_t PropertyBuffer[bufsize];
-
-    HDEVINFO devinfo = SetupDiGetClassDevsW(&CLSID_GUID_DEVCLASS_SYSTEM, 0, 0, 2u);
-    if ( devinfo == HDEVINFO(-1) )
-    {
-        return 0;
-    }
-    n = 0;
-    DeviceInfoData.cbSize = sizeof(DeviceInfoData);
-
-    while ( SetupDiEnumDeviceInfo(devinfo, n, &DeviceInfoData) ) // Invalid buffer
-    {
-        if ( SetupDiGetDeviceRegistryPropertyW(devinfo,
-                                               &DeviceInfoData,
-                                               SPDRP_ENUMERATOR_NAME,
-                                               NULL,
-                                               PBYTE(PropertyBuffer),
-                                               sizeof(PropertyBuffer),
-                                               0) )
-        {
-            // If we found property "ACPI"
-            if(!wcscmp(PropertyBuffer, L"ACPI"))
-            {
-                memset(PropertyBuffer, 0, sizeof(PropertyBuffer));
-                if ( SetupDiGetDeviceInstanceIdW(devinfo, &DeviceInfoData, PropertyBuffer, bufsize, 0) )
-                {
-                    _wcsupr_s(PropertyBuffer, bufsize);
-                    if(wcsstr(PropertyBuffer, L"ACPI\\ATK0100"))
-                    {
-                        result = 1;
-                        break;
-                    }
-                    if(!wcscmp(PropertyBuffer, L"ACPI\\PNP0C14\\ATK"))
-                    {
-                        result = 2;
-                        break;
-                    }
-                }
-            }
-        }
-        ++n;
-    }
-    SetupDiDestroyDeviceInfoList(devinfo);
-    return result;
-}
-
-AsusTUFLaptopController::AsusTUFLaptopController()
-{
-    hDevice = CreateFileW(L"\\\\.\\ATKACPI", 0xC0000000, 3u, 0, 3u, 0, 0);
-}
-
-AsusTUFLaptopController* AsusTUFLaptopController::checkAndCreate()
-{
-    // This might cause issues when coInitialize() is used in multiple places
-    HRESULT init = CoInitializeEx(0, COINIT_APARTMENTTHREADED);
-    if ( init < 0 && init != 0x80010106 )
-        return 0;
-    coInitialized = 1;
-
-    int type = checkWMIType();
-    if ( type == 2 )
-    {
-        AsusTUFLaptopController* controller = new AsusTUFLaptopController();
-        if(controller->hDevice != HANDLE(-1))
-        {
-            return controller;
-        }
-        delete controller;
-    }
-    return nullptr;
-}
-
-AsusTUFLaptopController::~AsusTUFLaptopController()
-{
-    if ( hDevice && hDevice != HANDLE(-1) )
-    {
-        CloseHandle(hDevice);
-        hDevice = 0;
-    }
-    // This might cause issues when coInitialize() is used in multiple places
-    if ( coInitialized )
-    {
-        CoUninitialize();
-        coInitialized = 0;
-    }
-
-}
-
-bool AsusTUFLaptopController::deviceIoControlWrapper(const void *dataIn, int commandIndex, int dataSizeIn, void *dataOut, int *dataSizeOut)
-{
-    size_t BytesReturned;
-    const int bufsize = 1024;
-    char outBuffer[bufsize];
-
-    LPDWORD inBuffer = LPDWORD(malloc(dataSizeIn + 8));
-    inBuffer[0] = commandIndex;
-    inBuffer[1] = dataSizeIn;
-    memmove(inBuffer + 2, dataIn, dataSizeIn);
-    memset(outBuffer, 0, bufsize);
-    BytesReturned = 0;
-    bool result = DeviceIoControl(
-                hDevice,
-                0x22240Cu,
-                inBuffer,
-                dataSizeIn + 8,
-                outBuffer,
-                bufsize,
-                LPDWORD(&BytesReturned),
-                0);
-    if ( result )
-    {
-        if ( *dataSizeOut < BytesReturned )
-        {
-            BytesReturned = *dataSizeOut;
-        }
-        memmove(dataOut, outBuffer, BytesReturned);
-    }
-    free(inBuffer);
-    return result;
-}
-
-bool AsusTUFLaptopController::deviceControl(int a1, int a2)
-{
-    if ( hDevice && hDevice != HANDLE(-1) )
-    {
-        int data[2];
-        data[0] = a1;
-        data[1] = a2;
-        int result;
-        int outBufSize = 4;
-        if ( deviceIoControlWrapper(&data, 1398162756, 8, &result, &outBufSize) )
-        {
-            if(outBufSize < 4)
-            {
-                result = 0;
-            }
-            if ( result == 1 )
-            {
-                return 1;
-            }
-        }
-    }
-    return 0;
-}
-
-bool AsusTUFLaptopController::deviceControl(int a1, int a2, int a3)
-{
-    unsigned int data[3];
-    data[0] = a1;
-    data[1] = a2;
-    data[2] = a3;
-    int outBuf;
-    int outBufSize = 4;
-
-    if ( hDevice && hDevice != HANDLE(-1) )
-    {
-        if ( deviceIoControlWrapper(data, 0x53564544, 12, &outBuf, &outBufSize) )
-        {
-            if(outBufSize < 4)
-            {
-                outBuf = 0;
-            }
-            if ( outBuf == 1 )
-            {
-                return 1;
-            }
-        }
-    }
-    return 0;
-}
-
-bool AsusTUFLaptopController::getStatus(int a1, int *out)
-{
-    int status;
-    int statusSize = 4;
-
-    if ( !hDevice || hDevice == HANDLE(-1) || (!deviceIoControlWrapper(&a1, 1398035268, 4, &status, &statusSize)) )
-    {
-        return 0;
-    }
-    if(statusSize < 4)
-    {
-        status = 0;
-    }
-    *out = status;
-    return 1;
-}
-
-bool AsusTUFLaptopController::getStatusExtended(int a1, int a2, int *status1, int *status2, int* status3)
-{
-    int commandData[2];
-    commandData[0] = a1;
-    commandData[1] = a2;
-    int statusBuffer[3];
-    int statusSize = 12;
-
-    if ( hDevice && hDevice != HANDLE(-1)
-         && deviceIoControlWrapper(commandData, 1398035268, 8, statusBuffer, &statusSize) )
-    {
-        *status1 = statusBuffer[0];
-        *status2 = statusBuffer[1];
-        *status3 = statusBuffer[2];
-        return 1;
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-void AsusTUFLaptopController::setMode(unsigned char red,
-                                      unsigned char green,
-                                      unsigned char blue,
-                                      unsigned char mode,
-                                      unsigned char speed,
-                                      bool save)
-{
-
-    /*--------------------------------------------------------*\
-    | Use switch case since our speed values are magic numbers |
-    | Default to Medium/Normal speed                           |
-    \*--------------------------------------------------------*/
-    unsigned char speed_val;
-
-    switch(speed)
-    {
-    case(1):
-        speed_val = ASUS_WMI_KEYBOARD_SPEED_SLOW;
-        break;
-    default:
-    case(2):
-        speed_val = ASUS_WMI_KEYBOARD_SPEED_NORMAL;
-        break;
-    case(3):
-        speed_val = ASUS_WMI_KEYBOARD_SPEED_FAST;
-        break;
-    }
-
-
-    /*----------------------------------------------------------*\
-    | We need to use a magic value to save to firmware in order  |
-    | To persist reboots. Save is normal op with different magic |
-    \*---------------------------------------------------------*/
-    unsigned char save_val = ASUS_WMI_KEYBOARD_MAGIC_USE;
-
-    if (save)
-    {
-        save_val = ASUS_WMI_KEYBOARD_MAGIC_SAVE;
-    }
-
-    // B3 is store value
-    unsigned int high = save_val | (mode<<8) | (red<<16) | (green<<24);
-    unsigned int low  = blue | (speed_val<<8);
-
-    deviceControl(ASUS_WMI_DEVID_TUF_RGB_MODE, high, low);
-
-}
-
-unsigned char AsusTUFLaptopController::getBrightness()
-{
-    int backlight_state = 0;
-    getStatus(ASUS_WMI_DEVID_KBD_BACKLIGHT, &backlight_state);
-
-    /*----------------------------------------------*\
-    | Only lowest two bits indicate brightness level |
-    \*----------------------------------------------*/
-    return backlight_state & 0x7F;
-}
-
-void AsusTUFLaptopController::setBrightness(unsigned char brightness)
-{
-    /*-----------------------------------------------------*\
-    | Only calls in this format persistently set brightness |
-    \*-----------------------------------------------------*/
-    int ctrl_param = 0x80 | (brightness & 0x7F);
-    deviceControl(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param);
-}
-
-/*-----------------------------------------------------------*\
-| These settings will not persist a reboot unless save is set |
-\*-----------------------------------------------------------*/
-void AsusTUFLaptopController::setPowerState(bool boot,
-                                            bool awake,
-                                            bool sleep,
-                                            bool shutdown,
-                                            bool save)
-{
-    unsigned int state = 0xBD;
-
-    if (boot)     state = state | ASUS_WMI_KEYBOARD_POWER_BOOT;
-    if (awake)    state = state | ASUS_WMI_KEYBOARD_POWER_AWAKE;
-    if (sleep)    state = state | ASUS_WMI_KEYBOARD_POWER_SLEEP;
-    if (shutdown) state = state | ASUS_WMI_KEYBOARD_POWER_SHUTDOWN;
-
-    if (save)     state = state | ASUS_WMI_KEYBOARD_POWER_SAVE;
-
-    deviceControl(ASUS_WMI_DEVID_TUF_RGB_STATE, state);
-}
-
-void AsusTUFLaptopController::setFanMode(int mode)
-{
-    deviceControl(ASUS_WMI_DEVID_FAN_BOOST_MODE, mode);
-}
-
-
-#endif

Controllers/AsusTUFLaptopController/AsusTUFLaptopController.h

@@ -1,82 +0,0 @@
-#ifndef ASUSTUFLAPTOPCONTROLLER_H
-#define ASUSTUFLAPTOPCONTROLLER_H
-
-#ifdef _WIN32
-
-#include <windows.h>
-
-#define ASUS_WMI_DEVID_KBD_BACKLIGHT      0x00050021
-#define ASUS_WMI_DEVID_TUF_RGB_MODE       0x00100056
-#define ASUS_WMI_DEVID_TUF_RGB_STATE      0x00100057
-
-#define ASUS_WMI_DEVID_FAN_BOOST_MODE     0x00110018
-#define ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY 0x00120075
-
-#define ASUS_WMI_KEYBOARD_SPEED_SLOW      0xE1
-#define ASUS_WMI_KEYBOARD_SPEED_NORMAL    0xEB
-#define ASUS_WMI_KEYBOARD_SPEED_FAST      0xF5
-
-#define ASUS_WMI_KEYBOARD_SPEED_MIN       1
-#define ASUS_WMI_KEYBOARD_SPEED_MAX       3
-
-#define ASUS_WMI_KEYBOARD_MODE_STATIC     0x00
-#define ASUS_WMI_KEYBOARD_MODE_BREATHING  0x01
-#define ASUS_WMI_KEYBOARD_MODE_COLORCYCLE 0x02
-#define ASUS_WMI_KEYBOARD_MODE_STROBING   0x0A
-
-#define ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN  0
-#define ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX  3
-
-#define ASUS_WMI_KEYBOARD_MAGIC_USE       0xB3
-#define ASUS_WMI_KEYBOARD_MAGIC_SAVE      0xB4
-
-#define ASUS_WMI_KEYBOARD_POWER_BOOT      0x03<<16
-#define ASUS_WMI_KEYBOARD_POWER_AWAKE     0x0C<<16
-#define ASUS_WMI_KEYBOARD_POWER_SLEEP     0x30<<16
-#define ASUS_WMI_KEYBOARD_POWER_SHUTDOWN  0xC0<<16
-
-#define ASUS_WMI_KEYBOARD_POWER_SAVE      0x01<<8
-
-#define ASUS_WMI_FAN_SPEED_NORMAL         0
-#define ASUS_WMI_FAN_SPEED_TURBO          1
-#define ASUS_WMI_FAN_SPEED_SILENT         2
-
-class AsusTUFLaptopController
-{
-private:
-    HANDLE hDevice;
-    static int checkWMIType();
-    AsusTUFLaptopController();
-
-    bool deviceIoControlWrapper(const void *dataIn, int commandIndex, int dataSizeIn, void *dataOut, int *dataSizeOut);
-    bool deviceControl(int a1, int a2);
-    bool deviceControl(int a1, int a2, int a3);
-    bool getStatus(int a1, int *out);
-    bool getStatusExtended(int a1, int a2, int *status1, int *status2, int* status3);
-
-public:
-    static AsusTUFLaptopController * checkAndCreate();
-    ~AsusTUFLaptopController();
-
-    void            setMode(unsigned char red,
-                            unsigned char green,
-                            unsigned char blue,
-                            unsigned char mode,
-                            unsigned char speed,
-                            bool save);
-
-    unsigned char   getBrightness();
-    void            setBrightness(unsigned char brightness);
-
-    void            setPowerState(bool boot,
-                                  bool awake,
-                                  bool sleep,
-                                  bool shutdown,
-                                  bool save);
-
-    void            setFanMode(int mode);
-};
-
-#endif
-
-#endif // ASUSTUFLAPTOPCONTROLLER_H

Controllers/AsusTUFLaptopController/AsusTUFLaptopLinuxController.cpp

@@ -1,51 +0,0 @@
-#include "AsusTUFLaptopLinuxController.h"
-
-#include <string>
-
-void AsusTUFLaptopLinuxController::SendUpdate
-(
-    unsigned char   mode,
-    unsigned char   speed,
-    unsigned char   save,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-)
-{
-    std::string s = "";
-    s.append(ASUS_KBD_BACKLIGHT_BASE_PATH);
-    s.append(ASUS_KBD_BACKLIGHT_MODE_PATH);
-    FILE *controller = fopen(s.c_str(), "w");
-
-    s = "";
-    s.append(std::to_string(save));
-    s.append(" ");
-    s.append(std::to_string(mode));
-    s.append(" ");
-    s.append(std::to_string(red));
-    s.append(" ");
-    s.append(std::to_string(green));
-    s.append(" ");
-    s.append(std::to_string(blue));
-    s.append(" ");
-    s.append(std::to_string(speed));
-
-    fputs(s.c_str(), controller);
-
-    fclose(controller);
-}
-
-void AsusTUFLaptopLinuxController::SendBrightness
-(
-    unsigned char   brightness
-)
-{
-    std::string s = "";
-    s.append(ASUS_KBD_BACKLIGHT_BASE_PATH);
-    s.append(ASUS_KBD_BACKLIGHT_BRIGHTNESS_PATH);
-    FILE *controller = fopen(s.c_str(), "w");
-
-    fputs(std::to_string(brightness).c_str(), controller);
-
-    fclose(controller);
-}

Controllers/AsusTUFLaptopController/AsusTUFLaptopLinuxController.h

@@ -1,37 +0,0 @@
-#ifndef ASUSTUFLAPTOPLINUXCONTROLLER_H
-#define ASUSTUFLAPTOPLINUXCONTROLLER_H
-
-#include "RGBController.h"
-
-#define ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN   0
-#define ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX   3
-#define ASUS_KBD_BACKLIGHT_BRIGHTNESS       3
-
-#define ASUS_KBD_BACKLIGHT_SPEED_MIN        0
-#define ASUS_KBD_BACKLIGHT_SPEED_MAX        2
-#define ASUS_KBD_BACKLIGHT_SPEED            1
-
-#define ASUS_KBD_BACKLIGHT_BASE_PATH        "/sys/devices/platform/asus-nb-wmi/leds/asus::kbd_backlight"
-#define ASUS_KBD_BACKLIGHT_MODE_PATH        "/kbd_rgb_mode"
-#define ASUS_KBD_BACKLIGHT_BRIGHTNESS_PATH  "/brightness"
-
-class AsusTUFLaptopLinuxController
-{
-public:
-    void    SendBrightness
-            (
-            unsigned char   brightness
-            );
-
-    void    SendUpdate
-            (
-            unsigned char   mode,
-            unsigned char   speed,
-            unsigned char   save,
-            unsigned char   red,
-            unsigned char   green,
-            unsigned char   blue
-            );
-};
-
-#endif // ASUSTUFLAPTOPLINUXCONTROLLER_H

Controllers/AsusTUFLaptopController/AsusTUFLaptopLinuxDetect.cpp

@@ -1,28 +0,0 @@
-#include "RGBController_AsusTUFLaptopLinux.h"
-#include "AsusTUFLaptopLinuxController.h"
-
-#include <string>
-#include "Detector.h"
-#include <unistd.h>
-
-static void DetectAsusTUFLaptopLinuxControllers()
-{
-    /*-------------------------------------------------------------------------------------*\
-    | If /sys/devices/platform/asus-nb-wmi/leds/asus::kbd_backlight/kbd_rgb_mode exists,    |
-    |   the kernel support TUF Laptop keyboard LED controlling.                             |
-    \*-------------------------------------------------------------------------------------*/
-
-    std::string s = "";
-    s.append(ASUS_KBD_BACKLIGHT_BASE_PATH);
-    s.append(ASUS_KBD_BACKLIGHT_MODE_PATH);
-
-    if(!access(s.c_str(), F_OK))
-    {
-        AsusTUFLaptopLinuxController*       controller     = new AsusTUFLaptopLinuxController();
-        RGBController_AsusTUFLaptopLinux*   rgb_controller = new RGBController_AsusTUFLaptopLinux(controller);
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-    return;
-}
-
-REGISTER_DETECTOR("ASUS TUF Laptop", DetectAsusTUFLaptopLinuxControllers);

Controllers/AsusTUFLaptopController/AsusTUFLaptopWMIDetect.cpp

@@ -1,13 +1,13 @@
 #ifdef _WIN32
 
-#include "AsusTUFLaptopController.h"
 #include "RGBController_AsusTUFLaptopWMI.h"
 
+#include "acpiwmi.h"
 #include "Detector.h"
 #include "wmi.h"
 #include <string>
 
-static void DetectAsusTUFLaptopWMIControllers()
+static void DetectAsusTUFLaptopWMIControllers(std::vector<RGBController*>&)
 {
     // Try to retrieve ProductID / Device name from WMI; Possibly can be rewritten to use wmi.cpp
     // IF you encounter false detection ( e.g. if your laptop keyboard backlight uses USB interface
@@ -29,21 +29,19 @@ static void DetectAsusTUFLaptopWMIControllers()
         return;
     }
     std::string& name = systemProduct[0]["Name"];
-
     if(name.find("TUF Gaming") == name.npos)
     {
         return;
     }
 
-    AsusTUFLaptopController* controller = AsusTUFLaptopController::checkAndCreate();
-    if(controller)
+    if(AsWMI_Open())
     {
-        RGBController* new_controller = new RGBController_AsusTUFLaptopWMI(controller);
-
+        RGBController* new_controller = new RGBController_AsusTUFLaptopWMI();
         ResourceManager::get()->RegisterRGBController(new_controller);
+        // Success! No more if's
     }
-}   /* DetectAsusTUFLaptopWMIControllers() */
+}   /* DetectFaustusControllers() */
 
-REGISTER_DETECTOR("ASUS TUF Laptop", DetectAsusTUFLaptopWMIControllers);
+REGISTER_DETECTOR("TUF Laptop WMI", DetectAsusTUFLaptopWMIControllers);
 
 #endif

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopLinux.cpp

@@ -1,150 +0,0 @@
-#include "RGBController_AsusTUFLaptopLinux.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus TUF Laptop Linux WMI
-    @category Keyboard
-    @type File Stream
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusTUFLaptopLinuxControllers
-    @comment Tested on ASUS TUF Gaming A15 2022
-    PLEASE UPDATE YOUR KERNEL TO A VERSION NEWER THAN 6.1.0
-
-    Every devices supported by asus-wmi would work technically.
-\*-------------------------------------------------------------------*/
-
-RGBController_AsusTUFLaptopLinux::RGBController_AsusTUFLaptopLinux(AsusTUFLaptopLinuxController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "ASUS TUF Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "Asus TUF Device";
-    location    = ASUS_KBD_BACKLIGHT_BASE_PATH;
-
-    mode Direct;
-    Direct.name                     = "Direct";
-    Direct.value                    = 4;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.brightness_min           = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
-    Direct.brightness_max           = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
-    Direct.brightness               = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name                     = "Static";
-    Static.value                    = 0;
-    Static.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.brightness_min           = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
-    Static.brightness_max           = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
-    Static.brightness               = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
-    Static.color_mode               = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = 1;
-    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.speed_min             = ASUS_KBD_BACKLIGHT_SPEED_MIN;
-    Breathing.speed_max             = ASUS_KBD_BACKLIGHT_SPEED_MAX;
-    Breathing.brightness_min        = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
-    Breathing.brightness_max        = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
-    Breathing.brightness            = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
-    Breathing.color_mode            = MODE_COLORS_PER_LED;
-    Breathing.speed                 = ASUS_KBD_BACKLIGHT_SPEED;
-    modes.push_back(Breathing);
-
-    mode Cycle;
-    Cycle.name                      = "Spectrum Cycle";
-    Cycle.value                     = 2;
-    Cycle.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Cycle.speed_min                 = ASUS_KBD_BACKLIGHT_SPEED_MIN;
-    Cycle.speed_max                 = ASUS_KBD_BACKLIGHT_SPEED_MAX;
-    Cycle.brightness_min            = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
-    Cycle.brightness_max            = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
-    Cycle.brightness                = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
-    Cycle.color_mode                = MODE_COLORS_NONE;
-    Cycle.speed                     = ASUS_KBD_BACKLIGHT_SPEED;
-    modes.push_back(Cycle);
-
-    mode Flashing;
-    Flashing.name                   = "Flashing";
-    Flashing.value                  = 0x0A;
-    Flashing.flags                  = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Flashing.brightness_min         = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
-    Flashing.brightness_max         = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
-    Flashing.brightness             = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
-    Flashing.color_mode             = MODE_COLORS_PER_LED;
-    modes.push_back(Flashing);
-
-    SetupZones();
-}
-
-void RGBController_AsusTUFLaptopLinux::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zone                                               |
-    \*---------------------------------------------------------*/
-    zones.resize(1);
-    zones[0].type           = ZONE_TYPE_SINGLE;
-    zones[0].name           = "Keyboard Backlight zone";
-    zones[0].leds_min       = 1;
-    zones[0].leds_max       = 1;
-    zones[0].leds_count     = 1;
-    zones[0].matrix_map     = NULL;
-
-    /*---------------------------------------------------------*\
-    | Set up LED                                                |
-    \*---------------------------------------------------------*/
-    leds.resize(1);
-    leds[0].name = "Keyboard Backlight LED";
-
-    SetupColors();
-}
-
-void RGBController_AsusTUFLaptopLinux::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AsusTUFLaptopLinux::DeviceUpdateLEDs()
-{
-    uint8_t red   = RGBGetRValue(colors[0]);
-    uint8_t green = RGBGetGValue(colors[0]);
-    uint8_t blue  = RGBGetBValue(colors[0]);
-    uint8_t speed = 0;
-    uint8_t mode  = modes[active_mode].value;
-    uint8_t save  = 1;
-    if(mode == 4)
-    {
-        mode = 0;
-        save = 0;
-    }
-    if(mode == 1 || mode == 2)
-    {
-        speed = modes[active_mode].speed;
-    }
-
-    controller->SendUpdate(mode, speed, save, red, green, blue);
-    controller->SendBrightness(modes[active_mode].brightness);
-}
-
-void RGBController_AsusTUFLaptopLinux::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AsusTUFLaptopLinux::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AsusTUFLaptopLinux::DeviceUpdateMode()
-{
-    DeviceUpdateLEDs();
-}

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopLinux.h

@@ -1,27 +0,0 @@
-#ifndef RGBCONTROLLER_ASUSTUFLAPTOPLINUX_H
-#define RGBCONTROLLER_ASUSTUFLAPTOPLINUX_H
-
-#include "RGBController.h"
-#include "AsusTUFLaptopLinuxController.h"
-
-
-class RGBController_AsusTUFLaptopLinux : public RGBController
-{
-public:
-    RGBController_AsusTUFLaptopLinux(AsusTUFLaptopLinuxController* controller_ptr);
-
-    void SetupZones() override;
-
-    void ResizeZone(int zone, int new_size) override;
-
-    void DeviceUpdateLEDs() override;
-    void UpdateZoneLEDs(int zone) override;
-    void UpdateSingleLED(int led) override;
-
-    void DeviceUpdateMode() override;
-
-private:
-    AsusTUFLaptopLinuxController* controller;
-};
-
-#endif // RGBCONTROLLER_ASUSTUFLAPTOPLINUX_H

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.cpp

@@ -2,6 +2,12 @@
 
 #include "RGBController_AsusTUFLaptopWMI.h"
 
+#include "acpiwmi.h"
+#include "ResourceManager.h"
+#include "Detector.h"
+#include "wmi.h"
+#include <string>
+
 using namespace std::chrono_literals;
 
 /**------------------------------------------------------------------*\
@@ -15,91 +21,72 @@ using namespace std::chrono_literals;
     @comment
 \*-------------------------------------------------------------------*/
 
-RGBController_AsusTUFLaptopWMI::RGBController_AsusTUFLaptopWMI(AsusTUFLaptopController* controller_ptr)
+RGBController_AsusTUFLaptopWMI::RGBController_AsusTUFLaptopWMI()
 {
-    name                        = "ASUS TUF Keyboard";
-    vendor                      = "ASUS";
-    type                        = DEVICE_TYPE_KEYBOARD;
-    description                 = "WMI Device";
-    location                    = "\\\\.\\ATKACPI";
+    name        = "ASUS TUF Keyboard";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "WMI Device";
+    location    = "\\\\.\\ATKACPI";
 
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = ASUS_WMI_KEYBOARD_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Static.color_mode           = MODE_COLORS_PER_LED;
-    Static.brightness_max       = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
-    Static.brightness_min       = ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN;
-    Static.brightness           = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
-    modes.push_back(Static);
+    modes.resize(5);
+    modes[0].name       = "Direct";
+    modes[0].value      = 4;
+    modes[0].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[0].color_mode = MODE_COLORS_PER_LED;
 
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = ASUS_WMI_KEYBOARD_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Breathing.color_mode        = MODE_COLORS_PER_LED;
-    Breathing.speed_min         = ASUS_WMI_KEYBOARD_SPEED_MIN;
-    Breathing.speed_max         = ASUS_WMI_KEYBOARD_SPEED_MAX;
-    Breathing.speed             = 2;
-    Breathing.brightness_max    = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
-    Breathing.brightness_min    = ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN;
-    Breathing.brightness        = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
-    modes.push_back(Breathing);
+    modes[1].name       = "Static";
+    modes[1].value      = 0;
+    modes[1].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[1].color_mode = MODE_COLORS_PER_LED;
 
-    mode ColorCycle;
-    ColorCycle.name             = "Color Cycle";
-    ColorCycle.value            = ASUS_WMI_KEYBOARD_MODE_COLORCYCLE;
-    ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    ColorCycle.color_mode       = MODE_COLORS_NONE;
-    ColorCycle.speed_min        = ASUS_WMI_KEYBOARD_SPEED_MIN;
-    ColorCycle.speed_max        = ASUS_WMI_KEYBOARD_SPEED_MAX;
-    ColorCycle.speed            = 2;
-    ColorCycle.brightness_max   = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
-    ColorCycle.brightness_min   = ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN;
-    ColorCycle.brightness       = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
-    modes.push_back(ColorCycle);
+    modes[2].name       = "Breathing";
+    modes[2].value      = 1;
+    modes[2].flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[2].speed_min  = 0;
+    modes[2].speed_max  = 2;
+    modes[2].color_mode = MODE_COLORS_PER_LED;
+    modes[2].speed      = 1;
 
-    mode Strobing;
-    Strobing.name               = "Strobing";
-    Strobing.value              = ASUS_WMI_KEYBOARD_MODE_STROBING;
-    Strobing.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Strobing.color_mode         = MODE_COLORS_PER_LED;
-    Strobing.brightness_max     = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
-    Strobing.brightness_min     = ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN;
-    Strobing.brightness         = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
-    modes.push_back(Strobing);
+    modes[3].name       = "Color Cycle";
+    modes[3].value      = 2;
+    modes[3].flags      = MODE_FLAG_HAS_SPEED;
+    modes[3].speed_min  = 0;
+    modes[3].speed_max  = 2;
+    modes[3].color_mode = MODE_COLORS_NONE;
+    modes[3].speed      = 1;
+
+    modes[4].name       = "Strobe";
+    modes[4].value      = 0x0A;
+    modes[4].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[4].color_mode = MODE_COLORS_PER_LED;
 
     SetupZones();
-
-    controller = controller_ptr;
-
-    ReadConfiguration();
 }
 
 RGBController_AsusTUFLaptopWMI::~RGBController_AsusTUFLaptopWMI()
 {
-    delete controller;
+    AsWMI_Close();
 }
 
 void RGBController_AsusTUFLaptopWMI::SetupZones()
 {
     /*---------------------------------------------------------*\
-    | Device only has one zone and one led                      |
+    | Set up zone                                               |
     \*---------------------------------------------------------*/
-    zone* new_zone = new zone();
-    led*  new_led  = new led();
+    zones.resize(1);
+    zones[0].type           = ZONE_TYPE_SINGLE;
+    zones[0].name           = "Keyboard Backlight zone";
+    zones[0].leds_min       = 1;
+    zones[0].leds_max       = 1;
+    zones[0].leds_count     = 1;
+    zones[0].matrix_map     = NULL;
 
-    new_zone->type           = ZONE_TYPE_SINGLE;
-    new_zone->name           = "Keyboard Backlight zone";
-    new_zone->leds_min       = 1;
-    new_zone->leds_max       = 1;
-    new_zone->leds_count     = 1;
-    new_zone->matrix_map     = NULL;
-
-    new_led->name            = "Keyboard Backlight LED";
-
-    zones.push_back(*new_zone);
-    leds.push_back(*new_led);
+    /*---------------------------------------------------------*\
+    | Set up LED                                                |
+    \*---------------------------------------------------------*/
+    leds.resize(1);
+    leds[0].name = "Keyboard Backlight LED";
 
     SetupColors();
 }
@@ -111,66 +98,52 @@ void RGBController_AsusTUFLaptopWMI::ResizeZone(int /*zone*/, int /*new_size*/)
     \*---------------------------------------------------------*/
 }
 
-/*---------------------------------------------------------*\
-| Break this function off since we have to call save in the |
-  same operation as doing everything else.                  |
-\*---------------------------------------------------------*/
-void RGBController_AsusTUFLaptopWMI::ControllerSetMode(bool save)
-{
-    unsigned char red   = RGBGetRValue(colors[0]);
-    unsigned char green = RGBGetGValue(colors[0]);
-    unsigned char blue  = RGBGetBValue(colors[0]);
-
-    unsigned char mode  = (unsigned char)modes[(unsigned int)active_mode].value;
-
-    /*------------------------------------------------------------*\
-    | Use speed only if the mode supports it. Otherwise set normal |
-    \*------------------------------------------------------------*/
-    unsigned char speed = ASUS_WMI_KEYBOARD_SPEED_NORMAL;
-
-    if (modes[(unsigned int)active_mode].flags & MODE_FLAG_HAS_SPEED)
-    {
-        speed = (unsigned char)modes[(unsigned int)active_mode].speed;
-    }
-
-    controller->setMode(red, green, blue, mode, speed, save);
-}
-
 void RGBController_AsusTUFLaptopWMI::DeviceUpdateLEDs()
 {
-    ControllerSetMode(false);
+    uint8_t red   = RGBGetRValue(colors[0]);
+    uint8_t green = RGBGetGValue(colors[0]);
+    uint8_t blue  = RGBGetBValue(colors[0]);
+    uint8_t speed_byte = 0;
+    uint8_t mode = modes[active_mode].value;
+    uint8_t inv = 0;
+    if(mode == 4)
+    {
+        mode = 1;
+        inv = 4; // Any invalid mode, i.e. anything other than 0, 1, 2 and 10
+    }
+    if(mode == 1 || mode == 2)
+    {
+        switch(modes[active_mode].speed)
+        {
+        case 0: speed_byte = 0xE1; break;
+        case 1: speed_byte = 0xEB; break;
+        case 2: speed_byte = 0xF5; break;
+        }
+    }
+    int high = ((mode | ((red | (green << 8)) << 8)) << 8) | 0xB3;
+    int low = blue | (speed_byte << 8);
+    AsWMI_NB_DeviceControl_2arg(0x100056, high, low);
+    if(inv)
+    {
+        //std::this_thread::sleep_for(10ms);
+        high = ((inv | ((red | (green << 8)) << 8)) << 8) | 0xB3;
+        AsWMI_NB_DeviceControl_2arg(0x100056, high, low);
+    }
 }
 
 void RGBController_AsusTUFLaptopWMI::UpdateZoneLEDs(int /*zone*/)
 {
-    ControllerSetMode(false);
+    DeviceUpdateLEDs();
 }
 
 void RGBController_AsusTUFLaptopWMI::UpdateSingleLED(int /*led*/)
 {
-    ControllerSetMode(false);
+    DeviceUpdateLEDs();
 }
 
 void RGBController_AsusTUFLaptopWMI::DeviceUpdateMode()
 {
-    if (modes[(unsigned int)active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS)
-    {
-        controller->setBrightness((unsigned char)modes[(unsigned int)active_mode].brightness);
-    }
-    ControllerSetMode(false);
-}
-
-void RGBController_AsusTUFLaptopWMI::ReadConfiguration()
-{
-    if (modes[(unsigned int)active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS)
-    {
-        modes[(unsigned int)active_mode].brightness = controller->getBrightness();
-    }
-}
-
-void RGBController_AsusTUFLaptopWMI::DeviceSaveMode()
-{
-    ControllerSetMode(true);
+    DeviceUpdateLEDs();
 }
 
 #endif

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.h

@@ -1,35 +1,27 @@
-#ifdef _WIN32
-
 #ifndef RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
 #define RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
 
-#include "AsusTUFLaptopController.h"
+#ifdef _WIN32
+
 #include "RGBController.h"
 
 class RGBController_AsusTUFLaptopWMI : public RGBController
 {
 public:
-    RGBController_AsusTUFLaptopWMI(AsusTUFLaptopController* controller_ptr);
+    RGBController_AsusTUFLaptopWMI();
     virtual ~RGBController_AsusTUFLaptopWMI();
 
-    void SetupZones();
+    void SetupZones() override;
 
-    void ResizeZone(int zone, int new_size);
+    void ResizeZone(int zone, int new_size) override;
 
-    void DeviceUpdateLEDs();
-    void UpdateZoneLEDs(int zone);
-    void UpdateSingleLED(int led);
+    void DeviceUpdateLEDs() override;
+    void UpdateZoneLEDs(int zone) override;
+    void UpdateSingleLED(int led) override;
 
-    void DeviceUpdateMode();
-    void DeviceSaveMode();
-
-private:
-    AsusTUFLaptopController* controller;
-
-    void ReadConfiguration();
-    void ControllerSetMode(bool save);
+    void DeviceUpdateMode() override;
 };
 
-#endif // RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
+#endif
 
-#endif // _WIN32
+#endif // RGBCONTROLLER_ASUSTUFLAPTOPWMI_H

Controllers/BlinkyTapeController/BlinkyTapeControllerDetect.cpp

@@ -2,6 +2,7 @@
 #include "BlinkyTapeController.h"
 #include "RGBController.h"
 #include "RGBController_BlinkyTape.h"
+#include "SettingsManager.h"
 #include "find_usb_serial_port.h"
 #include <vector>
 #include <stdio.h>
@@ -18,7 +19,7 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectBlinkyTapeControllers()
+void DetectBlinkyTapeControllers(std::vector<RGBController*> &rgb_controllers)
 {
     std::vector<std::string *> device_locations = find_usb_serial_port(BLINKINLABS_VID, BLINKYTAPE_PID);
 
@@ -28,7 +29,7 @@ void DetectBlinkyTapeControllers()
         controller->Initialize(*device_locations[device_idx]);
 
         RGBController_BlinkyTape* rgb_controller = new RGBController_BlinkyTape(controller);
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        rgb_controllers.push_back(rgb_controller);
     }
 }
 

Controllers/CherryKeyboardController/CherryKeyboardController.cpp

@@ -1,262 +0,0 @@
-/*-----------------------------------------*\
-|  CherryKeyboardController.cpp             |
-|                                           |
-|  Driver for Cherry RGB keyboard lighting  |
-|  controller                               |
-|                                           |
-|  Sebastian Kraus 12/25/2021               |
-\*-----------------------------------------*/
-
-#include "CherryKeyboardController.h"
-
-#include <cstring>
-
-CherryKeyboardController::CherryKeyboardController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-CherryKeyboardController::~CherryKeyboardController()
-{
-    hid_close(dev);
-}
-
-std::string CherryKeyboardController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string CherryKeyboardController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-void CherryKeyboardController::SetKeyboardColors
-    (
-    unsigned char *     color_data,
-    unsigned int        size
-    )
-{
-    unsigned int    packet_size = 0;
-    unsigned int    packet_offset = 0;
-
-    while(size > 0)
-    {
-        if(size >= CHERRY_KB_MAX_PACKET_SIZE)
-        {
-            packet_size     = CHERRY_KB_MAX_PACKET_SIZE;
-        }
-        else
-        {
-            packet_size     = size;
-        }
-        
-        SendKeyboardData
-            (
-            &color_data[packet_offset],
-            packet_size,
-            packet_offset
-            );
-
-        size           -= packet_size;
-        packet_offset  += packet_size;
-    }
-}
-
-void CherryKeyboardController::SendKeyboardMode
-    (
-    unsigned char       mode
-    )
-{
-    SendKeyboardParameter(CHERRY_KB_PARAMETER_MODE, 1, &mode);
-}
-
-void CherryKeyboardController::SendKeyboardModeEx
-    (
-    unsigned char       mode,
-    unsigned char       brightness,
-    unsigned char       speed,
-    unsigned char       direction,
-    unsigned char       random_flag,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-    )
-{
-    unsigned char parameter_data[8];
-
-    parameter_data[0]   = mode;
-    parameter_data[1]   = brightness;
-    parameter_data[2]   = speed;
-    parameter_data[3]   = direction;
-    parameter_data[4]   = random_flag;
-    parameter_data[5]   = red;
-    parameter_data[6]   = green;
-    parameter_data[7]   = blue;
-
-    SendKeyboardParameter(0, 8, parameter_data);
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void CherryKeyboardController::ComputeChecksum
-    (
-    char                usb_buf[CHERRY_KB_PACKET_SIZE]
-    )
-{
-    unsigned short checksum = 0;
-
-    for(unsigned int byte_idx = 0x03; byte_idx < CHERRY_KB_PACKET_SIZE; byte_idx++)
-    {
-        checksum += usb_buf[byte_idx];
-    }
-
-    usb_buf[0x01] = checksum & 0xFF;
-    usb_buf[0x02] = checksum >> 8;
-}
-
-void CherryKeyboardController::SendKeyboardBegin()
-{
-    unsigned char usb_buf[CHERRY_KB_PACKET_SIZE];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Keyboard Begin (0x01) packet                   |
-    |   Note: Not computing checksum as packet contents are |
-    |         fixed                                         |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x04;
-    usb_buf[0x01]           = CHERRY_KB_COMMAND_BEGIN;
-    usb_buf[0x02]           = 0x00;
-    usb_buf[0x03]           = CHERRY_KB_COMMAND_BEGIN;
-    
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, CHERRY_KB_PACKET_SIZE);
-    hid_read(dev, usb_buf, CHERRY_KB_PACKET_SIZE);
-}
-
-void CherryKeyboardController::SendKeyboardEnd()
-{
-    char usb_buf[CHERRY_KB_PACKET_SIZE];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Keyboard End (0x02) packet                     |
-    |   Note: Not computing checksum as packet contents are |
-    |         fixed                                         |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x04;
-    usb_buf[0x01]           = CHERRY_KB_COMMAND_END;
-    usb_buf[0x02]           = 0x00;
-    usb_buf[0x03]           = CHERRY_KB_COMMAND_END;
-    
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
-    hid_read(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
-}
-
-void CherryKeyboardController::SendKeyboardData
-    (
-    unsigned char *     data,
-    unsigned char       data_size,
-    unsigned short      data_offset
-    )
-{
-    char usb_buf[CHERRY_KB_PACKET_SIZE];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Keyboard Color Data (0x0B) packet              |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x04;
-    usb_buf[0x03]           = CHERRY_KB_COMMAND_WRITE_CUSTOM_COLOR_DATA;
-
-    usb_buf[0x04]           = data_size;
-    usb_buf[0x05]           = data_offset & 0x00FF;
-    usb_buf[0x06]           = data_offset >> 8;
-
-    /*-----------------------------------------------------*\
-    | Copy in data bytes                                    |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x08], data, data_size);
-    
-    /*-----------------------------------------------------*\
-    | Compute Checksum                                      |
-    \*-----------------------------------------------------*/
-    ComputeChecksum(usb_buf);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
-    hid_read(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
-}
-
-void CherryKeyboardController::SendKeyboardParameter
-    (
-    unsigned char       parameter,
-    unsigned char       parameter_size,
-    unsigned char*      parameter_data
-    )
-{
-    char usb_buf[CHERRY_KB_PACKET_SIZE];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Keyboard Parameter (0x06) packet               |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x04;
-    usb_buf[0x03]           = CHERRY_KB_COMMAND_SET_PARAMETER;
-    usb_buf[0x04]           = parameter_size;
-    usb_buf[0x05]           = parameter;
-
-    /*-----------------------------------------------------*\
-    | Copy in data bytes                                    |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x09], parameter_data, parameter_size);
-
-    /*-----------------------------------------------------*\
-    | Compute Checksum                                      |
-    \*-----------------------------------------------------*/
-    ComputeChecksum(usb_buf);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
-    hid_read(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
-}

Controllers/CherryKeyboardController/CherryKeyboardController.h

@@ -1,150 +0,0 @@
-/*-----------------------------------------*\
-|  CherryKeyboardController.h               |
-|                                           |
-|  Definitions and types for Cherry RGB     |
-|  keyboard lighting controller             |
-|                                           |
-|  Sebastian Kraus 12/25/2021               |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-#define CHERRY_KB_PACKET_SIZE                        64
-#define CHERRY_KB_MAX_PACKET_SIZE                  ( 0x36 )/* max packet size for color*/
-                                                            /* update packets           */
-enum
-{
-    CHERRY_KB_COMMAND_BEGIN                        = 0x01, /* Begin packet command     */
-    CHERRY_KB_COMMAND_END                          = 0x02, /* End packet command       */
-    CHERRY_KB_COMMAND_SET_PARAMETER                = 0x06, /* Set parameter command    */
-    CHERRY_KB_COMMAND_READ_CUSTOM_COLOR_DATA       = 0x1B, /* Read custom color data   */
-    CHERRY_KB_COMMAND_WRITE_CUSTOM_COLOR_DATA      = 0x0B, /* Write custom color data  */
-};
-
-enum
-{
-    CHERRY_KB_PARAMETER_MODE                       = 0x00, /* Mode parameter           */
-    CHERRY_KB_PARAMETER_BRIGHTNESS                 = 0x01, /* Brightness parameter     */
-    CHERRY_KB_PARAMETER_SPEED                      = 0x02, /* Speed parameter          */
-    CHERRY_KB_PARAMETER_DIRECTION                  = 0x03, /* Direction parameter      */
-    CHERRY_KB_PARAMETER_RANDOM_COLOR_FLAG          = 0x04, /* Random color parameter   */
-    CHERRY_KB_PARAMETER_MODE_COLOR                 = 0x05, /* Mode color (RGB)         */
-    CHERRY_KB_PARAMETER_POLLING_RATE               = 0x0F, /* Polling rate             */
-    CHERRY_KB_PARAMETER_SURMOUNT_MODE_COLOR        = 0x11, /* Surmount mode color      */
-};
-
-enum
-{
-    CHERRY_KB_MODE_WAVE                            = 0x00,
-    CHERRY_KB_MODE_SPECTRUM                        = 0x01,
-    CHERRY_KB_MODE_BREATHING                       = 0x02,
-    CHERRY_KB_MODE_STATIC                          = 0x03,
-    CHERRY_KB_MODE_RADAR                           = 0x04,
-    CHERRY_KB_MODE_VORTEX                          = 0x05,
-    CHERRY_KB_MODE_FIRE                            = 0x06,
-    CHERRY_KB_MODE_STARS                           = 0x07,
-    CHERRY_KB_MODE_CUSTOM                          = 0x08,
-    CHERRY_KB_MODE_ROLLING                         = 0x0A,
-    CHERRY_KB_MODE_RAIN                            = 0x0B,
-    CHERRY_KB_MODE_CURVE                           = 0x0C,
-    CHERRY_KB_MODE_WAVE_MID                        = 0x0E,
-    CHERRY_KB_MODE_SCAN                            = 0x0F,
-    CHERRY_KB_MODE_RADIATION                       = 0x12,
-    CHERRY_KB_MODE_RIPPLES                         = 0x13,
-    CHERRY_KB_MODE_SINGLE_KEY                      = 0x15,
-    
-};
-
-enum
-{
-    CHERRY_KB_BRIGHTNESS_LOWEST                    = 0x00, /* Lowest brightness (off)  */
-    CHERRY_KB_BRIGHTNESS_HIGHEST                   = 0x04, /* Highest brightness       */
-};
-
-enum
-{
-    CHERRY_KB_SPEED_SLOWEST                        = 0x04, /* Slowest speed setting    */
-    CHERRY_KB_SPEED_NORMAL                         = 0x02, /* Normal speed setting     */
-    CHERRY_KB_SPEED_FASTEST                        = 0x00, /* Fastest speed setting    */
-};
-
-enum
-{
-    CHERRY_KB_SURMOUNT_MODE_COLOR_RED              = 0x01, /* Red surmount color       */
-    CHERRY_KB_SURMOUNT_MODE_COLOR_YELLOW           = 0x02, /* Yellow surmount color    */
-    CHERRY_KB_SURMOUNT_MODE_COLOR_GREEN            = 0x03, /* Green surmount color     */
-    CHERRY_KB_SURMOUNT_MODE_COLOR_BLUE             = 0x04, /* Blue surmount color      */
-};
-
-enum
-{
-    CHERRY_KB_POLLING_RATE_125HZ                   = 0x00, /* 125Hz polling rate       */
-    CHERRY_KB_POLLING_RATE_250HZ                   = 0x01, /* 250Hz polling rate       */
-    CHERRY_KB_POLLING_RATE_500HZ                   = 0x02, /* 500Hz polling rate       */
-    CHERRY_KB_POLLING_RATE_1000HZ                  = 0x03, /* 1000Hz polling rate      */
-};
-
-class CherryKeyboardController
-{
-public:
-    CherryKeyboardController(hid_device* dev_handle, const char* path);
-    ~CherryKeyboardController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void        SetKeyboardColors
-                    (
-                    unsigned char *     color_data,
-                    unsigned int        size
-                    );
-
-    void        SendKeyboardBegin();
-
-    void        SendKeyboardMode
-                    (
-                    unsigned char       mode
-                    );
-
-    void        SendKeyboardModeEx
-                    (
-                    unsigned char       mode,
-                    unsigned char       brightness,
-                    unsigned char       speed,
-                    unsigned char       direction,
-                    unsigned char       random_flag,
-                    unsigned char       red,
-                    unsigned char       green,
-                    unsigned char       blue
-                    );
-
-    void        SendKeyboardData
-                    (
-                    unsigned char *     data,
-                    unsigned char       data_size,
-                    unsigned short      data_offset
-                    );
-
-    void        SendKeyboardEnd();
-
-private:
-    hid_device*             dev;
-    std::string             location;
-
-    void        ComputeChecksum
-                    (
-                    char                usb_buf[CHERRY_KB_PACKET_SIZE]
-                    );
-
-    void        SendKeyboardParameter
-                    (
-                    unsigned char       parameter,
-                    unsigned char       parameter_size,
-                    unsigned char*      parameter_data
-                    );
-};

Controllers/CherryKeyboardController/CherryKeyboardControllerDetect.cpp

@@ -1,80 +0,0 @@
-#include "Detector.h"
-#include "CherryKeyboardController.h"
-#include "RGBController.h"
-#include "RGBController_CherryKeyboard.h"
-#include <vector>
-#include <hidapi/hidapi.h>
-
-/*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
-\*-----------------------------------------------------*/
-#define CHERRY_KEYBOARD_VID             0x046A
-#define CHERRY_KEYBOARD_USAGE_PAGE      0xFF1C
-#define MX_BOARD_3_0S_FL_NBL_PID        0x0077
-#define MX_BOARD_3_0S_FL_RGB_PID        0x0079
-#define MX_BOARD_3_0S_FL_RGB_KOR_PID    0x0083
-#define MX_1_0_FL_BL_PID                0x00AB
-#define MX_BOARD_1_0_TKL_RGB_PID        0x00AC
-#define MX_BOARD_8_0_TKL_RGB_PID        0x00B7
-#define MX_BOARD_10_0_FL_RGB_PID        0x00BB
-#define G80_3000_TKL_NBL_PID            0x00C3
-#define MX_BOARD_2_0S_FL_RGB_PID        0x00C4
-#define G80_3000_TKL_RGB_PID            0x00C5
-#define MV_BOARD_3_0FL_RGB_PID          0x00C7
-#define CCF_MX_8_0_TKL_BL_PID           0x00C9
-#define CCF_MX_1_0_TKL_BL_PID           0x00CA
-#define CCF_MX_1_0_TKL_NBL_PID          0x00CB
-#define G30_3000_TKL_NBL_KOR_PID        0x00CD
-#define MX_BOARD_2_0S_FL_NBL_PID        0x00CE
-#define MX_1_0_FL_NBL_PID               0x00D2
-#define MX_1_0_FL_RGB_PID               0x00D3
-#define G80_3000N_TKL_RGB_PID           0x00DD
-#define G30_3000N_FL_RGB_PID            0x00DE
-#define MX_BOARD_10_0N_FL_RGB_PID       0x00DF
-#define MX_BOARD_2_0S_FL_RGB_DE_PID     0x01A6
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCherryKeyboards                                                                 *
-*                                                                                          *
-*       Tests the USB address to see if an Cherry RGB Keyboard controller exists there.   *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCherryKeyboards(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        CherryKeyboardController* controller = new CherryKeyboardController(dev, info->path);
-        RGBController_CherryKeyboard* rgb_controller = new RGBController_CherryKeyboard(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-/*---------------------------------------------------------------------------------------------------------------------------------------------*\
-| Keyboards                                                                                                                                     |
-\*---------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 3.0S FL NBL",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_3_0S_FL_NBL_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 3.0S FL RGB",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_3_0S_FL_RGB_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 3.0S FL RGB KOREAN", DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_3_0S_FL_RGB_KOR_PID, 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX 1.0 FL BL",                DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_1_0_FL_BL_PID            , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 1.0 TKL RGB",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_1_0_TKL_RGB_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 8.0 TKL RGB",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_8_0_TKL_RGB_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 10.0 FL RGB",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_10_0_FL_RGB_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000 TKL NBL",            DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G80_3000_TKL_NBL_PID        , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 2.0S FL RGB",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_2_0S_FL_RGB_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000 TKL RGB",            DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G80_3000_TKL_RGB_PID        , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MV BOARD 3.0 FL RGB",         DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MV_BOARD_3_0FL_RGB_PID      , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard CCF MX 8.0 TKL BL",           DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   CCF_MX_8_0_TKL_BL_PID       , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard CCF MX 1.0 TKL BL",           DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   CCF_MX_1_0_TKL_BL_PID       , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard CCF MX 1.0 TKL NBL",          DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   CCF_MX_1_0_TKL_NBL_PID      , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000 TKL NBL KOREAN",     DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G30_3000_TKL_NBL_KOR_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 2.0S FL NBL",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_2_0S_FL_NBL_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX 1.0 FL NBL",               DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_1_0_FL_NBL_PID           , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX 1.0 FL RGB",               DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_1_0_FL_RGB_PID           , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000N TKL RGB",           DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G80_3000N_TKL_RGB_PID       , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000N FL RGB",            DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G30_3000N_FL_RGB_PID        , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 10.0N FL RGB",       DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_10_0N_FL_RGB_PID   , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 2.0S FL RGB DE",     DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_2_0S_FL_RGB_DE_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);

Controllers/CherryKeyboardController/RGBController_CherryKeyboard.cpp

@@ -1,358 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_CherryKeyboard.cpp         |
-|                                           |
-|  Generic RGB Interface for Cherry RGB     |
-|  Keyboard                                 |
-|                                           |
-|  Sebastian Kraus 12/25/2021               |
-\*-----------------------------------------*/
-
-#include "RGBController_CherryKeyboard.h"
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-static unsigned int matrix_map[6][23] =
-    { {  0,  NA,  12,  18,  24,  30,  36,  42,  48,  54,  60,  66,  72,  78,  84,  90,  96,  NA,  NA,  NA,  NA,  NA,  NA },
-      {  1,   7,  13,  19,  25,  31,  37,  43,  49,  55,  61,  67,  73,  79,  85,  91,  97,  NA,  NA,  NA,  NA,  NA,  NA },
-      {  2,   8,  14,  20,  26,  32,  38,  44,  50,  56,  62,  68,  74,  NA,  86,  92,  98,  NA,  NA,  NA,  NA,  NA,  NA },
-      {  3,   9,  15,  21,  27,  33,  39,  45,  51,  57,  63,  69,  75,  81,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
-      {  4,  10,  16,  22,  28,  34,  40,  46,  52,  58,  64,  70,  NA,  82,  NA,  94,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
-      {  5,  11,  17,  NA,  NA,  NA,  41,  NA,  NA,  NA,  65,  71,  77,  83,  89,  95, 101,  NA,  NA,  NA,  NA,  NA,  NA } };
-
-/**------------------------------------------------------------------*\
-    @name Cherry Keyboard
-    @category Keyboard
-    @type USB
-    @save :robot:
-    @direct :rotating_light:
-    @effects :white_check_mark:
-    @detectors DetectCherryKeyboards
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_CherryKeyboard::RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "Cherry Keyboard Device";
-    vendor      = "Cherry";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "Cherry Keyboard Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Custom;
-    Custom.name       = "Custom";
-    Custom.value      = CHERRY_KB_MODE_CUSTOM;
-    Custom.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Custom.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Custom);
-
-    mode Wave;
-    Wave.name       = "Wave";
-    Wave.value      = CHERRY_KB_MODE_WAVE;
-    Wave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Wave.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Wave.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Wave.speed      = CHERRY_KB_SPEED_NORMAL;
-    Wave.colors_min = 1;
-    Wave.colors_max = 1;
-    Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Wave.colors.resize(1);
-    modes.push_back(Wave);
-
-    mode Spectrum;
-    Spectrum.name       = "Spectrum";
-    Spectrum.value      = CHERRY_KB_MODE_SPECTRUM;
-    Spectrum.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-    Spectrum.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Spectrum.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Spectrum.speed      = CHERRY_KB_SPEED_NORMAL;
-    Spectrum.color_mode = MODE_COLORS_NONE;
-    Spectrum.colors.resize(1);
-    modes.push_back(Spectrum);
-
-    mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = CHERRY_KB_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Breathing.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Breathing.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Breathing.speed      = CHERRY_KB_SPEED_NORMAL;
-    Breathing.colors_min = 1;
-    Breathing.colors_max = 1;
-    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
-
-    mode Static;
-    Static.name       = "Static";
-    Static.value      = CHERRY_KB_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Static.colors_min = 1;
-    Static.colors_max = 1;
-    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Radar;
-    Radar.name       = "Radar";
-    Radar.value      = CHERRY_KB_MODE_RADAR;
-    Radar.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Radar.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Radar.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Radar.speed      = CHERRY_KB_SPEED_NORMAL;
-    Radar.colors_min = 1;
-    Radar.colors_max = 1;
-    Radar.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Radar.colors.resize(1);
-    modes.push_back(Radar);
-
-    mode Vortex;
-    Vortex.name       = "Vortex";
-    Vortex.value      = CHERRY_KB_MODE_VORTEX;
-    Vortex.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Vortex.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Vortex.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Vortex.speed      = CHERRY_KB_SPEED_NORMAL;
-    Vortex.colors_min = 1;
-    Vortex.colors_max = 1;
-    Vortex.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Vortex.colors.resize(1);
-    modes.push_back(Vortex);
-
-    mode Fire;
-    Fire.name       = "Fire";
-    Fire.value      = CHERRY_KB_MODE_FIRE;
-    Fire.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Fire.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Fire.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Fire.speed      = CHERRY_KB_SPEED_NORMAL;
-    Fire.colors_min = 1;
-    Fire.colors_max = 1;
-    Fire.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Fire.colors.resize(1);
-    modes.push_back(Fire);
-
-    mode Stars;
-    Stars.name       = "Stars";
-    Stars.value      = CHERRY_KB_MODE_STARS;
-    Stars.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Stars.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Stars.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Stars.speed      = CHERRY_KB_SPEED_NORMAL;
-    Stars.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Stars.colors.resize(1);
-    modes.push_back(Stars);
-
-    mode Rain;
-    Rain.name       = "Rain";
-    Rain.value      = CHERRY_KB_MODE_RAIN;
-    Rain.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Rain.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Rain.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Rain.speed      = CHERRY_KB_SPEED_NORMAL;
-    Rain.colors_min = 1;
-    Rain.colors_max = 1;
-    Rain.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Rain.colors.resize(1);
-    modes.push_back(Rain);
-
-    mode Rolling;
-    Rolling.name       = "Rolling";
-    Rolling.value      = CHERRY_KB_MODE_ROLLING;
-    Rolling.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-    Rolling.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Rolling.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Rolling.speed      = CHERRY_KB_SPEED_NORMAL;
-    Rolling.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Rolling);
-    
-    mode Curve;
-    Curve.name       = "Curve";
-    Curve.value      = CHERRY_KB_MODE_CURVE;
-    Curve.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Curve.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Curve.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Curve.speed      = CHERRY_KB_SPEED_NORMAL;
-    Curve.colors_min = 1;
-    Curve.colors_max = 1;
-    Curve.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Curve.colors.resize(1);
-    modes.push_back(Curve);
-
-    mode WaveMid;
-    WaveMid.name       = "Wave Mid";
-    WaveMid.value      = CHERRY_KB_MODE_WAVE_MID;
-    WaveMid.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    WaveMid.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    WaveMid.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    WaveMid.speed      = CHERRY_KB_SPEED_NORMAL;
-    WaveMid.color_mode = MODE_COLORS_NONE;
-    WaveMid.colors.resize(1);
-    modes.push_back(WaveMid);
-
-    mode Scan;
-    Scan.name       = "Scan";
-    Scan.value      = CHERRY_KB_MODE_SCAN;
-    Scan.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Scan.colors_min = 1;
-    Scan.colors_max = 1;
-    Scan.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Scan.colors.resize(1);
-    modes.push_back(Scan);
-
-    mode Radiation;
-    Radiation.name       = "Radiation";
-    Radiation.value      = CHERRY_KB_MODE_RADIATION;
-    Radiation.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Radiation.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Radiation.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Radiation.speed      = CHERRY_KB_SPEED_NORMAL;
-    Radiation.colors_min = 1;
-    Radiation.colors_max = 1;
-    Radiation.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Radiation.colors.resize(1);
-    modes.push_back(Radiation);
-
-    mode Ripples;
-    Ripples.name       = "Ripples";
-    Ripples.value      = CHERRY_KB_MODE_RIPPLES;
-    Ripples.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Ripples.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Ripples.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Ripples.speed      = CHERRY_KB_SPEED_NORMAL;
-    Ripples.colors_min = 1;
-    Ripples.colors_max = 1;
-    Ripples.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Ripples.colors.resize(1);
-    modes.push_back(Ripples);
-
-    mode SingleKey;
-    SingleKey.name       = "Single Key";
-    SingleKey.value      = CHERRY_KB_MODE_SINGLE_KEY;
-    SingleKey.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    SingleKey.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    SingleKey.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    SingleKey.speed      = CHERRY_KB_SPEED_NORMAL;
-    SingleKey.colors_min = 1;
-    SingleKey.colors_max = 1;
-    SingleKey.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    SingleKey.colors.resize(1);
-    modes.push_back(SingleKey);
-
-    SetupZones();
-}
-
-RGBController_CherryKeyboard::~RGBController_CherryKeyboard()
-{
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].matrix_map != NULL)
-        {
-            delete zones[zone_index].matrix_map;
-        }
-    }
-
-    delete controller;
-}
-
-void RGBController_CherryKeyboard::SetupZones()
-{
-    zone new_zone;
-
-    new_zone.name               = "Keyboard";
-    new_zone.type               = ZONE_TYPE_MATRIX;
-    new_zone.leds_min           = 126;
-    new_zone.leds_max           = 126;
-    new_zone.leds_count         = 126;
-    new_zone.matrix_map         = new matrix_map_type;
-    new_zone.matrix_map->height = 6;
-    new_zone.matrix_map->width  = 23;
-    new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-    
-    zones.push_back(new_zone);
-
-    for(int led_idx = 0; led_idx < 126; led_idx++)
-    {
-        led new_led;
-
-        new_led.name = "Keyboard LED ";
-        new_led.name.append(std::to_string(led_idx));
-
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_CherryKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_CherryKeyboard::DeviceUpdateLEDs()
-{
-    unsigned char color_data[7*CHERRY_KB_MAX_PACKET_SIZE];
-
-    for(int led_idx = 0; led_idx < 126; led_idx++)
-    {
-        color_data[(3 * led_idx) + 0] = RGBGetRValue(colors[led_idx]);
-        color_data[(3 * led_idx) + 1] = RGBGetGValue(colors[led_idx]);
-        color_data[(3 * led_idx) + 2] = RGBGetBValue(colors[led_idx]);
-    }
-
-    controller->SetKeyboardColors
-                    (
-                    color_data,
-                    CHERRY_KB_MAX_PACKET_SIZE * 7
-                    );
-}
-
-void RGBController_CherryKeyboard::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_CherryKeyboard::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_CherryKeyboard::SetCustomMode()
-{
-
-}
-
-void RGBController_CherryKeyboard::DeviceUpdateMode()
-{
-    unsigned char red    = 0x00;
-    unsigned char grn    = 0x00;
-    unsigned char blu    = 0x00;
-    unsigned char random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-
-    if(modes[active_mode].colors.size() > 0)
-    {
-        red = RGBGetRValue(modes[active_mode].colors[0]);
-        grn = RGBGetGValue(modes[active_mode].colors[0]);
-        blu = RGBGetBValue(modes[active_mode].colors[0]);
-    }
-
-    controller->SendKeyboardModeEx
-                    (
-                    modes[active_mode].value,
-                    CHERRY_KB_BRIGHTNESS_HIGHEST,
-                    modes[active_mode].speed,
-                    0,
-                    random,
-                    red,
-                    grn,
-                    blu
-                    );
-}

Controllers/CherryKeyboardController/RGBController_CherryKeyboard.h

@@ -1,33 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_CherryKeyboard.h           |
-|                                           |
-|  Generic RGB Interface for Cherry RGB     |
-|  Keyboard                                 |
-|                                           |
-|  Sebastian Kraus 12/25/2021               |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "CherryKeyboardController.h"
-
-class RGBController_CherryKeyboard : public RGBController
-{
-public:
-    RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr);
-    ~RGBController_CherryKeyboard();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-    
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    CherryKeyboardController*  controller;
-};

Controllers/ColorfulGPUController/ColorfulGPUController.cpp

@@ -1,44 +0,0 @@
-#include "ColorfulGPUController.h"
-#include <cstring>
-
-ColorfulGPUController::ColorfulGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-}
-
-ColorfulGPUController::~ColorfulGPUController()
-{
-
-}
-
-std::string ColorfulGPUController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-void ColorfulGPUController::SetDirect(RGBColor color)
-{
-    uint8_t r = RGBGetRValue(color);
-    uint8_t g = RGBGetGValue(color);
-    uint8_t b = RGBGetBValue(color);
-
-    uint8_t data_pkt[COLORFUL_PACKET_LENGTH] = { 0xAA, 0xEF, 0x12, 0x03, 0x01, 0xFF, r, g, b};
-
-    int crc = 0;
-
-    for (int i = 0; i < COLORFUL_PACKET_LENGTH - 2; ++i)
-    {
-        crc += data_pkt[i];
-    }
-
-    data_pkt[COLORFUL_PACKET_LENGTH - 2] = crc & 0xFF;
-    data_pkt[COLORFUL_PACKET_LENGTH - 1] = crc >> 8;
-
-    bus->i2c_write_block(dev, COLORFUL_PACKET_LENGTH, data_pkt);
-}

Controllers/ColorfulGPUController/ColorfulGPUController.h

@@ -1,24 +0,0 @@
-#include <string>
-#include "i2c_smbus.h"
-#include "RGBController.h"
-
-#pragma once
-
-typedef unsigned char colorful_gpu_dev_id;
-
-#define COLORFUL_PACKET_LENGTH 11
-
-class ColorfulGPUController
-{
-public:
-    ColorfulGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev);
-    ~ColorfulGPUController();
-
-    std::string GetDeviceLocation();
-    void        SetDirect(RGBColor color);
-
-
-private:
-    i2c_smbus_interface *   bus;
-    colorful_gpu_dev_id     dev;
-};