Add Translations field to SDK protocol

Added support for Lenovo Legion M300 RGB Mouse.
Added all supported modes Static, Rainbow, Breathing and Off
Also Tested all modes to verify its working

.gitignore

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

.gitlab-ci.yml

@@ -61,7 +61,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 32 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
   stage: build
   script:
   - export $(dpkg-architecture)
@@ -87,7 +87,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 64 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
   stage: build
   script:
   - export $(dpkg-architecture)
@@ -109,6 +109,7 @@ 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
@@ -137,6 +138,7 @@ 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
@@ -165,6 +167,7 @@ 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
@@ -193,6 +196,7 @@ 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
@@ -221,6 +225,7 @@ 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
@@ -249,6 +254,7 @@ 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
@@ -278,6 +284,7 @@ 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
@@ -310,8 +317,9 @@ before_script:
   image: fedora:36
   stage: build
   script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel -y
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-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
@@ -562,6 +570,8 @@ 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:
@@ -638,6 +648,8 @@ 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,7 +74,6 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/NZXTHue2Controller/
 /Controllers/NZXTHuePlusController/
 /Controllers/NZXTKrakenController/
-/Controllers/OpenRazerController/
 /Controllers/PNYGPUController/
 /Controllers/PatriotViperController/
 /Controllers/PhilipsHueController/

.gitlab/merge_request_templates/New Device.md

@@ -10,6 +10,7 @@ Please put "Initial commit for" name of the product, including manufacturer abov
 <!-- For admin purposes: Please leave this section as is -->
 
 # Checklist for Accepting a Merge Request for a New Device
+- [ ] The source branch of the merge request is not protected (`master` is protected by default when creating a fork, so it is recommended to not use it as your source).
 - [ ] The `New Device` issue raised for this device is linked to this MR with a keyword `Closes / Resolves / Implements`
 - [ ] There is a device protocol page in the [Developer Wiki](https://gitlab.com/OpenRGBDevelopers/OpenRGB-Wiki) or there is enough information / captures in the `New Device` issue to provide ongoing support.
 - [ ] The code to be merged follows the style guide and change requirements as [documented in the contributing guide](https://gitlab.com/CalcProgrammer1/OpenRGB/-/blob/master/CONTRIBUTING.md).

AutoStart/AutoStart-Linux.cpp

@@ -4,6 +4,7 @@
 
 #include <fstream>
 #include <iostream>
+#include <sstream>
 #include <unistd.h>
 #include <linux/limits.h>
 

CONTRIBUTING.md

@@ -11,6 +11,7 @@ To create a merge request, log into GitLab and fork the OpenRGB project.  Push y
 * Mark your merge request as a draft (start title with "Draft:") until it has been tested and verified working.
 * Follow the Style Guidelines below when making your code changes.
 * Avoid using `git merge` when updating your fork.  The OpenRGB project uses a linear git history, meaning all changes are rebased onto the tip of master.  By using `git rebase` to update your fork, you will make it easier to accept merge requests.
+* Do not submit a merge request using your fork's `master` branch as the source.  The `master` branch is protected by default when creating a fork and I cannot manually rebase a protected branch before merging.  If you submit a merge request with a protected `master` branch as the source, it may not get merged until you unprotect it.
 
 ### Pipelines, Shared Runners and Quotas
 

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -1,15 +1,25 @@
+/*-------------------------------------------------------------------*\
+|  A4TechDetector.cpp                                                 |
+|                                                                     |
+|  Driver for A4Tech Devices Detector                                 |
+|                                                                     |
+|  Chris M (Dr_No)                              30 Jun 2022           |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)    01 Apr 2024           |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
 /*-----------------------------------------------------*\
 | OpenRGB includes                                      |
 \*-----------------------------------------------------*/
 #include <hidapi/hidapi.h>
 #include "Detector.h"
-#include "LogManager.h"
 #include "RGBController.h"
 
 /*-----------------------------------------------------*\
 | A4 Tech specific includes                             |
 \*-----------------------------------------------------*/
 #include "RGBController_BloodyMouse.h"
+#include "RGBController_BloodyB820R.h"
 
 /*-----------------------------------------------------*\
 | A4 Tech USB vendor ID                                 |
@@ -30,5 +40,21 @@ void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name
     }
 }
 
+void DetectBloodyB820R(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path);
+        RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
+        rgb_controller->name                      = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 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);
+REGISTER_HID_DETECTOR_IPU("A4Tech Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);

Controllers/A4TechController/BloodyB820RController.cpp

@@ -0,0 +1,102 @@
+/*-------------------------------------------------------------------*\
+|  BloodyB820RController.cpp                                          |
+|                                                                     |
+|  Driver for A4Tech Bloody B820R Keyboard Controller                 |
+|                                                                     |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "BloodyB820RController.h"
+
+/*--------------------------------------------------------------------------------------*\
+ * The controller for this device should pass a packet of 64 bytes where the subsequent *
+ * two packets are for RED, GREEN, and BLUE respectively. The first 6 bytes are control *
+ * or information bytes and colors bytes starts from index 6. Moreover, the first pack- *
+ * et of each RGB contains color for 58 keys and the rest (104 - 58 == 46) are send on  *
+ * the second packet.                                                                   *
+\*--------------------------------------------------------------------------------------*/
+
+BloodyB820RController::BloodyB820RController(hid_device* dev_handle, const char* path)
+{
+    dev                 = dev_handle;
+    location            = path;
+
+    SendControlPacket(BLOODY_B820R_GAIN_CONTROL);
+}
+
+BloodyB820RController::~BloodyB820RController()
+{
+    SendControlPacket(BLOODY_B820R_RELEASE_CONTROL);
+    hid_close(dev);
+}
+
+std::string BloodyB820RController::GetSerial()
+{
+    const int szTemp    = HID_MAX_STR;
+    wchar_t   tmpName[szTemp];
+
+    hid_get_serial_number_string(dev, tmpName, szTemp);
+    std::wstring wName  = std::wstring(tmpName);
+    std::string serial  = std::string(wName.begin(), wName.end());
+
+    return serial;
+}
+
+std::string BloodyB820RController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+void  BloodyB820RController::SendControlPacket(uint8_t data)
+{
+    uint8_t buffer[BLOODY_B820R_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
+
+    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
+
+    buffer[BLOODY_B820R_MODE_BYTE]                   = 0;
+    buffer[BLOODY_B820R_DATA_BYTE]                   = data;
+
+    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
+}
+
+void BloodyB820RController::SetLEDDirect(std::vector<RGBColor> colors)
+{
+
+    uint8_t r1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x07, 0x00, 0x00 };
+    uint8_t r2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x08, 0x00, 0x00 };
+    uint8_t g1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x09, 0x00, 0x00 };
+    uint8_t g2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0A, 0x00, 0x00 };
+    uint8_t b1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0B, 0x00, 0x00 };
+    uint8_t b2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0C, 0x00, 0x00 };
+
+    /*-----------------------------------------------------------------*\
+    | Set up Direct packet                                              |
+    |   packet_map is the index of the Key from full_matrix_map and     |
+    |   the value is the position in the direct packet buffer           |
+    \*-----------------------------------------------------------------*/
+
+
+    for(size_t i = 0; i < colors.size(); i++)
+    {
+        RGBColor    color                     = colors[i];
+        uint8_t     offset                    = BLOODY_B820R_RGB_OFFSET;
+        uint8_t     buffer_idx                = offset + i % BLOODY_B820R_RGB_BUFFER_SIZE;
+        uint8_t*    buffers[2][3]             =
+                {
+                        {r1_buffer, g1_buffer, b1_buffer},
+                        {r2_buffer, g2_buffer, b2_buffer}
+                };
+
+        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][0][buffer_idx] = RGBGetRValue(color);
+        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][1][buffer_idx] = RGBGetGValue(color);
+        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][2][buffer_idx] = RGBGetBValue(color);
+    }
+
+    hid_send_feature_report(dev, r1_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, r2_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, g1_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, g2_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, b1_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, b2_buffer, BLOODY_B820R_PACKET_SIZE);
+}

Controllers/A4TechController/BloodyB820RController.h

@@ -0,0 +1,51 @@
+/*-------------------------------------------------------------------*\
+|  BloodyB820RController.h                                            |
+|                                                                     |
+|  Driver for A4Tech Bloody B820R Keyboard Controller                 |
+|                                                                     |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
+#pragma once
+#define NA                                      0xFFFFFFFF
+#define HID_MAX_STR                             255
+
+#define BLOODY_B820R_RGB_BUFFER_SIZE    58
+#define BLOODY_B820R_RGB_OFFSET         6
+#define BLOODY_B820R_PACKET_SIZE        64
+#define BLOODY_B820R_KEYCOUNT           104
+#define BLOODY_B820R_MODE_BYTE          3
+#define BLOODY_B820R_DATA_BYTE          8
+#define BLOODY_B820R_GAIN_CONTROL       0x01
+#define BLOODY_B820R_RELEASE_CONTROL    0x00
+
+/*---------------------------------------------------------*\
+| Bloody B820R product ID                                    |
+\*---------------------------------------------------------*/
+#define BLOODY_B820R_PID                               0xFA10
+
+enum
+{
+    BLOODY_B820R_MODE_DIRECT     = 0x01,    // Direct LED control - Independently set LEDs in zone
+};
+
+class BloodyB820RController
+{
+public:
+    BloodyB820RController(hid_device* dev_handle, const char* path);
+    ~BloodyB820RController();
+
+    std::string     GetSerial();
+    std::string     GetLocation();
+
+    void            SetLEDDirect(std::vector<RGBColor> colors);
+    void            SendControlPacket(uint8_t data);
+private:
+    std::string     location;
+    hid_device*     dev;
+};

Controllers/A4TechController/BloodyMouseController.cpp

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

Controllers/A4TechController/BloodyMouseController.h

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

Controllers/A4TechController/RGBController_BloodyB820R.cpp

@@ -0,0 +1,247 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_BloodyB820R.cpp                                      |
+|                                                                     |
+|  Driver for A4Tech Bloody B820R Keyboard Controller                 |
+|                                                                     |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include "RGBController_BloodyB820R.h"
+
+static unsigned int matrix_map[6][21] =
+        {
+                {0, NA, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, NA, NA, NA, NA, 13, 14, 15},
+                {16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36},
+                {37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57},
+                {58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, NA, NA, NA, NA, 71, 72, 73, NA},
+                {74, NA, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, NA, NA, 86, NA, 87, 88, 89, 90},
+                {91, 92, 93, 94, NA, NA, NA, NA, NA, NA, 95, 96, 97, 98, 99, 100, 101, 102, NA, 103, NA},
+        };
+
+static const char *led_names[] =
+        {
+                KEY_EN_ESCAPE,              //00
+                KEY_EN_F1,
+                KEY_EN_F2,
+                KEY_EN_F3,
+                KEY_EN_F4,
+                KEY_EN_F5,
+                KEY_EN_F6,
+                KEY_EN_F7,
+                KEY_EN_F8,
+                KEY_EN_F9,
+                KEY_EN_F10,                 
+                KEY_EN_F11,
+                KEY_EN_F12,
+                KEY_EN_PRINT_SCREEN,
+                KEY_EN_SCROLL_LOCK,
+                KEY_EN_PAUSE_BREAK,
+
+                KEY_EN_BACK_TICK,           //10
+                KEY_EN_1,
+                KEY_EN_2,
+                KEY_EN_3,
+                KEY_EN_4,                   
+                KEY_EN_5,
+                KEY_EN_6,
+                KEY_EN_7,
+                KEY_EN_8,
+                KEY_EN_9,
+                KEY_EN_0,
+                KEY_EN_MINUS,
+                KEY_EN_EQUALS,
+                KEY_EN_BACKSPACE,
+                KEY_EN_INSERT,
+                KEY_EN_HOME,
+                KEY_EN_PAGE_UP,
+                KEY_EN_NUMPAD_LOCK,
+                KEY_EN_NUMPAD_DIVIDE,
+                KEY_EN_NUMPAD_TIMES,
+                KEY_EN_NUMPAD_MINUS,
+
+                KEY_EN_TAB,                 //20
+                KEY_EN_Q,
+                KEY_EN_W,
+                KEY_EN_E,
+                KEY_EN_R,
+                KEY_EN_T,
+                KEY_EN_Y,
+                KEY_EN_U,
+                KEY_EN_I,
+                KEY_EN_O,
+                KEY_EN_P,
+                KEY_EN_LEFT_BRACKET,
+                KEY_EN_RIGHT_BRACKET,
+                KEY_EN_ANSI_BACK_SLASH,
+                KEY_EN_DELETE,
+                KEY_EN_END,
+                KEY_EN_PAGE_DOWN,
+                KEY_EN_NUMPAD_7,
+                KEY_EN_NUMPAD_8,
+                KEY_EN_NUMPAD_9,
+                KEY_EN_NUMPAD_PLUS,
+
+                KEY_EN_CAPS_LOCK,           //30
+                KEY_EN_A,
+                KEY_EN_S,
+                KEY_EN_D,
+                KEY_EN_F,
+                KEY_EN_G,
+                KEY_EN_H,
+                KEY_EN_J,
+                KEY_EN_K,
+                KEY_EN_L,
+                KEY_EN_SEMICOLON,
+                KEY_EN_QUOTE,
+                KEY_EN_ANSI_ENTER,
+                KEY_EN_NUMPAD_4,
+                KEY_EN_NUMPAD_5,
+                KEY_EN_NUMPAD_6,
+
+                KEY_EN_LEFT_SHIFT,          //40
+                KEY_EN_Z,
+                KEY_EN_X,
+                KEY_EN_C,
+                KEY_EN_V,
+                KEY_EN_B,
+                KEY_EN_N,
+                KEY_EN_M,
+                KEY_EN_COMMA,
+                KEY_EN_PERIOD,
+                KEY_EN_FORWARD_SLASH,
+                KEY_EN_RIGHT_SHIFT,
+                KEY_EN_UP_ARROW,
+                KEY_EN_NUMPAD_1,
+                KEY_EN_NUMPAD_2,
+                KEY_EN_NUMPAD_3,
+                KEY_EN_NUMPAD_ENTER,
+
+                KEY_EN_LEFT_CONTROL,        //50
+                KEY_EN_LEFT_WINDOWS,
+                KEY_EN_LEFT_ALT,
+                KEY_EN_SPACE,
+                KEY_EN_RIGHT_ALT,
+                KEY_EN_RIGHT_FUNCTION,
+                KEY_EN_MENU,
+                KEY_EN_RIGHT_CONTROL,
+                KEY_EN_LEFT_ARROW,
+                KEY_EN_DOWN_ARROW,
+                KEY_EN_RIGHT_ARROW,
+                KEY_EN_NUMPAD_0,
+                KEY_EN_NUMPAD_PERIOD
+        };
+
+/**------------------------------------------------------------------*\
+    @name A4Tech Bloody B820R
+    @category Keyboard
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors A4TechDetector
+    @comment The A4Tech Bloody B820R keyboard controller currently
+        supports the full size (ANSI layout).
+\*-------------------------------------------------------------------*/
+
+RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = "Bloody B820R";
+    vendor                      = "A4Tech";
+    type                        = DEVICE_TYPE_KEYBOARD;
+    description                 = "A4Tech Bloody Keyboard";
+    serial                      = controller->GetSerial();
+    location                    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = BLOODY_B820R_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_BloodyB820R::~RGBController_BloodyB820R()
+{
+    delete controller;
+}
+
+void RGBController_BloodyB820R::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Create the Keyboard zone and add the matrix map   |
+    \*-------------------------------------------------*/
+    zone KB_zone;
+    KB_zone.name                = ZONE_EN_KEYBOARD;
+    KB_zone.type                = ZONE_TYPE_MATRIX;
+    KB_zone.leds_min            = BLOODY_B820R_KEYCOUNT;
+    KB_zone.leds_max            = BLOODY_B820R_KEYCOUNT;
+    KB_zone.leds_count          = BLOODY_B820R_KEYCOUNT;
+
+    KB_zone.matrix_map          = new matrix_map_type;
+    KB_zone.matrix_map->height  = 6;
+    KB_zone.matrix_map->width   = 21;
+    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
+    zones.push_back(KB_zone);
+
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    for(unsigned int led_index = 0; led_index < BLOODY_B820R_KEYCOUNT; led_index++)
+    {
+        led new_led;
+        new_led.name        = led_names[led_index];
+        new_led.value       = led_index;
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_BloodyB820R::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+
+void RGBController_BloodyB820R::DeviceUpdateLEDs()
+{
+    controller->SetLEDDirect(colors);
+}
+
+void RGBController_BloodyB820R::UpdateZoneLEDs(int zone)
+{
+    std::vector<RGBColor> colour;
+    for(size_t i = 0; i < zones[zone].leds_count; i++)
+    {
+        colour.push_back(zones[zone].colors[i]);
+    }
+
+    controller->SetLEDDirect(colour);
+}
+
+void RGBController_BloodyB820R::UpdateSingleLED(int led)
+{
+    std::vector<RGBColor> colour;
+    colour.push_back(colors[led]);
+
+    controller->SetLEDDirect(colour);
+}
+
+void RGBController_BloodyB820R::DeviceUpdateMode()
+{
+    /* This device does not support modes yet */
+}

Controllers/A4TechController/RGBController_BloodyB820R.h

@@ -0,0 +1,32 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_BloodyB820R.h                                |
+|                                                                     |
+|  Driver for A4Tech Bloody B820R Keyboard Controller                   |
+|                                                                     |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "BloodyB820RController.h"
+#include <vector>
+
+class RGBController_BloodyB820R : public RGBController
+{
+public:
+    RGBController_BloodyB820R(BloodyB820RController* controller_ptr);
+    ~RGBController_BloodyB820R();
+
+    void    SetupZones();
+    void    ResizeZone(int zone, int new_size);
+
+    void    DeviceUpdateLEDs();
+    void    UpdateZoneLEDs(int zone);
+    void    UpdateSingleLED(int led);
+
+    void    DeviceUpdateMode();
+
+private:
+    BloodyB820RController* controller;
+};

Controllers/A4TechController/RGBController_BloodyMouse.cpp

@@ -25,6 +25,19 @@ 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
 {
     {
@@ -56,7 +69,6 @@ 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();
@@ -89,11 +101,15 @@ 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,7 +9,6 @@
 
 #pragma once
 #include <vector>
-#include "LogManager.h"
 #include "RGBController.h"
 #include "BloodyMouseController.h"
 

Controllers/AOCKeyboardController/AOCKeyboardController.cpp

@@ -0,0 +1,211 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,107 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,36 @@
+#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
+#define AOC_GK500_PID_2                             0x1229
+
+/******************************************************************************************\
+*                                                                                          *
+*   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);
+REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID_2,   0xFF19, 0xFF19);

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp

@@ -0,0 +1,370 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,32 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,130 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,80 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,34 @@
+#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

@@ -0,0 +1,215 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,32 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,112 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,79 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,34 @@
+#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

@@ -0,0 +1,192 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,32 @@
+/*-----------------------------------------*\
+|  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

@@ -12,6 +12,7 @@
 
 #include "RGBController.h"
 #include "ResourceManager.h"
+#include "SettingsManager.h"
 #include "ASRockPolychromeUSBController.h"
 #include "dependencies/dmiinfo.h"
 
@@ -76,7 +77,7 @@ std::string PolychromeUSBController::GetSerialString()
     {
         return("");
     }
-    
+
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());
 
@@ -213,13 +214,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];
 
@@ -234,7 +235,7 @@ 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)
@@ -262,7 +263,7 @@ void PolychromeUSBController::WriteZone
 
 void PolychromeUSBController::WriteAllZones
     (
-    const std::vector<PolychromeZoneInfo>&  zones_info,
+    const std::vector<PolychromeZoneInfo>&  /*zones_info*/,
     const std::vector<zone>&                zones
     )
 {
@@ -434,7 +435,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                                           |
@@ -446,7 +447,7 @@ 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];

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_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Music.flags                 = MODE_FLAG_AUTOMATIC_SAVE;
     Music.color_mode            = MODE_COLORS_NONE;
     modes.push_back(Music);
 
@@ -122,7 +122,6 @@ 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;
@@ -192,7 +191,6 @@ 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,6 +15,7 @@
 #include <chrono>
 #include <algorithm>
 #include <sstream>
+#include "LogManager.h"
 
 typedef uint32_t alienware_platform_id;
 
@@ -24,8 +25,10 @@ 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
+    { 0x0C01,   4 },    // Dell G5 SE 5505
+    { 0x0A01,  16 },    // Dell G7 15 7500
+    { 0x0E03,   4 }     // Dell G15   5511
+
 };
 
 /*---------------------------------------------------------*\
@@ -39,7 +42,8 @@ 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"              } }
+                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
+    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } }
 };
 
 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
@@ -113,10 +117,13 @@ 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"                          |

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/AlienwareAW410KController.cpp

@@ -0,0 +1,448 @@
+/*------------------------------------------------------*\
+|  AlienwareAW410KController.cpp                         |
+|                                                        |
+|  Driver for Alienware AW410K                           |
+|  keyboard light controller                             |
+|                                                        |
+|  based on AW510K controller by Mohamad Sallal - msallal|
+|                                                        |
+|  Dominik Mikolajczyk - dmiko 23/10/2023                |
+\*------------------------------------------------------*/
+
+#include "AlienwareAW410KController.h"
+#include <cstring>
+
+AlienwareAW410KController::AlienwareAW410KController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+
+    SendCommit();
+}
+
+AlienwareAW410KController::~AlienwareAW410KController()
+{
+    hid_close(dev);
+}
+
+std::string AlienwareAW410KController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AlienwareAW410KController::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 AlienwareAW410KController::SendCommit()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x0A]           = 0x10;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0C]           = 0x01;
+    usb_buf[0x0D]           = 0x02;
+    usb_buf[0x0E]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 20 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(20));
+}
+
+
+void AlienwareAW410KController::SendfeatureReport
+    (
+    unsigned char   first_byte,
+    unsigned char   second_byte,
+    unsigned char   third_byte,
+    unsigned char   forth_byte
+    )
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Feature report packet                          |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = first_byte;
+    usb_buf[0x02]           = second_byte;
+    usb_buf[0x03]           = third_byte;
+    usb_buf[0x04]           = forth_byte;
+
+    /*-----------------------------------------------------*\
+    | Send Feature report packet                            |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 10 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+}
+
+void AlienwareAW410KController::SendEdit()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Edit packet                                    |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x01;
+    usb_buf[0x02]           = 0x00;
+    usb_buf[0x03]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 2 milliseconds                                  |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void AlienwareAW410KController::SendInitialize()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x0E;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = 0x00;
+    usb_buf[0x04]           = 0x01;
+    usb_buf[0x05]           = 0xAD;
+    usb_buf[0x06]           = 0x80;
+    usb_buf[0x07]           = 0x10;
+    usb_buf[0x08]           = 0xA5;
+    usb_buf[0x0A]           = 0x0A;
+    usb_buf[0x12]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 2 milliseconds                                  |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void AlienwareAW410KController::SetDirect
+    (
+    unsigned char   /*zone*/,
+    unsigned char   r,
+    unsigned char   g,
+    unsigned char   b
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Lighting Control packet                        |
+    \*-----------------------------------------------------*/
+
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = 0x01;
+    usb_buf[0x04]           = r;
+    usb_buf[0x05]           = g;
+    usb_buf[0x06]           = b;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0D]           = 0x01;
+    usb_buf[0x0E]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 2 milliseconds                                  |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void AlienwareAW410KController::SendDirectOn
+    (
+    std::vector<SelectedButtons>     &frame_data
+    )
+{
+    SendfeatureReport(0x0E, frame_data.size(), 0x00, 0x01);
+
+    /*-----------------------------------------------*\
+    | To Guarantee the data are always %4 =0 append   |
+    | zeros at end of last packet                     |
+    \*-----------------------------------------------*/
+    for(unsigned int i = 0; i < (frame_data.size() % 4); i++)
+    {
+        SelectedButtons key;
+        key.idx     = 0x00;
+        key.red     = 0x00;
+        key.green   = 0x00;
+        key.blue    = 0x00;
+
+        frame_data.push_back(key);
+    }
+
+    unsigned char usb_buf[65];
+    unsigned int  frame_idx = 0;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, 65);
+
+    for(unsigned int packet_idx = 0; packet_idx < frame_data.size(); packet_idx++)
+    {
+        usb_buf[0x00]           = 0x00;
+        usb_buf[0x01]           = 0x0E;
+        usb_buf[0x02]           = 0x01;
+        usb_buf[0x03]           = 0x00;
+        usb_buf[0x04]           = ++frame_idx;
+        usb_buf[0x05]           = frame_data[packet_idx].idx;
+        usb_buf[0x06]           = 0x81;
+        usb_buf[0x07]           = 0x00;
+        usb_buf[0x08]           = 0xA5;
+        usb_buf[0x0A]           = 0x0A;
+        usb_buf[0x0B]           = frame_data[packet_idx].red;
+        usb_buf[0x0C]           = frame_data[packet_idx].green;
+        usb_buf[0x0D]           = frame_data[packet_idx].blue;
+        usb_buf[0x12]           = 0x01;
+
+        usb_buf[0x14]           = frame_data[++packet_idx].idx;
+        usb_buf[0x15]           = 0x81;
+        usb_buf[0x16]           = 0x00;
+        usb_buf[0x17]           = 0xA5;
+        usb_buf[0x19]           = 0x0A;
+        usb_buf[0x1A]           = frame_data[packet_idx].red;
+        usb_buf[0x1B]           = frame_data[packet_idx].green;
+        usb_buf[0x1C]           = frame_data[packet_idx].blue;
+        usb_buf[0x21]           = 0x01;
+
+        usb_buf[0x23]           = frame_data[++packet_idx].idx;
+        usb_buf[0x24]           = 0x81;
+        usb_buf[0x25]           = 0x00;
+        usb_buf[0x26]           = 0xA5;
+        usb_buf[0x28]           = 0x0A;
+        usb_buf[0x29]           = frame_data[packet_idx].red;
+        usb_buf[0x2A]           = frame_data[packet_idx].green;
+        usb_buf[0x2B]           = frame_data[packet_idx].blue;
+        usb_buf[0x30]           = 0x01;
+
+        usb_buf[0x32]           = frame_data[++packet_idx].idx;
+        usb_buf[0x33]           = 0x81;
+        usb_buf[0x34]           = 0x00;
+        usb_buf[0x35]           = 0xA5;
+        usb_buf[0x37]           = 0x0A;
+        usb_buf[0x38]           = frame_data[packet_idx].red;
+        usb_buf[0x39]           = frame_data[packet_idx].green;
+        usb_buf[0x3A]           = frame_data[packet_idx].blue;
+        usb_buf[0x3F]           = 0x01;
+
+        hid_write(dev, (unsigned char *)usb_buf, 65);
+    }
+}
+
+
+void AlienwareAW410KController::SetMode
+    (
+    unsigned char   mode,
+    unsigned short  speed,
+    unsigned char   direction,
+    unsigned char   colorMode,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    SendMode(ALIENWARE_AW410K_ZONE_MODE_KEYBOARD, mode, speed, direction, colorMode, red, green, blue);
+    SendCommit();
+}
+
+void AlienwareAW410KController::UpdateSingleLED
+    (
+    unsigned char   led,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    SendfeatureReport(0x0E, 0x01, 0x00, 0x01);
+
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Single LED packet                              |
+    \*-----------------------------------------------------*/
+
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x0E;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = 0x00;
+    usb_buf[0x04]           = 0x01;
+    usb_buf[0x05]           = led;
+    usb_buf[0x06]           = 0x81;
+    usb_buf[0x07]           = 0x00;
+    usb_buf[0x08]           = 0xA5;
+    usb_buf[0x09]           = 0x00;
+    usb_buf[0x0A]           = 0x0A;
+    usb_buf[0x0B]           = red;
+    usb_buf[0x0C]           = green;
+    usb_buf[0x0D]           = blue;
+    usb_buf[0x12]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 20 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(20));
+
+}
+void AlienwareAW410KController::SendMode
+    (
+    unsigned char   /*zone*/,
+    unsigned char   mode,
+    unsigned short  speed,
+    unsigned char   direction,
+    unsigned char   colorMode,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Mode Control packet                            |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = mode;
+    usb_buf[0x04]           = red;
+    usb_buf[0x05]           = green;
+    usb_buf[0x06]           = blue;
+    usb_buf[0x0A]           = speed;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0D]           = 0x01;
+    usb_buf[0x0E]           = colorMode;
+    usb_buf[0x0F]           = direction;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+}
+
+void AlienwareAW410KController::SetMorphMode
+    (
+    unsigned char   mode,
+    unsigned short  speed,
+    unsigned char   red1,
+    unsigned char   green1,
+    unsigned char   blue1,
+    unsigned char   red2,
+    unsigned char   green2,
+    unsigned char   blue2
+    )
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Morph Mode packet                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = mode;
+    usb_buf[0x04]           = red1;
+    usb_buf[0x05]           = green1;
+    usb_buf[0x06]           = blue1;
+    usb_buf[0x07]           = red2;
+    usb_buf[0x08]           = green2;
+    usb_buf[0x09]           = blue2;
+    usb_buf[0x0E]           = 0x02;
+    usb_buf[0x0A]           = speed;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0D]           = 0x01;
+    usb_buf[0x0E]           = ALIENWARE_AW410K_TWO_USER_DEFINED_COLOR_MODE;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+}

Controllers/AlienwareKeyboardController/AlienwareAW410KController.h

@@ -0,0 +1,155 @@
+/*------------------------------------------------------*\
+|  AlienwareAW410KController.h                           |
+|                                                        |
+|  Definitions and types for alienware                   |
+|  AW410K Keyboard                                       |
+|                                                        |
+|  based on AW510K controller by Mohamad Sallal - msallal|
+|                                                        |
+|  Dominik Mikolajczyk - dmiko 23/10/2023                |
+\*------------------------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    ALIENWARE_AW410K_ZONE_MODE_KEYBOARD         = 0x01,
+};
+
+enum
+{
+    ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD       = 0x01,
+    ALIENWARE_AW410K_ZONE_DIRECT_MEDIA          = 0x02,
+    ALIENWARE_AW410K_ZONE_DIRECT_INDICATORS     = 0x40,
+};
+
+enum
+{
+    ALIENWARE_AW410K_MODE_OFF                   = 0x00,
+    ALIENWARE_AW410K_MODE_DIRECT                = 0x01,
+    ALIENWARE_AW410K_MODE_PULSE                 = 0x02,
+    ALIENWARE_AW410K_MODE_MORPH                 = 0x03,
+    ALIENWARE_AW410K_MODE_BREATHING             = 0x07,
+    ALIENWARE_AW410K_MODE_SPECTRUM              = 0x08,
+    ALIENWARE_AW410K_MODE_SINGLE_WAVE           = 0x0F,
+    ALIENWARE_AW410K_MODE_RAINBOW_WAVE          = 0x10,
+    ALIENWARE_AW410K_MODE_SCANNER               = 0x11,
+    ALIENWARE_AW410K_MODE_STATIC                = 0x13,
+};
+
+enum
+{
+    ALIENWARE_AW410K_SPEED_SLOWEST              = 0x2D,     /* Slowest speed                                */
+    ALIENWARE_AW410K_SPEED_NORMAL               = 0x19,     /* Normal speed                                 */
+    ALIENWARE_AW410K_SPEED_FASTEST              = 0x0A,     /* Fastest speed                                */
+};
+
+enum
+{
+    ALIENWARE_AW410K_DIRECTION_LEFT_TO_RIGHT    = 0x01,
+    ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT    = 0x02,
+    ALIENWARE_AW410K_DIRECTION_TOP_TO_BOTTOM    = 0x03,
+    ALIENWARE_AW410K_DIRECTION_BOTTOM_TO_TOP    = 0x04,
+};
+
+enum
+{
+    ALIENWARE_AW410K_SINGLE_COLOR_MODE          = 0x01,
+    ALIENWARE_AW410K_TWO_USER_DEFINED_COLOR_MODE= 0x02,
+    ALIENWARE_AW410K_RANBOW_COLOR_MODE          = 0x03,
+};
+
+struct SelectedButtons
+{
+    unsigned char idx;
+    unsigned char red;
+    unsigned char green;
+    unsigned char blue;
+};
+
+class AlienwareAW410KController
+{
+public:
+    AlienwareAW410KController(hid_device* dev_handle, const char* path);
+    ~AlienwareAW410KController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void        SendInitialize();
+    void        SendCommit();
+    void        SendfeatureReport
+                    (
+                    unsigned char   first_byte,
+                    unsigned char   second_byte,
+                    unsigned char   third_byte,
+                    unsigned char   forth_byte
+                    );
+
+    void        SendEdit();
+
+    void        SetDirect
+                    (
+                    unsigned char   zone,
+                    unsigned char   r,
+                    unsigned char   g,
+                    unsigned char   b
+                    );
+
+    void    SendDirectOn
+                    (
+                    std::vector<SelectedButtons>     &frame_data
+                    );
+
+    void        SetMode
+                    (
+                    unsigned char   mode,
+                    unsigned short  speed,
+                    unsigned char   direction,
+                    unsigned char   colorMode,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+
+    void        SetMorphMode
+                    (
+                    unsigned char   mode,
+                    unsigned short  speed,
+                    unsigned char   red1,
+                    unsigned char   green1,
+                    unsigned char   blue1,
+                    unsigned char   red2,
+                    unsigned char   green2,
+                    unsigned char   blue2
+                    );
+
+    void        UpdateSingleLED
+                    (
+                    unsigned char   led,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+
+private:
+    hid_device*             dev;
+    std::string             location;
+
+    void        SendMode
+                    (
+                    unsigned char   zone,
+                    unsigned char   mode,
+                    unsigned short  speed,
+                    unsigned char   direction,
+                    unsigned char   colorMode,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+};

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

@@ -1,7 +1,9 @@
 #include "Detector.h"
 #include "AlienwareAW510KController.h"
+#include "AlienwareAW410KController.h"
 #include "RGBController.h"
 #include "RGBController_AlienwareAW510K.h"
+#include "RGBController_AlienwareAW410K.h"
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
@@ -13,6 +15,7 @@
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
 #define ALIENWARE_AW510K_PID    0x1830
+#define ALIENWARE_AW410K_PID    0x1968
 
 /******************************************************************************************\
 *                                                                                          *
@@ -32,7 +35,20 @@ void DetectAlienwareAW510KControllers(hid_device_info* info, const std::string&
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-}   /* DetectAlienwareKeyboardControllers() */
+}
+
+void DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
+    {
+        AlienwareAW410KController*     controller     = new AlienwareAW410KController(dev, info->path);
+        RGBController_AlienwareAW410K* rgb_controller = new RGBController_AlienwareAW410K(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}/* DetectAlienwareKeyboardControllers() */
 
 
 REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);
+REGISTER_HID_DETECTOR_IPU("Alienware AW410K",   DetectAlienwareAW410KControllers,   ALIENWARE_VID,  ALIENWARE_AW410K_PID,   0x02,   0xFF00, 0x01);

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW410K.cpp

@@ -0,0 +1,481 @@
+/*------------------------------------------------------*\
+|  RGBController_AlienwareAW410K.cpp                     |
+|                                                        |
+|  Generic RGB Interface for alienware                   |
+|  AW410K Keyboard                                       |
+|                                                        |
+|  based on AW510K controller by Mohamad Sallal - msallal|
+|                                                        |
+|  Dominik Mikolajczyk - dmiko 23/10/2023                |
+\*------------------------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include "RGBController_AlienwareAW410K.h"
+#include <iterator>
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+int GetAW410K_WaveDirection(int input);
+
+static unsigned int matrix_map[6][24] =
+{ {  0,   NA,   1,   2,   3,   4,  NA,   5,   6,   7,   8,   9,  10,  11,  12, NA,  13,  14,  15,  NA,  NA,  16,  17,  18 },
+  {  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  NA, NA,  33,  34,  35,  NA,  36,  37,  38,  39 },
+  {  40,  NA,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53, NA,  54,  55,  56,  NA,  57,  58,  59,  60 },
+  {  61,  NA,  62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  72,  NA,  73, NA,  NA,  NA,  NA,  NA,  74,  75,  76,  NA },
+  {  77,  NA,  NA,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  NA, NA,  NA,  89,  NA,  NA,  90,  91,  92,  93 },
+  {  94,  NA,  95,  96,  NA,  NA,  NA,  97,  NA,  NA,  NA,  98,  99, 100, 101, NA, 102, 103, 104,  NA, 105,  NA, 106,  NA }};
+
+static const char* zone_names[] =
+{
+    "AW410K",
+};
+
+static zone_type zone_types[] =
+{
+    ZONE_TYPE_MATRIX,
+};
+
+static const unsigned int zone_sizes[] =
+{
+    107,
+};
+
+typedef struct
+{
+    const char *        name;
+    const unsigned char zone;
+    const unsigned char idx;
+} aw410k_led_type;
+
+static const aw410k_led_type led_names[] =
+{
+    /* Key Label                Zone,                                      Index  */
+    { KEY_EN_ESCAPE,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB0    },
+    { KEY_EN_F1,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x98    },
+    { KEY_EN_F2,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x90    },
+    { KEY_EN_F3,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x88    },
+    { KEY_EN_F4,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x80    },
+    { KEY_EN_F5,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x70    },
+    { KEY_EN_F6,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x68    },
+    { KEY_EN_F7,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x60    },
+    { KEY_EN_F8,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x58    },
+    { KEY_EN_F9,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x50    },
+    { KEY_EN_F10,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x48    },
+    { KEY_EN_F11,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x40    },
+    { KEY_EN_F12,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x38    },
+    { KEY_EN_PRINT_SCREEN,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x30    },
+    { KEY_EN_SCROLL_LOCK,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x28    },
+    { KEY_EN_PAUSE_BREAK,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x20    },
+    { KEY_EN_MEDIA_MUTE,        ALIENWARE_AW410K_ZONE_DIRECT_MEDIA,        0x18    },
+    { KEY_EN_MEDIA_VOLUME_DOWN, ALIENWARE_AW410K_ZONE_DIRECT_MEDIA,        0x10    },
+    { KEY_EN_MEDIA_VOLUME_UP,   ALIENWARE_AW410K_ZONE_DIRECT_MEDIA,        0x08    },
+    { KEY_EN_BACK_TICK,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB1    },
+    { KEY_EN_1,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA1    },
+    { KEY_EN_2,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x99    },
+    { KEY_EN_3,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x91    },
+    { KEY_EN_4,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x89    },
+    { KEY_EN_5,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x81    },
+    { KEY_EN_6,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x79    },
+    { KEY_EN_7,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x71    },
+    { KEY_EN_8,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x69    },
+    { KEY_EN_9,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x61    },
+    { KEY_EN_0,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x59    },
+    { KEY_EN_MINUS,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x51    },
+    { KEY_EN_EQUALS,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x49    },
+    { KEY_EN_BACKSPACE,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x39    },
+    { KEY_EN_INSERT,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x31    },
+    { KEY_EN_HOME,              ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x29    },
+    { KEY_EN_PAGE_UP,           ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x21    },
+    { KEY_EN_NUMPAD_LOCK,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x19    },
+    { KEY_EN_NUMPAD_DIVIDE,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x11    },
+    { KEY_EN_NUMPAD_TIMES,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x09    },
+    { KEY_EN_NUMPAD_MINUS,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x01    },
+    { KEY_EN_TAB,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB2    },
+    { KEY_EN_Q,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA2    },
+    { KEY_EN_W,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x9A    },
+    { KEY_EN_E,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x92    },
+    { KEY_EN_R,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x8A    },
+    { KEY_EN_T,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x82    },
+    { KEY_EN_Y,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x7A    },
+    { KEY_EN_U,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x72    },
+    { KEY_EN_I,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x6A    },
+    { KEY_EN_O,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x62    },
+    { KEY_EN_P,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5A    },
+    { KEY_EN_LEFT_BRACKET,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x52    },
+    { KEY_EN_RIGHT_BRACKET,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x4A    },
+    { KEY_EN_ANSI_BACK_SLASH,   ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x42    },
+    { KEY_EN_DELETE,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x32    },
+    { KEY_EN_END,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x2A    },
+    { KEY_EN_PAGE_DOWN,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x22    },
+    { KEY_EN_NUMPAD_7,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1A    },
+    { KEY_EN_NUMPAD_8,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x12    },
+    { KEY_EN_NUMPAD_9,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0A    },
+    { KEY_EN_NUMPAD_PLUS,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x03    },
+    { KEY_EN_CAPS_LOCK,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB3    },
+    { KEY_EN_A,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA3    },
+    { KEY_EN_S,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x9B    },
+    { KEY_EN_D,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x93    },
+    { KEY_EN_F,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x8B    },
+    { KEY_EN_G,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x83    },
+    { KEY_EN_H,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x7B    },
+    { KEY_EN_J,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x73    },
+    { KEY_EN_K,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x6B    },
+    { KEY_EN_L,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x63    },
+    { KEY_EN_SEMICOLON,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5B    },
+    { KEY_EN_QUOTE,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x53    },
+    { KEY_EN_ANSI_ENTER,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x43    },
+    { KEY_EN_NUMPAD_4,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1B    },
+    { KEY_EN_NUMPAD_5,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x13    },
+    { KEY_EN_NUMPAD_6,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0B    },
+    { KEY_EN_LEFT_SHIFT,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB4    },
+    { KEY_EN_Z,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA4    },
+    { KEY_EN_X,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x9C    },
+    { KEY_EN_C,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x94    },
+    { KEY_EN_V,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x8C    },
+    { KEY_EN_B,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x84    },
+    { KEY_EN_N,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x7C    },
+    { KEY_EN_M,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x74    },
+    { KEY_EN_COMMA,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x6C    },
+    { KEY_EN_PERIOD,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x64    },
+    { KEY_EN_FORWARD_SLASH,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5C    },
+    { KEY_EN_RIGHT_SHIFT,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x4C    },
+    { KEY_EN_UP_ARROW,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x2C    },
+    { KEY_EN_NUMPAD_1,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1C    },
+    { KEY_EN_NUMPAD_2,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x14    },
+    { KEY_EN_NUMPAD_3,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0C    },
+    { KEY_EN_NUMPAD_ENTER,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x05    },
+    { KEY_EN_LEFT_CONTROL,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB5    },
+    { KEY_EN_LEFT_WINDOWS,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xAD    },
+    { KEY_EN_LEFT_ALT,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA5    },
+    { KEY_EN_SPACE,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x85    },
+    { KEY_EN_RIGHT_ALT,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x65    },
+    { KEY_EN_RIGHT_FUNCTION,    ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5D    },
+    { KEY_EN_MENU,              ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x55    },
+    { KEY_EN_RIGHT_CONTROL,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x4D    },
+    { KEY_EN_LEFT_ARROW,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x35    },
+    { KEY_EN_DOWN_ARROW,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x2D    },
+    { KEY_EN_RIGHT_ARROW,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x25    },
+    { KEY_EN_NUMPAD_0,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1D    },
+    { KEY_EN_NUMPAD_PERIOD,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0D    }
+};
+
+/**------------------------------------------------------------------*\
+    @name Alienware AW410 Keyboard
+    @category Keyboard
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAlienwareAW410KControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AlienwareAW410K::RGBController_AlienwareAW410K(AlienwareAW410KController* controller_ptr)
+{
+    controller                      = controller_ptr;
+
+    name                            = "Alienware AW410K Keyboard Device";
+    vendor                          = "Alienware";
+    type                            = DEVICE_TYPE_KEYBOARD;
+    description                     = "Alienware AW410K Keyboard Device";
+    location                        = controller->GetDeviceLocation();
+    serial                          = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name                     = "Direct";
+    Direct.value                    = ALIENWARE_AW410K_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                    = ALIENWARE_AW410K_MODE_STATIC;
+    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min               = 1;
+    Static.colors_max               = 1;
+    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Pulse;
+    Pulse.name                      = "Pulse";
+    Pulse.value                     = ALIENWARE_AW410K_MODE_PULSE;
+    Pulse.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Pulse.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+    Pulse.speed_min                 = ALIENWARE_AW410K_SPEED_SLOWEST;
+    Pulse.speed_max                 = ALIENWARE_AW410K_SPEED_NORMAL;
+    Pulse.speed                     = ALIENWARE_AW410K_SPEED_NORMAL;
+    Pulse.colors_min                = 1;
+    Pulse.colors_max                = 1;
+    Pulse.colors.resize(1);
+    modes.push_back(Pulse);
+
+    mode Morph;
+    Morph.name                      = "Morph";
+    Morph.value                     = ALIENWARE_AW410K_MODE_MORPH;
+    Morph.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Morph.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+    Morph.speed_min                 = ALIENWARE_AW410K_SPEED_SLOWEST;
+    Morph.speed_max                 = ALIENWARE_AW410K_SPEED_NORMAL;
+    Morph.speed                     = ALIENWARE_AW410K_SPEED_NORMAL;
+    Morph.colors_min                = 2;
+    Morph.colors_max                = 2;
+    Morph.colors.resize(2);
+    modes.push_back(Morph);
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = ALIENWARE_AW410K_MODE_BREATHING;
+    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.colors_min            = 1;
+    Breathing.colors_max            = 1;
+    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(1);
+    Breathing.speed_min             = ALIENWARE_AW410K_SPEED_SLOWEST;
+    Breathing.speed_max             = ALIENWARE_AW410K_SPEED_FASTEST;
+    Breathing.speed                 = ALIENWARE_AW410K_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
+    mode SingleWave;
+    SingleWave.name                  = "Single Wave";
+    SingleWave.value                 = ALIENWARE_AW410K_MODE_SINGLE_WAVE;
+    SingleWave.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    SingleWave.speed_min             = ALIENWARE_AW410K_SPEED_SLOWEST;
+    SingleWave.speed_max             = ALIENWARE_AW410K_SPEED_FASTEST;
+    SingleWave.speed                 = ALIENWARE_AW410K_SPEED_NORMAL;
+    SingleWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    SingleWave.colors_min            = 1;
+    SingleWave.colors_max            = 1;
+    SingleWave.colors.resize(1);
+    modes.push_back(SingleWave);
+
+    mode RainbowWave;
+    RainbowWave.name                  = "Rainbow Wave";
+    RainbowWave.value                 = ALIENWARE_AW410K_MODE_RAINBOW_WAVE;
+    RainbowWave.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    RainbowWave.speed_min             = ALIENWARE_AW410K_SPEED_SLOWEST;
+    RainbowWave.speed_max             = ALIENWARE_AW410K_SPEED_FASTEST;
+    RainbowWave.speed                 = ALIENWARE_AW410K_SPEED_NORMAL;
+    RainbowWave.colors_min            = 1;
+    RainbowWave.colors_max            = 1;
+    RainbowWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    RainbowWave.colors.resize(1);
+    modes.push_back(RainbowWave);
+
+    mode Off;
+    Off.name                          = "Off";
+    Off.value                         = ALIENWARE_AW410K_MODE_OFF;
+    Off.flags                         = 0;
+    Off.color_mode                    = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    SetupZones();
+    std::copy(colors.begin(), colors.end(),std::back_inserter(current_colors));
+}
+
+RGBController_AlienwareAW410K::~RGBController_AlienwareAW410K()
+{
+    /*---------------------------------------------------------*\
+    | 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_AlienwareAW410K::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    unsigned int total_led_count = 0;
+
+    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
+    {
+        zone new_zone;
+        new_zone.name                   = zone_names[zone_idx];
+        new_zone.type                   = zone_types[zone_idx];
+        new_zone.leds_min               = zone_sizes[zone_idx];
+        new_zone.leds_max               = zone_sizes[zone_idx];
+        new_zone.leds_count             = zone_sizes[zone_idx];
+
+        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
+        {
+            new_zone.matrix_map         = new matrix_map_type;
+            new_zone.matrix_map->height = 6;
+            new_zone.matrix_map->width  = 24;
+            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
+        }
+
+        zones.push_back(new_zone);
+
+        total_led_count += zone_sizes[zone_idx];
+    }
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
+    {
+        led new_led;
+        new_led.name  = led_names[led_idx].name;
+        new_led.value = led_names[led_idx].idx;
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AlienwareAW410K::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AlienwareAW410K::DeviceUpdateLEDs()
+{
+    std::vector<SelectedButtons>   frame_buf_keys;
+    std::vector<RGBColor>       new_colors;
+
+    std::copy(colors.begin(), colors.end(),std::back_inserter(new_colors));
+
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+            SelectedButtons key;
+
+            key.idx     = (unsigned char)leds[led_idx].value;
+            key.red     = RGBGetRValue(colors[led_idx]);
+            key.green   = RGBGetGValue(colors[led_idx]);
+            key.blue    = RGBGetBValue(colors[led_idx]);
+
+            frame_buf_keys.push_back(key);
+    }
+
+    controller->SendInitialize();
+    controller->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
+    controller->SendCommit();
+
+    if(frame_buf_keys.size() > 0)
+    {
+        controller->SendDirectOn(frame_buf_keys);
+    }
+
+    std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
+}
+
+void RGBController_AlienwareAW410K::UpdateZoneLEDs(int zone)
+{
+    controller->SetDirect((unsigned char) zone, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
+}
+
+void RGBController_AlienwareAW410K::UpdateSingleLED(int led)
+{
+    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+}
+
+void RGBController_AlienwareAW410K::DeviceUpdateMode()
+{
+    if(active_mode == 0xFFFF)
+    {
+        UpdateLEDs();
+        return;
+    }
+
+    controller->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
+    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]);
+    }
+
+    switch(modes[active_mode].value)
+    {
+        case ALIENWARE_AW410K_MODE_DIRECT:
+            /*-------------------------------------------------------------*\
+            | Load LEDs again in case of profile load etc.                  |
+            \*-------------------------------------------------------------*/
+            DeviceUpdateLEDs();
+            break;  
+        case ALIENWARE_AW410K_MODE_MORPH:
+            /*-------------------------------------------------------------*\
+            | In case of morph it requires two colors (color1 and color2)   |
+            \*-------------------------------------------------------------*/
+            {
+                unsigned char red2 = RGBGetRValue(modes[active_mode].colors[1]);
+                unsigned char grn2 = RGBGetGValue(modes[active_mode].colors[1]);
+                unsigned char blu2 = RGBGetBValue(modes[active_mode].colors[1]);
+
+                controller->SetMorphMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu, red2, grn2, blu2);
+            }
+            break;
+
+        case ALIENWARE_AW410K_MODE_SPECTRUM:
+            /*-------------------------------------------------------------*\
+            | Spectrum only set mode, speed and colorMode                   |
+            \*-------------------------------------------------------------*/
+            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW410K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
+            break;
+
+        case ALIENWARE_AW410K_MODE_SINGLE_WAVE:
+            /*-------------------------------------------------------------*\
+            | Wave only set mode, speed, direction and colorMode            |
+            \*-------------------------------------------------------------*/
+            {
+                int waveDirection = GetAW410K_WaveDirection(modes[active_mode].direction);
+                controller->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW410K_SINGLE_COLOR_MODE, red, grn, blu);
+            }
+            break;
+
+        case ALIENWARE_AW410K_MODE_RAINBOW_WAVE:
+            /*-------------------------------------------------------------*\
+            | Wave only set mode, speed, direction and colorMode            |
+            \*-------------------------------------------------------------*/
+            {
+            int waveDirection = GetAW410K_WaveDirection(modes[active_mode].direction);
+            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW410K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
+            }
+            break;
+
+
+        default:
+            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW410K_SINGLE_COLOR_MODE, red, grn, blu);
+            break;
+    }
+}
+
+int GetAW410K_WaveDirection(int input)
+{
+    switch(input)
+    {
+        case MODE_DIRECTION_LEFT:
+            return(ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT);
+
+        case MODE_DIRECTION_RIGHT:
+            return(ALIENWARE_AW410K_DIRECTION_LEFT_TO_RIGHT);
+
+        case MODE_DIRECTION_UP:
+            return(ALIENWARE_AW410K_DIRECTION_BOTTOM_TO_TOP);
+
+        case MODE_DIRECTION_DOWN:
+            return(ALIENWARE_AW410K_DIRECTION_TOP_TO_BOTTOM);
+
+        default:
+            return(ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT);
+    }
+}
+

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW410K.h

@@ -0,0 +1,36 @@
+/*------------------------------------------------------*\
+|  RGBController_AlienwareAW410K.h                       |
+|                                                        |
+|  Generic RGB Interface for Alienware                   |
+|  AW410K keyboard                                       |
+|                                                        |
+|  based on AW510K controller by Mohamad Sallal - msallal|
+|                                                        |
+|  Dominik Mikolajczyk - dmiko 23/10/2023                |
+\*------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AlienwareAW410KController.h"
+
+class RGBController_AlienwareAW410K : public RGBController
+{
+public:
+    RGBController_AlienwareAW410K(AlienwareAW410KController* controller_ptr);
+    ~RGBController_AlienwareAW410K();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AlienwareAW410KController*  controller;
+    std::vector<RGBColor>       current_colors;
+};

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.cpp

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

Controllers/AnnePro2Controller/AnnePro2ControllerDetect.cpp

@@ -4,11 +4,13 @@
 #include "RGBController_AnnePro2.h"
 #include <hidapi/hidapi.h>
 
-#define ANNE_PRO_2_VID 0x04D9
+#define ANNE_PRO_2_VID_1 0x04D9
+#define ANNE_PRO_2_VID_2 0x3311
 #define ANNE_PRO_2_PID_1 0x8008
 #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
 
 /******************************************************************************************\
 *                                                                                          *
@@ -30,7 +32,8 @@ void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
     }
 }
 
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_1, 1);
-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_1, ANNE_PRO_2_PID_1, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_2, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_3, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_4, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_2, ANNE_PRO_2_PID_5, 1);

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

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

Controllers/ArcticController/ArcticController.cpp

@@ -0,0 +1,155 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,29 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,48 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,131 @@
+/*-----------------------------------------*\
+|  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,23 +1,23 @@
 /*-----------------------------------------*\
-|  RGBController_HyperXAlloyOrigins60.h     |
+|  RGBController_Arctic.h                   |
 |                                           |
-|  Generic RGB Interface for HyperX Alloy   |
-|  Origins 60 RGB Keyboard                  |
+|  Generic RGB Interface for Arctic devices |
 |                                           |
-|  Derek Huber 10/24/2022                   |
+|  Armin Wolf (Wer-Wolf) 27/08/2023         |
 \*-----------------------------------------*/
 
 #pragma once
-#include <chrono>
-
+#include "ArcticController.h"
 #include "RGBController.h"
-#include "HyperXAlloyOrigins60Controller.h"
+#include "serial_port.h"
+#include <chrono>
+#include <thread>
 
-class RGBController_HyperXAlloyOrigins60 : public RGBController
+class RGBController_Arctic : public RGBController
 {
 public:
-    RGBController_HyperXAlloyOrigins60(HyperXAlloyOrigins60Controller* controller_ptr);
-    ~RGBController_HyperXAlloyOrigins60();
+    RGBController_Arctic(ArcticController* controller_ptr);
+    ~RGBController_Arctic();
 
     void        SetupZones();
 
@@ -29,11 +29,12 @@ public:
 
     void        DeviceUpdateMode();
 
-    void        KeepaliveThread();
+    void        KeepaliveThreadFunction();
 
 private:
-    HyperXAlloyOrigins60Controller*                     controller;
-    std::thread*                                        keepalive_thread;
-    std::atomic<bool>                                   keepalive_thread_run;
+    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,3 +55,4 @@ 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,6 +9,8 @@
 
 #include "AsusAuraCoreLaptopController.h"
 
+#include "SettingsManager.h"
+
 static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT       +
                           ASUSAURACORELAPTOP_LIGHTBARCOUNT  +
                           ASUSAURACORELAPTOP_LIDCOUNT       ] =

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.h

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

Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.cpp

@@ -406,6 +406,8 @@ 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;
@@ -414,6 +416,8 @@ 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/AsusAuraGPUController.cpp

@@ -7,6 +7,7 @@
 \*-----------------------------------------*/
 
 #include "AsusAuraGPUController.h"
+#include "pci_ids.h"
 #include <cstring>
 
 AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev)
@@ -52,25 +53,16 @@ unsigned char AuraGPUController::GetLEDBlue()
     return(AuraGPURegisterRead(AURA_GPU_REG_BLUE));
 }
 
-void AuraGPUController::SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue)                  // Direct Mode is just Static Mode without applying color changes
+void AuraGPUController::SetLEDColors(unsigned char red, unsigned char green, unsigned char blue)
 {
     AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
     AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
     AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
 }
 
-void AuraGPUController::SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
-    AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
-    AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
-    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
-}
-
 void AuraGPUController::SetMode(unsigned char mode)
 {
     AuraGPURegisterWrite(AURA_GPU_REG_MODE, mode);
-    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
 }
 
 unsigned char AuraGPUController::AuraGPURegisterRead(unsigned char reg)
@@ -81,4 +73,21 @@ unsigned char AuraGPUController::AuraGPURegisterRead(unsigned char reg)
 void AuraGPUController::AuraGPURegisterWrite(unsigned char reg, unsigned char val)
 {
     bus->i2c_smbus_write_byte_data(dev, reg, val);
-}
+}
+
+bool AuraGPUController::SaveOnlyApplies()
+{
+    switch (bus->pci_subsystem_device)
+    {
+        case ASUS_VEGA64_STRIX:
+            return false;
+    }
+    // Behavior on other GPU models is unknown and needs to be tested.
+    // Assume the safest option to prevent damaage from excessive writes.
+    return false;
+}
+
+void AuraGPUController::Save()
+{
+    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
+}

Controllers/AsusAuraGPUController/AsusAuraGPUController.h

@@ -23,7 +23,7 @@ enum
     AURA_GPU_REG_BLUE                       = 0x06,    /* AURA GPU BLUE Register           */
     AURA_GPU_REG_MODE                       = 0x07,    /* AURA GPU Mode Selection Register */
     AURA_GPU_REG_SYNC                       = 0x0C,    /* AURA GPU "Sync" Register         */
-    AURA_GPU_REG_APPLY                      = 0x0E,    /* AURA GPU Apply Chnages Register  */
+    AURA_GPU_REG_APPLY                      = 0x0E,    /* AURA GPU Save or Apply Register  */
 };
 
 enum
@@ -48,17 +48,18 @@ public:
     unsigned char GetLEDRed();
     unsigned char GetLEDGreen();
     unsigned char GetLEDBlue();
-    void          SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetLEDColors(unsigned char red, unsigned char green, unsigned char blue);
     void          SetMode(unsigned char mode);
+    void          Save();
 
     unsigned char AuraGPURegisterRead(unsigned char reg);
     void          AuraGPURegisterWrite(unsigned char reg, unsigned char val);
 
+    bool          SaveOnlyApplies();
     bool          direct = false;                                                // Temporary solution to check if we are in "Direct" mode
 
 private:
     char                    device_name[16];
     i2c_smbus_interface *   bus;
     aura_gpu_dev_id         dev;
-};
+};

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -69,67 +69,69 @@ void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
 |  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);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1060 Strix"                       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX,                         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1070 Strix Gaming"                , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_GAMING,                  0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1070 Strix OC"                    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_OC,                      0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1070 Ti 8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1070 Ti A8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1080 Strix OC"                    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_GTX1080_STRIX,                         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 A8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 O8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 O8G 11Gbps"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_11GBPS,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti Gaming"          , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti 11G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti O11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti O11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650S OC 4G"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A);
-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 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 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 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 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 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);
+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 ROG GTX 1060 Strix 6G Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX_6G_GAMING,               0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1060 Strix"                      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX,                         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1070 Strix Gaming"               , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_GAMING,                  0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1070 Strix OC"                   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_OC,                      0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1070 Ti 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1070 Ti A8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1080 Strix OC"                   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_GTX1080_STRIX,                         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 A8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 O8G 11Gbps"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_11GBPS,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650 SUPER OC 4G"          , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 SUPER O6G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 SUPER 6G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_6G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix 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 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 2060 SUPER 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 2060 SUPER 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 2060 SUPER 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 2060 SUPER 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 2070 SUPER 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 2070 SUPER 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 2070 SUPER 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 2070 SUPER 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 2070 SUPER 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 2070 SUPER 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 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 SUPER 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 2080 SUPER 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 2080 SUPER 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 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 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 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 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 ROG Vega 64 Strix"                       , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5600 XT Strix O6G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5700 XT Strix Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5700 XT 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 RX 470 O4G Gaming"             , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 480 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 RX 560 Gaming"                 , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG 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 ROG 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 ROG 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 ROG RX 580 Strix Gaming TOP"             , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp

@@ -45,11 +45,15 @@ int RGBController_AuraGPU::GetDeviceMode()
     @name Asus Aura GPU
     @category GPU
     @type SMBus
-    @save :x:
+    @save :tools:
     @direct :white_check_mark:
     @effects :white_check_mark:
     @detectors DetectAsusAuraGPUControllers
-    @comment
+    @comment On some models save command might function like apply.
+        Known models with correctly working save: ASUS Vega 64 Strix.
+        This may result in changes not applying until user clicks
+        "save to device". Contact OpenRGB developers if you have one
+        of the affected models.
 \*-------------------------------------------------------------------*/
 
 RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)
@@ -69,38 +73,44 @@ RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)
     Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
+    unsigned int save_flags = 0;
+    if(!controller->SaveOnlyApplies())
+    {
+        save_flags |= MODE_FLAG_MANUAL_SAVE;
+    }
+
     mode Off;
     Off.name       = "Off";
     Off.value      = AURA_GPU_MODE_OFF;
-    Off.flags      = 0;
+    Off.flags      = save_flags;
     Off.color_mode = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Static;
     Static.name       = "Static";
     Static.value      = AURA_GPU_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR | save_flags;
     Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Breathing;
     Breathing.name       = "Breathing";
     Breathing.value      = AURA_GPU_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR | save_flags;
     Breathing.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Breathing);
 
     mode Flashing;
     Flashing.name       = "Flashing";
     Flashing.value      = AURA_GPU_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR | save_flags;
     Flashing.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Flashing);
 
     mode Spectrum_Cycle;
     Spectrum_Cycle.name       = "Spectrum Cycle";
-    Spectrum_Cycle.value      = AURA_GPU_MODE_SPECTRUM_CYCLE;
-    Spectrum_Cycle.flags      = 0;
+    Spectrum_Cycle.value      = AURA_GPU_MODE_SPECTRUM_CYCLE ;
+    Spectrum_Cycle.flags      = save_flags;
     Spectrum_Cycle.color_mode = MODE_COLORS_NONE;
     modes.push_back(Spectrum_Cycle);
 
@@ -162,14 +172,11 @@ void RGBController_AuraGPU::DeviceUpdateLEDs()
         unsigned char grn = RGBGetGValue(colors[led]);
         unsigned char blu = RGBGetBValue(colors[led]);
 
-        if (GetMode() == 0)
-        {
-            controller->SetLEDColorsDirect(red, grn, blu);
-        }
-        else
-        {
-            controller->SetLEDColorsEffect(red, grn, blu);
-        }
+        controller->SetLEDColors(red, grn, blu);
+    }
+    if (controller->SaveOnlyApplies() && GetMode() != 0)
+    {
+        controller->Save();
     }
 }
 
@@ -192,7 +199,7 @@ void RGBController_AuraGPU::DeviceUpdateMode()
     {
         // Set all LEDs to 0 and Mode to static as a workaround for the non existing Off Mode
         case AURA_GPU_MODE_OFF:
-            controller->SetLEDColorsEffect(0, 0, 0);
+            controller->SetLEDColors(0, 0, 0);
             new_mode           = AURA_GPU_MODE_STATIC;
             break;
 
@@ -204,4 +211,13 @@ void RGBController_AuraGPU::DeviceUpdateMode()
     }
 
     controller->SetMode(new_mode);
+    if (controller->SaveOnlyApplies())
+    {
+        controller->Save();
+    }
+}
+
+void RGBController_AuraGPU::DeviceSaveMode()
+{
+    controller->Save();
 }

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.h

@@ -26,6 +26,7 @@ public:
     void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
     AuraGPUController* controller;

Controllers/AsusAuraUSBController/AsusAuraAddressableController.cpp

@@ -28,37 +28,12 @@ AuraAddressableController::~AuraAddressableController()
 
 void AuraAddressableController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
 {
-    unsigned char   led_data[60];
-    unsigned int    leds_sent = 0;
-
-    while(leds_sent < num_colors)
-    {
-        unsigned int leds_to_send = 20;
-
-        if((num_colors - leds_sent) < leds_to_send)
-        {
-            leds_to_send = num_colors - leds_sent;
-        }
-
-        for(unsigned int led_idx = 0; led_idx < leds_to_send; led_idx++)
-        {
-            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]);
-        }
-
-        SendDirect
-        (
-            channel,
-            leds_sent,
-            leds_to_send,
-            led_data
-        );
-
-        leds_sent += leds_to_send;
-    }
-
-    SendDirectApply(channel);
+    SendDirect
+    (
+        device_info[channel].direct_channel,
+        num_colors,
+        colors
+    );
 }
 
 void AuraAddressableController::SetMode
@@ -117,28 +92,3 @@ void AuraAddressableController::SendEffect
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
 }
-
-void AuraAddressableController::SendDirectApply
-    (
-    unsigned char   channel
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
-    usb_buf[0x02]   = 0x80 | channel;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}

Controllers/AsusAuraUSBController/AsusAuraAddressableController.h

@@ -52,9 +52,4 @@ private:
         unsigned char   grn,
         unsigned char   blu
         );
-
-    void    SendDirectApply
-        (
-        unsigned char   channel
-        );
 };

Controllers/AsusAuraUSBController/AsusAuraMainboardController.cpp

@@ -15,6 +15,7 @@ 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)
     {
@@ -24,14 +25,18 @@ AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const c
     /*-----------------------------------------------------*\
     | Add mainboard device                                  |
     \*-----------------------------------------------------*/
-    device_info.push_back({0x00, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});
+    if(num_total_mainboard_leds > 0)
+    {
+        device_info.push_back({effect_channel, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});
+        effect_channel++;
+    }
 
     /*-----------------------------------------------------*\
     | Add addressable devices                               |
     \*-----------------------------------------------------*/
     for(int i = 0; i < num_addressable_headers; i++)
     {
-        device_info.push_back({0x01, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
+        device_info.push_back({effect_channel, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
     }
 }
 
@@ -41,36 +46,13 @@ AuraMainboardController::~AuraMainboardController()
 
 void AuraMainboardController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
 {
-    unsigned char   led_data[60];
-    unsigned int    leds_sent = 0;
+    SendDirect
+    (
+        device_info[channel].direct_channel,
+        num_colors,
+        colors
+    );
 
-    while(leds_sent < num_colors)
-    {
-        unsigned int leds_to_send = 20;
-
-        if((num_colors - leds_sent) < leds_to_send)
-        {
-            leds_to_send = num_colors - leds_sent;
-        }
-
-        for(unsigned int led_idx = 0; led_idx < leds_to_send; led_idx++)
-        {
-            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]);
-        }
-
-        SendDirect
-        (
-            device_info[channel].direct_channel,
-            leds_sent,
-            leds_to_send,
-            led_data,
-            leds_sent + leds_to_send >= num_colors
-        );
-
-        leds_sent += leds_to_send;
-    }
 }
 
 void AuraMainboardController::SetMode
@@ -81,11 +63,24 @@ 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);
+    SendEffect(device_info[channel].effect_channel, mode, shutdown_effect);
     if(mode == AURA_MODE_DIRECT)
     {
         return;
@@ -111,7 +106,8 @@ void AuraMainboardController::SetMode
         channel,
         start_led,
         device_info[channel].num_leds,
-        led_data
+        led_data,
+        shutdown_effect
     );
 }
 
@@ -123,7 +119,8 @@ unsigned short AuraMainboardController::GetMask(int start, int size)
 void AuraMainboardController::SendEffect
     (
     unsigned char   channel,
-    unsigned char   mode
+    unsigned char   mode,
+    bool            shutdown_effect
     )
 {
     unsigned char usb_buf[65];
@@ -140,7 +137,7 @@ void AuraMainboardController::SendEffect
     usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT;
     usb_buf[0x02]   = channel;
     usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = 0x00;
+    usb_buf[0x04]   = shutdown_effect ? 0x01 : 0x00;
     usb_buf[0x05]   = mode;
 
     /*-----------------------------------------------------*\
@@ -154,7 +151,8 @@ void AuraMainboardController::SendColor
     unsigned char   /*channel*/,
     unsigned char   start_led,
     unsigned char   led_count,
-    unsigned char*  led_data
+    unsigned char*  led_data,
+    bool            shutdown_effect
     )
 {
     unsigned short  mask = GetMask(start_led, led_count);
@@ -172,7 +170,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]   = 0x00;
+    usb_buf[0x04]   = shutdown_effect ? 0x01 : 0x00;
 
     /*-----------------------------------------------------*\
     | Copy in color data bytes                              |

Controllers/AsusAuraUSBController/AsusAuraMainboardController.h

@@ -44,15 +44,28 @@ 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
+        unsigned char   mode,
+        bool            shutdown_effect
         );
 
     void SendColor
@@ -60,8 +73,7 @@ private:
         unsigned char   channel,
         unsigned char   start_led,
         unsigned char   led_count,
-        unsigned char*  led_data
+        unsigned char*  led_data,
+        bool            shutdown_effect
         );
-
-    void SendCommit();
 };

Controllers/AsusAuraUSBController/AsusAuraMonitorController.cpp

@@ -49,7 +49,7 @@ void AuraMonitorController::BeginUpdate()
 {
     unsigned char usb_buf[8];
 
-    if (device_pid == AURA_ROG_PG32UQ_PID)
+    if (device_pid == AURA_ROG_PG32UQ_PID || device_pid == AURA_ROG_STRIX_XG32VC_PID)
     {
         memset(usb_buf, 0x00, sizeof(usb_buf));
 
@@ -83,17 +83,19 @@ void AuraMonitorController::UpdateLed
     usb_buf[0x02]   = 0xA1;
     usb_buf[0x03]   = 0x80;
 
-    usb_buf[0x04]   = 16 + led * 3;
+    unsigned char offset = (device_pid == AURA_ROG_STRIX_XG279Q_PID) ? 0 : 16;
+
+    usb_buf[0x04]   = offset + led * 3;
     usb_buf[0x05]   = red;
     
     hid_send_feature_report(dev, usb_buf, 8);
 
-    usb_buf[0x04]   = 16 + led * 3 + 1;
+    usb_buf[0x04]   = offset + led * 3 + 1;
     usb_buf[0x05]   = blue;
     
     hid_send_feature_report(dev, usb_buf, 8);
 
-    usb_buf[0x04]   = 16 + led * 3 + 2;
+    usb_buf[0x04]   = offset + led * 3 + 2;
     usb_buf[0x05]   = green;
     
     hid_send_feature_report(dev, usb_buf, 8);

Controllers/AsusAuraUSBController/AsusAuraMonitorController.h

@@ -15,9 +15,12 @@
 
 enum
 {
-    AURA_ROG_STRIX_XG27AQ_PID    = 0x198C,
-    AURA_ROG_STRIX_XG27W_PID     = 0x1933,
-    AURA_ROG_PG32UQ_PID          = 0x19B9,
+    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_STRIX_XG32VC_PID   = 0x1968,
+    AURA_ROG_PG32UQ_PID         = 0x19B9,
 };
 
 

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

@@ -28,6 +28,32 @@ std::string AuraMouseController::GetDeviceLocation()
     return("HID: " + location);
 }
 
+std::string AuraMouseController::CleanSerial(const std::wstring& wstr)
+{
+    /*---------------------------------------------------------------*\
+    | Cleanes garbage at the end of serial numbers                    |
+    | (apparently 2 characters too much, but maybe variable)          |
+    | Limited to new devices, old ones don't even have serial numbers |
+    \*---------------------------------------------------------------*/
+    std::string result;
+    for(wchar_t c : wstr)
+    {
+        /*-----------------------------------------------------*\
+        | Forbid anything besides digits and upper case letters |
+        \*-----------------------------------------------------*/
+        bool isUpperCaseLetter = (c >= 64 && c <= 90);
+        bool isDigit           = (c >= 48 && c <= 57);
+        if(!isUpperCaseLetter && !isDigit)
+        {
+            break;
+        }
+
+        result += c;
+    }
+
+    return(result);
+}
+
 std::string AuraMouseController::GetSerialString()
 {
     wchar_t serial_string[HID_MAX_STR];
@@ -38,8 +64,8 @@ std::string AuraMouseController::GetSerialString()
         return("");
     }
 
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
+    std::wstring serial_wstring = serial_string;
+    std::string return_string = CleanSerial(serial_wstring);
 
     return(return_string);
 }
@@ -184,3 +210,48 @@ void AuraMouseController::SendUpdate
     unsigned char usb_buf_out[ASUS_AURA_MOUSE_PACKET_SIZE];
     hid_read_timeout(dev, usb_buf_out, ASUS_AURA_MOUSE_PACKET_SIZE, 10);
 }
+
+void AuraMouseController::SendDirect
+    (
+    std::vector<RGBColor>   zone_colors
+    )
+{
+    std::vector<RGBColor> colors = {};
+    colors.resize(aura_mouse_led_maps[device_pid].led_amount);
+
+    for(unsigned char zone = 0; zone < zone_colors.size(); zone++)
+    {
+        std::vector<uint8_t> zone_map = aura_mouse_led_maps[device_pid].map[zone];
+        for(unsigned char led = 0; led < zone_map.size(); led++)
+        {
+            colors[zone_map[led]] = zone_colors[zone];
+        }
+    }
+
+    /*-----------------------------------------------------*\
+    | Only 5 colors can be sent in each packet              |
+    \*-----------------------------------------------------*/
+    for(unsigned char led = 0; led < aura_mouse_led_maps[device_pid].led_amount; led += 5)
+    {
+        unsigned char usb_buf[ASUS_AURA_MOUSE_PACKET_SIZE];
+        memset(usb_buf, 0x00, ASUS_AURA_MOUSE_PACKET_SIZE);
+
+        unsigned char colors_in_packet = (aura_mouse_led_maps[device_pid].led_amount >= led + 5) ? 5 : aura_mouse_led_maps[device_pid].led_amount - led;
+
+        usb_buf[0x00]   = 0x00;
+        usb_buf[0x01]   = 0x51;
+        usb_buf[0x02]   = 0x29;
+        usb_buf[0x03]   = colors_in_packet; // colors in this packet
+        usb_buf[0x04]   = 0x00;
+        usb_buf[0x05]   = led; // offset
+
+        for(unsigned char color = 0; color < colors_in_packet; color++)
+        {
+            usb_buf[0x06 + color * 3] = RGBGetRValue(colors[led + color]);
+            usb_buf[0x07 + color * 3] = RGBGetGValue(colors[led + color]);
+            usb_buf[0x08 + color * 3] = RGBGetBValue(colors[led + color]);
+        }
+
+        hid_write(dev, usb_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
+    }
+};

Controllers/AsusAuraUSBController/AsusAuraMouseController.h

@@ -25,6 +25,7 @@ public:
     virtual ~AuraMouseController();
 
     std::string GetDeviceLocation();
+    std::string CleanSerial(const std::wstring& wstr);
     std::string GetSerialString();
     std::string GetVersion(bool wireless, int protocol);
 
@@ -41,6 +42,10 @@ public:
         unsigned char   speed,
         unsigned char   brightness
         );
+    void SendDirect
+        (
+        std::vector<RGBColor>   zone_colors
+        );
 
     uint16_t                    device_pid;
 

Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h

@@ -11,38 +11,50 @@
 
 #pragma once
 
-#define AURA_ROG_GLADIUS_II_CORE_PID                0x18DD
-#define AURA_ROG_GLADIUS_II_PID                     0x1845
-#define AURA_ROG_GLADIUS_II_ORIGIN_PID              0x1877
-#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID      0x18CD
-#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_PUGIO_PID                          0x1846
-#define AURA_ROG_PUGIO_II_WIRED_PID                 0x1906
-#define AURA_ROG_PUGIO_II_WIRELESS_PID              0x1908
-#define AURA_ROG_STRIX_IMPACT_PID                   0x1847
-#define AURA_ROG_STRIX_IMPACT_II_PID                0x18E1
-#define AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID         0x189E
-#define AURA_ROG_STRIX_IMPACT_II_PUNK_PID           0x1956
-#define AURA_ROG_STRIX_IMPACT_II_WHITE_PID          0x19D2
-#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID   0x1947
-#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID   0x1949
-#define AURA_ROG_KERIS                              0x195C
-#define AURA_ROG_KERIS_WIRELESS_USB_PID             0x195E
-#define AURA_ROG_KERIS_WIRELESS_2_4_PID             0x1960
-#define AURA_ROG_KERIS_WIRELESS_BT_PID              0x1962
-#define AURA_TUF_M3_PID                             0x1910
-#define AURA_TUF_M5_PID                             0x1898
+#define AURA_ROG_GLADIUS_II_CORE_PID                    0x18DD
+#define AURA_ROG_GLADIUS_II_PID                         0x1845
+#define AURA_ROG_GLADIUS_II_ORIGIN_PID                  0x1877
+#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID          0x18CD
+#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_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID  0x1A70
+#define AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID  0x1A72
+#define AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_BT_PID   0x1A74
+#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
+#define AURA_ROG_STRIX_IMPACT_PID                       0x1847
+#define AURA_ROG_STRIX_IMPACT_II_PID                    0x18E1
+#define AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID             0x189E
+#define AURA_ROG_STRIX_IMPACT_II_PUNK_PID               0x1956
+#define AURA_ROG_STRIX_IMPACT_II_WHITE_PID              0x19D2
+#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID       0x1947
+#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID       0x1949
+#define AURA_ROG_STRIX_IMPACT_III_PID                   0x1A88
+#define AURA_ROG_KERIS                                  0x195C
+#define AURA_ROG_KERIS_WIRELESS_USB_PID                 0x195E
+#define AURA_ROG_KERIS_WIRELESS_2_4_PID                 0x1960
+#define AURA_ROG_KERIS_WIRELESS_BT_PID                  0x1962
+#define AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID        0x1A66
+#define AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID        0x1A68
+#define AURA_ROG_KERIS_WIRELESS_AIMPOINT_BT_PID         0x1A6A
+#define AURA_TUF_M3_PID                                 0x1910
+#define AURA_TUF_M5_PID                                 0x1898
+
+#define AURA_ROG_SPATHA_X_DOCK_FAKE_PID                 0xFFFF
 
 enum
 {
@@ -50,6 +62,7 @@ enum
     AURA_MOUSE_ZONE_SCROLL      = 1,
     AURA_MOUSE_ZONE_UNDERGLOW   = 2,
     AURA_MOUSE_ZONE_ALL         = 3,
+    AURA_MOUSE_ZONE_DOCK        = 4,
 };
 
 enum
@@ -61,6 +74,7 @@ enum
     AURA_MOUSE_MODE_REACTIVE    = 4,
     AURA_MOUSE_MODE_COMET       = 5,
     AURA_MOUSE_MODE_BATTERY     = 6,
+    AURA_MOUSE_MODE_DIRECT      = 254,
     AURA_MOUSE_MODE_NONE        = 255,
 };
 
@@ -72,6 +86,7 @@ typedef struct
     uint8_t                 brightness_max;
     bool                    wireless;
     int                     version_protocol;
+    bool                    direct;
     std::vector<uint8_t>    mouse_zones;
     std::vector<uint8_t>    mouse_modes;
 } mouse_type;
@@ -95,6 +110,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,      // Brightness Max
             false,  // is wireless? (important for fetching the version)
             1,      // version protocol
+            false,  // direct - defines whether the mouse has a native direct mode or just uses static as direct (only present on newer devices)
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -108,6 +124,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             0,
+            false,
             { 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 }
         }
@@ -121,6 +138,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             0,
+            false,
             { 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 }
         }
@@ -134,6 +152,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             0,
+            false,
             { 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 }
         }
@@ -147,6 +166,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             0,
+            false,
             { 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 }
         }
@@ -160,6 +180,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             true,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { 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 }
         }
@@ -173,6 +194,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             true,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { 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 }
         }
@@ -183,9 +205,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
             255,
             1,
             0,
-            64,
+            100,
             false,
             1,
+            false,
             { 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 }
         }
@@ -196,9 +219,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
             255,
             1,
             0,
-            64,
+            100,
             false,
             1,
+            false,
             { 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 }
         }
@@ -209,9 +233,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
             255,
             1,
             0,
-            64,
+            100,
             true,
             1,
+            false,
             { 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 }
         }
@@ -222,13 +247,42 @@ static std::map<int,mouse_type> aura_mouse_devices =
             255,
             1,
             0,
-            64,
+            100,
             true,
             1,
+            false,
             { 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_AIMPOINT_USB_PID, // ROG Gladius III Wireless AimPoint USB
+        {
+            255,
+            1,
+            0,
+            100,
+            false,
+            2,
+            true,
+            { 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_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
+    {
+        AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID, // ROG Gladius III Wireless AimPoint 2.4 GHz Dongle
+        {
+            255,
+            1,
+            0,
+            100,
+            true,
+            2,
+            true,
+            { 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_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
     {
         AURA_ROG_CHAKRAM_WIRELESS_PID, // ROG Chakram Wireless
         {
@@ -238,6 +292,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             true,
             1,
+            false,
             { 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 }
         }
@@ -251,6 +306,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { 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 }
         }
@@ -264,6 +320,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -271,12 +328,13 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_CHAKRAM_X_USB_PID, // ROG Chakram X USB
         {
-            0,
-            0,
-            0,
-            4,
-            false,
+            15, // technically until 255, but unusably slow after 15
             1,
+            0,
+            100,
+            false,
+            2,
+            true,
             { 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 }
         }
@@ -284,12 +342,41 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_CHAKRAM_X_2_4_PID, // ROG Chakram X 2.4GHz Dongle
         {
-            255,
+            15, // technically until 255, but unusably slow after 15
             1,
             0,
-            64,
+            100,
             true,
             2,
+            true,
+            { 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,
+            true,
+            { 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,
+            true,
             { 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 }
         }
@@ -303,6 +390,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             0,
+            false,
             { 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 }
         }
@@ -316,6 +404,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { 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 }
         }
@@ -329,6 +418,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             true,
             1,
+            false,
             { 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 }
         }
@@ -342,8 +432,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             4,
+            false,
             { AURA_MOUSE_ZONE_LOGO },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM }
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
         }
     },
     {
@@ -355,6 +446,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { 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_REACTIVE }
         }
@@ -368,6 +460,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { 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_REACTIVE }
         }
@@ -381,6 +474,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { 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_REACTIVE }
         }
@@ -394,6 +488,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { 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_REACTIVE }
         }
@@ -407,6 +502,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1, // not tested, but likely same as ROG Strix Impact II non wireless
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
@@ -420,10 +516,25 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             true,
             1, // not tested, but likely same as ROG Strix Impact II non wireless
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
     },
+    {
+        AURA_ROG_STRIX_IMPACT_III_PID, // ROG Strix Impact III
+        {
+            0,
+            0,
+            0,
+            100,
+            false,
+            1,
+            true,
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
+        }
+    },
     {
         AURA_ROG_KERIS, // ROG Keris
         {
@@ -432,7 +543,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             4,
             false,
-            1, // might be the wrong protocol for version
+            1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -444,8 +556,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             0,
             4,
-            true,
-            1, // might be the wrong protocol for version
+            false,
+            1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { 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 }
         }
@@ -458,7 +571,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             4,
             true,
-            1, // might be the wrong protocol for version
+            1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { 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 }
         }
@@ -471,11 +585,40 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             4,
             true,
-            1, // might be the wrong protocol for version
+            1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { 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_KERIS_WIRELESS_AIMPOINT_USB_PID, // ROG Keris Wireless AimPoint
+        {
+            0,
+            0,
+            0,
+            100,
+            false,
+            1,
+            true,
+            { 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_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
+    {
+        AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID, // ROG Keris Wireless AimPoint
+        {
+            0,
+            0,
+            0,
+            100,
+            true,
+            2,
+            true,
+            { 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_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
     {
         AURA_TUF_M3_PID, // TUF M3
         {
@@ -485,6 +628,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -498,8 +642,132 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             3,
+            false,
             { 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,
+            false,
+            { 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 }
+        }
+    },
+};
+
+typedef struct
+{
+    unsigned char                                           led_amount;
+    std::map< unsigned char, std::vector<unsigned char>>    map;
+} led_map;
+
+/*-----------------------------------------------------------------*\
+|  LED MAP                                                          |
+|                                                                   |
+|    This maps the LEDs to the correct zone.                        |
+|    This is necessary, because openrgb doesn't support per-zone    |
+|    lighting. To allow for per-zone color of modes like breathing, |
+|    the leds defined need to be the zones, which means the actual  |
+|    LEDs can't be implemented.                                     |
+\*-----------------------------------------------------------------*/
+static std::map<unsigned short, led_map > aura_mouse_led_maps =
+{
+    {
+        AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID,
+        {
+            1,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID,
+        {
+            1,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID,
+        {
+            1,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID,
+        {
+            1,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_SPATHA_X_2_4_PID,
+        {
+            5,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+                { AURA_MOUSE_ZONE_SCROLL, { 1 } },
+                { AURA_MOUSE_ZONE_UNDERGLOW, { 2, 3, 4 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_SPATHA_X_USB_PID,
+        {
+            5,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+                { AURA_MOUSE_ZONE_SCROLL, { 1 } },
+                { AURA_MOUSE_ZONE_UNDERGLOW, { 2, 3, 4 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_CHAKRAM_X_USB_PID,
+        {
+            9,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 7 } },
+                { AURA_MOUSE_ZONE_SCROLL, { 8 } },
+                { AURA_MOUSE_ZONE_UNDERGLOW, { 0, 1, 2, 3, 4, 5, 6 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_CHAKRAM_X_2_4_PID,
+        {
+            9,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 7 } },
+                { AURA_MOUSE_ZONE_SCROLL, { 8 } },
+                { AURA_MOUSE_ZONE_UNDERGLOW, { 0, 1, 2, 3, 4, 5, 6 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_STRIX_IMPACT_III_PID,
+        {
+            2,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+                { AURA_MOUSE_ZONE_SCROLL, { 1 } },
+            }
+        }
+    }
 };

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.cpp

@@ -0,0 +1,176 @@
+/*-----------------------------------------*\
+|  AsusAuraMouseGen1Controller.cpp          |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#include "AsusAuraMouseGen1Controller.h"
+
+#include <cstring>
+#include <chrono>
+#include <thread>
+
+AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid)
+{
+    dev         = dev_handle;
+    location    = path;
+    device_pid  = pid;
+}
+
+AsusAuraMouseGen1Controller::~AsusAuraMouseGen1Controller()
+{
+    hid_close(dev);
+}
+
+std::string AsusAuraMouseGen1Controller::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AsusAuraMouseGen1Controller::GetSerialString()
+{
+    wchar_t serial_string[HID_MAX_STR];
+    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
+
+    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 AsusAuraMouseGen1Controller::GetVersion()
+{
+    unsigned char usb_buf[9] = { 0x0C, 0xC4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+    usb_buf[3] = (device_pid == 0x1824) ? 0x02 : 0x00;
+    hid_send_feature_report(dev, usb_buf, 9);
+
+    unsigned char usb_buf_out[9] = { 0x0C };
+    hid_get_feature_report(dev, usb_buf_out, 9);
+
+    return std::string("1." +  std::to_string(usb_buf_out[3]));
+}
+
+int AsusAuraMouseGen1Controller::GetActiveProfile()
+{
+    unsigned char profile;
+
+    unsigned char profile_amount = 0;
+    unsigned char profile_key    = 0;
+
+    switch(device_pid)
+    {
+        case 0x185B:
+            profile_amount = 3;
+            profile_key    = 0xF0;
+            break;
+        case 0x181C:
+        case 0x1824:
+        default:
+            profile_amount = 6;
+            profile_key    = 0x60;
+            break;
+    }
+
+    do
+    {
+        unsigned char usb_buf[9] = { 0x0C, 0xDF, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+        hid_send_feature_report(dev, usb_buf, 9);
+
+        unsigned char usb_buf_out[9] = { 0x0C };
+        hid_get_feature_report(dev, usb_buf_out, 9);
+
+        profile = usb_buf_out[4];
+    } while(profile < profile_key || profile > profile_key + profile_amount - 1);
+
+    return (profile % 16) + 1;
+}
+
+void AsusAuraMouseGen1Controller::SendUpdate
+    (
+    unsigned char   key,
+    unsigned char   value
+    )
+{
+    unsigned char usb_buf[9];
+
+    memset(usb_buf, 0x00, 9);
+
+    usb_buf[0x00]   = 0x0C;
+    usb_buf[0x01]   = 0xC4;
+    usb_buf[0x02]   = 0x0F;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = key;
+    usb_buf[0x05]   = value;
+    hid_send_feature_report(dev, usb_buf, 9);
+
+    unsigned char buf_in[9];
+    buf_in[0] = 0x0C;
+    hid_get_feature_report(dev, buf_in, 9);
+    
+    std::this_thread::sleep_for(std::chrono::milliseconds(15));
+}
+
+
+void AsusAuraMouseGen1Controller::UpdateProfile
+    (
+    unsigned char   key,
+    unsigned char   profile,
+    unsigned char   value
+    )
+{
+    unsigned char usb_buf[9];
+
+    memset(usb_buf, 0x00, 9);
+
+    usb_buf[0x00]   = 0x0C;
+    usb_buf[0x01]   = 0xDE;
+    usb_buf[0x02]   = key;
+    usb_buf[0x03]   = profile;
+    usb_buf[0x04]   = value;
+    hid_send_feature_report(dev, usb_buf, 9);
+
+    unsigned char buf_in[9];
+    buf_in[0] = 0x0C;
+    hid_get_feature_report(dev, buf_in, 9);
+}
+
+void AsusAuraMouseGen1Controller::SendDirectSpatha(std::vector<RGBColor> colors)
+{
+    unsigned char usb_buf[33];
+
+    memset(usb_buf, 0x00, 33);
+
+    usb_buf[0x00]   = 0x10;
+    usb_buf[0x01]   = 0x00;
+    usb_buf[0x02]   = 0xF0;
+    usb_buf[0x03]   = 0x00;
+    
+    for(unsigned char i = 0; i < 3; i++)
+    {
+        usb_buf[4 + i * 3] = RGBGetRValue(colors[i]);
+        usb_buf[5 + i * 3] = RGBGetGValue(colors[i]);
+        usb_buf[6 + i * 3] = RGBGetBValue(colors[i]);
+    }
+
+    hid_send_feature_report(dev, usb_buf, 33);
+}
+
+void AsusAuraMouseGen1Controller::ResetToSavedLighting()
+{
+    unsigned char usb_buf[9];
+
+    memset(usb_buf, 0x00, 9);
+
+    usb_buf[0x00]   = 0x0C;
+    usb_buf[0x01]   = 0xC4;
+
+    hid_send_feature_report(dev, usb_buf, 9);
+}

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraStrixEvolveController.h          |
+|  AsusAuraMouseGen1Controller.h            |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  USB RGB lighting controller              |
@@ -10,17 +10,18 @@
 #include "RGBController.h"
 
 #include <string>
+#include <vector>
 #include <hidapi/hidapi.h>
 
 #pragma once
 
 #define HID_MAX_STR 255
 
-class AuraStrixEvolveController
+class AsusAuraMouseGen1Controller
 {
 public:
-    AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid);
-    virtual ~AuraStrixEvolveController();
+    AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid);
+    virtual ~AsusAuraMouseGen1Controller();
 
     std::string GetDeviceLocation();
     std::string GetSerialString();
@@ -39,8 +40,9 @@ public:
         unsigned char   profile,
         unsigned char   value
         );
+    void SendDirectSpatha(std::vector<RGBColor> colors);
 
-    void SendSavePacket();
+    void ResetToSavedLighting();
 
     uint16_t                    device_pid;
 

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[5];
-    snprintf(version, 5, "%04X", (usb_buf_out[6] << 8) | usb_buf_out[7]);
+    char version[9];
+    snprintf(version, 9, "%X.%02X.%02X", usb_buf_out[6], usb_buf_out[7], usb_buf_out[8]);
     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]   = 0x55;
+    usb_save_buf[0x02]   = 0x03;
 
     hid_write(dev, usb_save_buf, 65);
 }

Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.cpp

@@ -1,146 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraStrixEvolveController.cpp        |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Mola19 11/30/2021                        |
-\*-----------------------------------------*/
-
-#include "AsusAuraStrixEvolveController.h"
-
-#include <cstring>
-#include <chrono>
-#include <thread>
-
-AuraStrixEvolveController::AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid)
-{
-    dev         = dev_handle;
-    location    = path;
-    device_pid  = pid;
-}
-
-AuraStrixEvolveController::~AuraStrixEvolveController()
-{
-    hid_close(dev);
-}
-
-std::string AuraStrixEvolveController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraStrixEvolveController::GetSerialString()
-{
-    wchar_t serial_string[HID_MAX_STR];
-    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
-
-    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 AuraStrixEvolveController::GetVersion()
-{
-    unsigned char usb_buf[9] = { 0x0c, 0xc4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-    hid_send_feature_report(dev, usb_buf, 9);
-
-    unsigned char usb_buf_out[9] = { 0x0c };
-    hid_get_feature_report(dev, usb_buf_out, 9);
-
-    return std::string("1." +  std::to_string(usb_buf_out[3]));
-}
-
-int AuraStrixEvolveController::GetActiveProfile()
-{
-    int profile;
-
-    do
-    {
-        unsigned char usb_buf[9] = { 0x0c, 0xdf, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-        hid_send_feature_report(dev, usb_buf, 9);
-
-        unsigned char usb_buf_out[9] = { 0x0c };
-        hid_get_feature_report(dev, usb_buf_out, 9);
-
-        profile = usb_buf_out[4] % 16;
-    } while (profile > 2);
-
-    return profile + 1;
-}
-
-void AuraStrixEvolveController::SendUpdate
-    (
-    unsigned char   key,
-    unsigned char   value
-    )
-{
-    unsigned char usb_buf[9];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, 9);
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x0c;
-    usb_buf[0x01]   = 0xc4;
-    usb_buf[0x02]   = 0x0f;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = key;
-    usb_buf[0x05]   = value;
-    hid_send_feature_report(dev, usb_buf, 9);
-}
-
-
-void AuraStrixEvolveController::UpdateProfile
-    (
-    unsigned char   key,
-    unsigned char   profile,
-    unsigned char   value
-    )
-{
-    unsigned char usb_buf[9];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, 9);
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x0c;
-    usb_buf[0x01]   = 0xde;
-    usb_buf[0x02]   = key;
-    usb_buf[0x03]   = profile;
-    usb_buf[0x04]   = value;
-    hid_send_feature_report(dev, usb_buf, 9);
-    std::this_thread::sleep_for(std::chrono::milliseconds(5));
-}
-
-void AuraStrixEvolveController::SendSavePacket()
-{
-    unsigned char usb_buf[9];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, 9);
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x0c;
-    usb_buf[0x01]   = 0xc4;
-
-    hid_send_feature_report(dev, usb_buf, 9);
-}

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

@@ -17,12 +17,14 @@
 #include <string.h>
 #include <cmath>
 
-AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short rev_version)
+AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version)
 {
     dev         = dev_handle;
     location    = path;
     device_pid  = pid;
-    version     = rev_version;
+    rev_version = version;
+
+    is_per_led_keyboard = (pid != AURA_TUF_K1_GAMING_PID && pid != AURA_TUF_K5_GAMING_PID);
 }
 
 AuraTUFKeyboardController::~AuraTUFKeyboardController()
@@ -35,6 +37,26 @@ 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];
@@ -45,8 +67,8 @@ std::string AuraTUFKeyboardController::GetSerialString()
         return("");
     }
 
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
+    std::wstring serial_wstring = serial_string;
+    std::string return_string = clean_serial(serial_wstring);
 
     return(return_string);
 }
@@ -70,13 +92,24 @@ std::string AuraTUFKeyboardController::GetVersion()
         hid_read(dev, usb_buf_out, 65);
 
         char version[9];
-        if(device_pid == AURA_TUF_K3_GAMING_PID)
+        
+        switch(device_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]);
+            case AURA_ROG_AZOTH_USB_PID:
+            case AURA_ROG_AZOTH_2_4_PID:
+            case AURA_TUF_K3_GAMING_PID:
+            case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
+            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
+            case AURA_ROG_STRIX_SCOPE_II_PID:
+            case AURA_ROG_STRIX_SCOPE_II_RX_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;
+            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
+                snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[13], usb_buf_out[12], usb_buf_out[11]);
+                break;
+            default:
+                snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
         }
 
         return std::string(version);
@@ -136,13 +169,7 @@ int AuraTUFKeyboardController::GetLayout()
     }
     else
     {
-        char layout[4];
-
-        sprintf(layout, "%X", version);
-
-        int layoutnum = std::stoi(std::string(layout, 1));
-
-        switch(layoutnum)
+        switch(rev_version >> 0b1100)
         {
             case 1:
                 return 117;
@@ -267,17 +294,188 @@ void AuraTUFKeyboardController::UpdateLeds
 
         for(int j = 0; j < leds; j++)
         {
-            usb_buf[j * 4 + 5] = colors[i * 15 + j].value;
+            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);
         }
+
         ClearResponses();
         hid_write(dev, usb_buf, 65);
         AwaitResponse(20);
     }
 }
 
+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::UpdateScopeIIRainbowRipple
+    (
+    unsigned char           mode,
+    std::vector<RGBColor>   colors,
+    unsigned char           direction,
+    unsigned char           color_mode,
+    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]   = mode;
+    usb_buf[0x04]   = 0x02;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = brightness;
+    usb_buf[0x07]   = color_mode;
+    usb_buf[0x08]   = direction;
+    usb_buf[0x09]   = 0x02;
+    usb_buf[0x0A]   = colors.size();
+
+    for(unsigned int i = 0; i < 2; i ++)
+    {
+        if (i >= colors.size()) continue;
+        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]);
+    }
+
+    ClearResponses();
+    hid_write(dev, usb_buf, 65);
+    AwaitResponse(20);
+
+    memset(usb_buf + 4, 0x00, sizeof(usb_buf) - 4);
+
+    usb_buf[0x04] = 0x01;
+
+    for(unsigned int i = 0; i < 4; i ++)
+    {
+        if (i + 2 >= colors.size()) continue;
+        usb_buf[5 + i * 4] = 100/(double)colors.size()*(i+1+2);
+        usb_buf[6 + i * 4] = RGBGetRValue(colors[i+2]);
+        usb_buf[7 + i * 4] = RGBGetGValue(colors[i+2]);
+        usb_buf[8 + i * 4] = RGBGetBValue(colors[i+2]);
+    }
+
+    ClearResponses();
+    hid_write(dev, usb_buf, 65);
+    AwaitResponse(20);
+
+    memset(usb_buf + 4, 0x00, sizeof(usb_buf) - 4);
+
+    usb_buf[0x04] = 0x00;
+
+    for(unsigned int i = 0; i < 1; i ++)
+    {
+        if (i + 6 >= colors.size()) continue;
+        usb_buf[5 + i * 4] = 100/(double)colors.size()*(i+1+6);
+        usb_buf[6 + i * 4] = RGBGetRValue(colors[i+6]);
+        usb_buf[7 + i * 4] = RGBGetGValue(colors[i+6]);
+        usb_buf[8 + i * 4] = RGBGetBValue(colors[i+6]);
+    }
+
+    ClearResponses();
+    hid_write(dev, usb_buf, 65);
+    AwaitResponse(20);
+}
+
+void AuraTUFKeyboardController::UpdateScopeIIQuicksand
+    (
+    std::vector<RGBColor>   colors,
+    unsigned char           direction,
+    unsigned char           color_mode,
+    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]   = 0x07;
+    usb_buf[0x04]   = 0x01;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = brightness;
+    usb_buf[0x07]   = color_mode;
+    usb_buf[0x08]   = direction;
+    usb_buf[0x09]   = 0x02;
+
+    for(unsigned int i = 0; i < 3; 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]);
+    }
+
+    ClearResponses();
+    hid_write(dev, usb_buf, 65);
+    AwaitResponse(20);
+
+    memset(usb_buf + 4, 0x00, sizeof(usb_buf) - 4);
+
+    usb_buf[0x04] = 0x00;
+
+    for(unsigned int i = 0; i < 3; i ++)
+    {
+        usb_buf[5 + i * 3] = RGBGetRValue(colors[i+3]);
+        usb_buf[6 + i * 3] = RGBGetGValue(colors[i+3]);
+        usb_buf[7 + i * 3] = RGBGetBValue(colors[i+3]);
+    }
+
+    ClearResponses();
+    hid_write(dev, usb_buf, 65);
+    AwaitResponse(20);
+}
+
 void AuraTUFKeyboardController::UpdateDevice
     (
     unsigned char           mode,
@@ -288,6 +486,29 @@ void AuraTUFKeyboardController::UpdateDevice
     unsigned char           brightness
     )
 {
+    if(device_pid == AURA_TUF_K1_GAMING_PID && mode == AURA_KEYBOARD_MODE_WAVE)
+    {
+        return UpdateK1Wave(colors, direction, speed, brightness);
+    }
+
+    if(device_pid == AURA_ROG_AZOTH_USB_PID
+    || device_pid == AURA_ROG_AZOTH_2_4_PID
+    || device_pid == AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID
+    || device_pid == AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID
+    || device_pid == AURA_ROG_STRIX_SCOPE_II_PID
+    || device_pid == AURA_ROG_STRIX_SCOPE_II_RX_PID
+    || device_pid == AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID)
+    {
+        if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
+        {
+            return UpdateScopeIIRainbowRipple(mode, colors, direction, color_mode, speed, brightness);
+        }
+        else if (mode == AURA_KEYBOARD_MODE_QUICKSAND)
+        {
+            return UpdateScopeIIQuicksand(colors, direction, color_mode, speed, brightness);
+        }
+    }
+
     unsigned char usb_buf[65];
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
@@ -303,41 +524,79 @@ void AuraTUFKeyboardController::UpdateDevice
         usb_buf[0x06]   = brightness;
         usb_buf[0x07]   = color_mode;
         usb_buf[0x08]   = direction;
-        usb_buf[0x09]   = 0x02;
 
-        if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
+        if(is_per_led_keyboard)
         {
-            usb_buf[0x0A]   = colors.size();
+            usb_buf[0x09]   = 0x02;
 
-            /*-----------------------------------------------------*\
-            | Loop over every color given                           |
-            \*-----------------------------------------------------*/
-            for(unsigned int i = 0; i < colors.size(); i ++)
+            if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
             {
-                if(colors[i])
+                usb_buf[0x0A]   = colors.size();
+
+                /*-----------------------------------------------------*\
+                | Loop over every color given                           |
+                \*-----------------------------------------------------*/
+                for(unsigned int i = 0; i < colors.size(); 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]);
+                    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
         {
-            /*-----------------------------------------------------*\
-            | Loop over Color1, Color2 and Background if there      |
-            \*-----------------------------------------------------*/
-            for(unsigned int i = 0; i != colors.size(); i++)
+            /*-----------------------------------------------------------------*\
+            | Only handles K5 Rainbow.                                          |
+            | K1 is filtered out earlier and is executed in `UpdateK1Wave()`    |
+            \*-----------------------------------------------------------------*/
+            if(mode == AURA_KEYBOARD_MODE_WAVE)
             {
-                if(colors[i])
+                usb_buf[0x09]   = 0x05;
+
+                for(unsigned int i = 0; i < 5; 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]);
+                    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]);
+                    }
                 }
             }
-
         }
     }
     else

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h

@@ -33,11 +33,27 @@ enum
 
 enum
 {
-    AURA_ROG_FALCHION_WIRED_PID     = 0x193C,
-    AURA_ROG_FALCHION_WIRELESS_PID  = 0x193E,
-    AURA_TUF_K7_GAMING_PID          = 0x18AA,
-    AURA_TUF_K3_GAMING_PID          = 0x194B,
-    AURA_ROG_CLAYMORE_PID           = 0x184D,
+    AURA_ROG_AZOTH_USB_PID                              = 0x1A83,
+    AURA_ROG_AZOTH_2_4_PID                              = 0x1A85,
+    AURA_ROG_CLAYMORE_PID                               = 0x184D,
+    AURA_ROG_FALCHION_WIRED_PID                         = 0x193C,
+    AURA_ROG_FALCHION_WIRELESS_PID                      = 0x193E,
+    AURA_ROG_STRIX_FLARE_PID                            = 0x1875,
+    AURA_ROG_STRIX_FLARE_PNK_LTD_PID                    = 0x18CF,
+    AURA_ROG_STRIX_FLARE_COD_BO4_PID                    = 0x18AF,
+    AURA_ROG_STRIX_FLARE_II_PID                         = 0x19FE,
+    AURA_ROG_STRIX_FLARE_II_ANIMATE_PID                 = 0x19FC,
+    AURA_ROG_STRIX_SCOPE_PID                            = 0x18F8,
+    AURA_ROG_STRIX_SCOPE_RX_PID                         = 0x1951,
+    AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID     = 0x19F6,
+    AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID     = 0x19F8,
+    AURA_ROG_STRIX_SCOPE_II_PID                         = 0x1AB3,
+    AURA_ROG_STRIX_SCOPE_II_RX_PID                      = 0x1AB5,
+    AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID         = 0x1AAE,
+    AURA_TUF_K1_GAMING_PID                              = 0x1945,
+    AURA_TUF_K3_GAMING_PID                              = 0x194B,
+    AURA_TUF_K5_GAMING_PID                              = 0x1899,
+    AURA_TUF_K7_GAMING_PID                              = 0x18AA,
 };
 
 struct led_color
@@ -49,7 +65,7 @@ struct led_color
 class AuraTUFKeyboardController
 {
 public:
-    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short rev_version);
+    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version);
     ~AuraTUFKeyboardController();
 
     std::string GetDeviceLocation();
@@ -73,11 +89,38 @@ public:
         std::vector<led_color>    colors
         );
 
+    void UpdateK1Wave
+        (
+        std::vector<RGBColor>   colors,
+        unsigned char           direction,
+        unsigned char           speed,
+        unsigned char           brightness
+        );
+
+    void UpdateScopeIIRainbowRipple
+        (
+        unsigned char           mode,
+        std::vector<RGBColor>   colors,
+        unsigned char           direction,
+        unsigned char           color_mode,
+        unsigned char           speed,
+        unsigned char           brightness
+        );
+
+    void UpdateScopeIIQuicksand
+        (
+        std::vector<RGBColor>   colors,
+        unsigned char           direction,
+        unsigned char           color_mode,
+        unsigned char           speed,
+        unsigned char           brightness
+        );
+
     void UpdateDevice
         (
         unsigned char           mode,
         std::vector<RGBColor>   colors,
-        unsigned char           dir,
+        unsigned char           direction,
         unsigned char           color_mode,
         unsigned char           speed,
         unsigned char           brightness
@@ -88,10 +131,11 @@ public:
     void ClearResponses();
 
     uint16_t                    device_pid;
+    bool                        is_per_led_keyboard;
 
 private:
     hid_device*                 dev;
     std::string                 location;
-    unsigned short              version;
+    unsigned short              rev_version;
 };
 

Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp

@@ -11,7 +11,6 @@
 #include "LogManager.h"
 
 #include <cstring>
-#include <stdexcept>
 
 AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path)
 {
@@ -144,36 +143,56 @@ void AuraUSBController::GetFirmwareVersion()
 void AuraUSBController::SendDirect
     (
     unsigned char   device,
-    unsigned char   start_led,
     unsigned char   led_count,
-    unsigned char*  led_data,
-    bool apply /* = false */
+    RGBColor*  colors
     )
 {
     unsigned char usb_buf[65];
+    unsigned char offset         =      0x00;
+    unsigned char sent_led_count =      LEDS_PER_PACKET;
+    bool apply                   =      false;
+    while(!apply)
+    {
+        if(offset + sent_led_count > led_count)
+        {
+            sent_led_count = led_count - offset;
+        }
 
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
 
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
-    usb_buf[0x02]   = apply ? 0x80 : 0x00;
-    usb_buf[0x02]  |= device;
-    usb_buf[0x03]   = start_led;
-    usb_buf[0x04]   = led_count;
+        if(offset + sent_led_count == led_count)
+        {
+            apply = true;
+        }
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
 
-    /*-----------------------------------------------------*\
-    | Copy in color data bytes                              |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x05], led_data, led_count * 3);
+        /*-----------------------------------------------------*\
+        | Set up message packet                                 |
+        \*-----------------------------------------------------*/
+        usb_buf[0x00]   = 0xEC;
+        usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
+        usb_buf[0x02]   = (apply ? 0x80 : 0x00) | device;
+        usb_buf[0x03]   = offset;
+        usb_buf[0x04]   = sent_led_count;
 
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+        /*-----------------------------------------------------*\
+        | Copy in color data bytes                              |
+        \*-----------------------------------------------------*/
+        for(unsigned char led_idx = 0; led_idx < sent_led_count; led_idx++)
+        {
+
+            usb_buf[0x05 + (led_idx * 3)] = RGBGetRValue(colors[offset + led_idx]);
+            usb_buf[0x06 + (led_idx * 3)] = RGBGetGValue(colors[offset + led_idx]);
+            usb_buf[0x07 + (led_idx * 3)] = RGBGetBValue(colors[offset + led_idx]);
+        }
+
+        /*-----------------------------------------------------*\
+        | Send packet                                           |
+        \*-----------------------------------------------------*/
+        hid_write(dev, usb_buf, 65);
+
+        offset += sent_led_count;
+    }
 }

Controllers/AsusAuraUSBController/AsusAuraUSBController.h

@@ -49,6 +49,8 @@ enum class AuraDeviceType
     ADDRESSABLE,
 };
 
+#define LEDS_PER_PACKET  0x14;
+
 struct AuraDeviceInfo
 {
     unsigned char effect_channel;
@@ -97,10 +99,8 @@ protected:
     void SendDirect
         (
         unsigned char   device,
-        unsigned char   start_led,
         unsigned char   led_count,
-        unsigned char*  led_data,
-        bool apply = false
+        RGBColor *      colors
         );
 private:
     char                        device_name[16];

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -5,8 +5,9 @@
 #include "AsusAuraTUFKeyboardController.h"
 #include "AsusAuraMainboardController.h"
 #include "AsusAuraMouseController.h"
+#include "AsusROGAllyController.h"
+#include "AsusAuraMouseGen1Controller.h"
 #include "AsusAuraMousematController.h"
-#include "AsusAuraStrixEvolveController.h"
 #include "AsusAuraMonitorController.h"
 #include "AsusAuraRyuoAIOController.h"
 #include "RGBController.h"
@@ -14,90 +15,105 @@
 #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_AsusROGSpatha.h"
+#include "RGBController_AsusROGStrixEvolve.h"
 #include "RGBController_AsusAuraMonitor.h"
 #include "RGBController_AsusAuraRyuoAIO.h"
 #include <stdexcept>
 #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_SCOPE_PID                0x18F8
-#define AURA_ROG_STRIX_SCOPE_RX_PID             0x1951
-#define AURA_ROG_STRIX_SCOPE_TKL_PID            0x190C
-#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID    0x1954
-#define AURA_ROG_CLAYMORE_PID                   0x184D
-#define AURA_TUF_K7_GAMING_PID                  0x18AA
-#define AURA_TUF_K3_GAMING_PID                  0x194B
+#define AURA_ROG_AZOTH_USB_PID                              0x1A83
+#define AURA_ROG_AZOTH_2_4_PID                              0x1A85
+#define AURA_ROG_CLAYMORE_PID                               0x184D
+#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_FLARE_II_PID                         0x19FE
+#define AURA_ROG_STRIX_SCOPE_PID                            0x18F8
+#define AURA_ROG_STRIX_SCOPE_TKL_PID                        0x190C
+#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID                0x1954
+#define AURA_ROG_STRIX_SCOPE_RX_PID                         0x1951
+#define AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID              0x1A05
+#define AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID     0x19F6
+#define AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID     0x19F8
+#define AURA_ROG_STRIX_SCOPE_II_PID                         0x1AB3
+#define AURA_ROG_STRIX_SCOPE_II_RX_PID                      0x1AB5
+#define AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID         0x1AAE
+#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
 
 /*-----------------------------------------------------------------*\
 |  MICE - defined in AsusAuraMouseDevices.h                         |
 \*-----------------------------------------------------------------*/
 
-#define AURA_ROG_STRIX_EVOLVE_PID               0x185B
+#define AURA_ROG_STRIX_EVOLVE_PID                     0x185B
+#define AURA_ROG_SPATHA_WIRED_PID                     0x181C
+#define AURA_ROG_SPATHA_WIRELESS_PID                  0x1824
 
 /*-----------------------------------------------------------------*\
 | 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_XG27W_PID                0x1933
-#define AURA_ROG_PG32UQ_PID                     0x19B9
+#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_STRIX_XG32VC_PID                     0x1968
+#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 AURA_TERMINAL_PID                             0x1889
+#define ROG_STRIX_LC120_PID                           0x879E
+#define AURA_RYUO_AIO_PID                             0x1887
+#define ASUS_ROG_ALLY_PID                             0x1ABE
 
 AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
 {
     switch(pid)
     {
-        case AURA_ROG_STRIX_FLARE_PID:
-        case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
-        case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
-            return FLARE_LAYOUT;
-
         case AURA_ROG_STRIX_SCOPE_PID:
             return SCOPE_LAYOUT;
 
@@ -105,6 +121,7 @@ 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;
 
@@ -150,7 +167,7 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*n
         {
             DMIInfo dmi;
             AuraMainboardController* controller             = new AuraMainboardController(dev, info->path);
-            RGBController_AuraUSB*   rgb_controller         = new RGBController_AuraUSB(controller);
+            RGBController_AuraMainboard*   rgb_controller   = new RGBController_AuraMainboard(controller);
             rgb_controller->name                            = "ASUS " + dmi.getMainboard();
             ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
@@ -182,7 +199,8 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, info->product_id);
+        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);
         RGBController_AuraMouse* rgb_controller             = new RGBController_AuraMouse(controller);
         rgb_controller->name                                = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -234,8 +252,21 @@ void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name
 
     if(dev)
     {
-        AuraStrixEvolveController*     controller           = new AuraStrixEvolveController(dev, info->path, info->product_id);
-        RGBController_AuraStrixEvolve* rgb_controller       = new RGBController_AuraStrixEvolve(controller);
+        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id);
+        RGBController_AsusROGStrixEvolve* rgb_controller    = new RGBController_AsusROGStrixEvolve(controller);
+        rgb_controller->name                                = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectAsusAuraUSBSpatha(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id);
+        RGBController_AsusROGSpatha* rgb_controller         = new RGBController_AsusROGSpatha(controller);
         rgb_controller->name                                = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
@@ -280,6 +311,19 @@ 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                                                     |
 \*-----------------------------------------------------------------*/
@@ -294,56 +338,78 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAs
 /*-----------------------------------------------------------------*\
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
-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 Flare CoD Black Ops 4 Edition",DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_COD_BO4_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 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 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 TUF Gaming K7",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                       1,  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 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 Azoth USB",                              DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_AZOTH_USB_PID,                           1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Azoth 2.4GHz",                           DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_AZOTH_2_4_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 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",                            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 Strix Flare II Animate",                 DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_ANIMATE_PID,              1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare II",                         DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_PID,                      1,  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 ROG Strix Scope NX Wireless Deluxe USB",     DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID,  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope NX Wireless Deluxe 2.4GHz",  DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID,  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II",                         DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_PID,                      1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II RX",                      DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_RX_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 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 TUF Gaming K7",                              DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                           1,  0xFF00);
 
 /*-----------------------------------------------------------------*\
 |  MICE                                                             |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,                 0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                         DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                      2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,               2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID,       2,  0xFF01);
-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 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,                    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);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Moonlight White",    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WHITE_PID,           0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless USB",       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID,    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless 2.4 Ghz",   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID,    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris",                              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS,                               0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless USB",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_USB_PID,              0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless 2.4Ghz",              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_2_4_PID,              0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless Bluetooth",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_BT_PID,               0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3",                          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M3_PID,                              1,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M5_PID,                              2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",                            DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,                     0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                                 DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                          2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",                          DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,                   2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",                  DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID,           2,  0xFF01);
+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 Gladius III Wireless AimPoint USB",          DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID,   0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless AimPoint 2.4Ghz",       DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_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 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);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Moonlight White",            DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WHITE_PID,               0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless USB",               DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID,        0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless 2.4 Ghz",           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID,        0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact III",                           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_III_PID,                    0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris",                                      DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS,                                   0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless USB",                         DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_USB_PID,                  0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless 2.4Ghz",                      DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_2_4_PID,                  0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless Bluetooth",                   DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_BT_PID,                   0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless AimPoint USB",                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID,         0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless AimPoint 2.4Ghz",             DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID,         0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3",                                  DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_TUF_M3_PID,                                  1,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                                  DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_TUF_M5_PID,                                  2,  0xFF01);
 
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Evolve",                       DetectAsusAuraUSBStrixEvolve,   AURA_USB_VID, AURA_ROG_STRIX_EVOLVE_PID,                    1,  0x0008);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Spatha Wired",                       DetectAsusAuraUSBSpatha,        AURA_USB_VID, AURA_ROG_SPATHA_WIRED_PID,                    1,  0x0008);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Spatha Wireless",                    DetectAsusAuraUSBSpatha,        AURA_USB_VID, AURA_ROG_SPATHA_WIRELESS_PID,                 1,  0x0008);
 
 /*-----------------------------------------------------------------*\
 | MOUSEMATS                                                         |
@@ -356,7 +422,9 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi",                         DetectAs
 \*-----------------------------------------------------------------*/
 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 Strix XG32VC",                       DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG32VC_PID,                    0xFFA0, 1);
 REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ",                             DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_PG32UQ_PID,                          0xFFA0, 1);
 
 /*-----------------------------------------------------------------*\
@@ -368,3 +436,4 @@ 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

@@ -0,0 +1,178 @@
+/*-----------------------------------------*\
+|  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;
+
+    SendInitialization();
+}
+
+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::SendInitialization()
+{
+    unsigned char usb_buf[64];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x5D;
+    usb_buf[0x01]   = 0xB9;
+    
+    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x5D;
+    usb_buf[0x01]   = 0x41;
+    usb_buf[0x02]   = 0x53;
+    usb_buf[0x03]   = 0x55;
+    usb_buf[0x04]   = 0x53;
+    usb_buf[0x05]   = 0x20;
+    usb_buf[0x06]   = 0x54;
+    usb_buf[0x07]   = 0x65;
+    usb_buf[0x08]   = 0x63;
+    usb_buf[0x09]   = 0x68;
+    usb_buf[0x0A]   = 0x2E;
+    usb_buf[0x0B]   = 0x49;
+    usb_buf[0x0C]   = 0x6E;
+    usb_buf[0x0D]   = 0x63;
+    usb_buf[0x0E]   = 0x2E;
+    
+    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
+}
+
+void ROGAllyController::UpdateBrightness
+    (
+    unsigned char           brightness
+    )
+{
+    unsigned char usb_buf[64];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x5A;
+    usb_buf[0x01]   = 0xBA;
+    usb_buf[0x02]   = 0xC5;
+    usb_buf[0x03]   = 0xC4;
+    usb_buf[0x04]   = brightness;
+
+    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
+}
+
+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           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

@@ -0,0 +1,73 @@
+/*-----------------------------------------*\
+|  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 SendInitialization();
+    
+    void UpdateBrightness
+        (
+            unsigned char           brightness
+        );
+
+    void UpdateLeds
+        (
+            std::vector<RGBColor>    colors
+            );
+
+    void UpdateDevice
+        (
+            unsigned char           mode,
+            std::vector<RGBColor>   colors,
+            unsigned char           speed,
+            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<led_type> default_led_names =
+static const std::vector<aura_keyboard_led> default_led_names =
 {
     /* Key Label                Index  */
     { KEY_EN_ESCAPE,            0x00    },
@@ -153,7 +153,7 @@ static const std::vector<led_type> default_led_names =
     { KEY_EN_NUMPAD_ENTER,      0xB4    },
 };
 
-static const std::vector<led_type> default_tkl_led_names =
+static const std::vector<aura_keyboard_led> default_tkl_led_names =
 {
     /* Key Label                Index  */
     { KEY_EN_ESCAPE,            0x00    },
@@ -270,7 +270,7 @@ static const std::vector<led_type> default_tkl_led_names =
     { "Underglow 26",           0xCE    },
 };
 
-static const std::vector<led_type> default_65pct_led_names =
+static const std::vector<aura_keyboard_led> 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<led_type> led_names;
+    std::vector<aura_keyboard_led> led_names;
 
     switch(layout)
     {

Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.h

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

Controllers/AsusAuraUSBController/RGBController_AsusAuraMainboard.cpp

@@ -0,0 +1,78 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,25 @@
+/*-----------------------------------------*\
+|  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,11 +9,13 @@
 
 #include "RGBController_AsusAuraMouse.h"
 
-static std::string aura_mouse_zone_names[3]
+static std::string aura_mouse_zone_names[5]
 {
     "Logo",
     "Scroll Wheel",
-    "Underglow"
+    "Underglow",
+    "All",
+    "Dock"
 };
 
 /**------------------------------------------------------------------*\
@@ -43,6 +45,16 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
 
     std::vector<uint8_t> mm = aura_mouse_devices[pid].mouse_modes;
 
+    if(aura_mouse_devices[pid].direct)
+    {
+        mode Direct;
+        Direct.name                 = "Direct";
+        Direct.value                = 254;
+        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+        Direct.color_mode           = MODE_COLORS_PER_LED;
+        modes.push_back(Direct);
+    }
+
     int mode_value          = 0;
 
     for(std::vector<uint8_t>::iterator it = mm.begin(); it != mm.end(); it++)
@@ -50,16 +62,24 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
         switch(*it)
         {
             case AURA_MOUSE_MODE_STATIC:
+                /*-----------------------------------------------------------------*\
+                | If there is no direct mode, this mode can be used as direct       |
+                | (Asus does it the same way).                                      |
+                | The acutal direct mode is only found on new devices and on        |
+                | these devices static can't be used as direct anymore as it is     |
+                | too slow. The Spatha X's dock can't be controlled, because        |
+                | static is too slow and it can't be adressed in direct             |
+                \*-----------------------------------------------------------------*/
                 {
-                    mode Direct;
-                    Direct.name                 = "Direct";
-                    Direct.value                = mode_value;
-                    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    Direct.brightness_min       = aura_mouse_devices[pid].brightness_min;
-                    Direct.brightness_max       = aura_mouse_devices[pid].brightness_max;
-                    Direct.brightness           = aura_mouse_devices[pid].brightness_max;
-                    Direct.color_mode           = MODE_COLORS_PER_LED;
-                    modes.push_back(Direct);
+                    mode Static;
+                    Static.name                 = (aura_mouse_devices[pid].direct || pid == AURA_ROG_SPATHA_X_DOCK_FAKE_PID)? "Static" : "Direct";
+                    Static.value                = mode_value;
+                    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    Static.brightness_min       = aura_mouse_devices[pid].brightness_min;
+                    Static.brightness_max       = aura_mouse_devices[pid].brightness_max;
+                    Static.brightness           = aura_mouse_devices[pid].brightness_max;
+                    Static.color_mode           = MODE_COLORS_PER_LED;
+                    modes.push_back(Static);
                 }
                 break;
 
@@ -199,19 +219,32 @@ void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AuraMouse::DeviceUpdateLEDs()
 {
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
     {
-        UpdateSingleLED(zone_index);
+        controller->SendDirect(colors);
+    }
+    else
+    {
+        for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+        {
+            UpdateSingleLED(zone_index);
+        }
     }
 }
 
-void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
+void RGBController_AuraMouse::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
 void RGBController_AuraMouse::UpdateSingleLED(int led)
 {
+    if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
+    {
+        DeviceUpdateLEDs();
+        return;
+    }
+
     uint8_t red = RGBGetRValue(colors[led]);
     uint8_t grn = RGBGetGValue(colors[led]);
     uint8_t blu = RGBGetBValue(colors[led]);
@@ -221,6 +254,11 @@ void RGBController_AuraMouse::UpdateSingleLED(int led)
 
 void RGBController_AuraMouse::DeviceUpdateMode()
 {
+    if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
+    {
+        return;
+    }
+
     if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
     {
         DeviceUpdateLEDs();
@@ -238,7 +276,22 @@ void RGBController_AuraMouse::DeviceUpdateMode()
             blu = RGBGetBValue(modes[active_mode].colors[0]);
         }
 
-        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);
+
+        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);
+        }
     }
 }
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.cpp

@@ -17,7 +17,7 @@
     @save :white_check_mark:
     @direct :white_check_mark:
     @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBMousemats
+    @detectors DetectAsusAuraUSBRyuoAIO
     @category Cooler
     @comment
 \*-------------------------------------------------------------------*/

Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h

@@ -1,40 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraStrixEvolve.h      |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 11/30/2021                        |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraStrixEvolveController.h"
-
-enum
-{
-    AURA_STRIX_EVOLVE_BRIGHTNESS_MIN     = 0,
-    AURA_STRIX_EVOLVE_BRIGHTNESS_MAX     = 255,
-    AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT = 255
-};
-
-class RGBController_AuraStrixEvolve : public RGBController
-{
-public:
-    RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr);
-    ~RGBController_AuraStrixEvolve();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-    void        DeviceSaveMode();
-
-private:
-    AuraStrixEvolveController*  controller;
-};

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -28,8 +28,6 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
 
     pid = controller->device_pid;
 
-    const unsigned char AURA_KEYBOARD_SPEED_MIN = (pid == AURA_ROG_FALCHION_WIRED_PID || pid == AURA_ROG_FALCHION_WIRELESS_PID) ? 255 : 15;
-
     if(pid != AURA_ROG_CLAYMORE_PID)
     {
         name        = "ASUS Aura Keyboard";
@@ -40,6 +38,50 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
         location    = controller->GetDeviceLocation();
         serial      = controller->GetSerialString();
 
+        unsigned char AURA_KEYBOARD_SPEED_MIN     = 0;
+        unsigned char AURA_KEYBOARD_SPEED_MAX     = 0;
+        unsigned char AURA_KEYBOARD_SPEED_DEFAULT = 0;
+
+        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_AZOTH_USB_PID:
+            case AURA_ROG_AZOTH_2_4_PID:
+            case AURA_ROG_FALCHION_WIRED_PID:
+            case AURA_ROG_FALCHION_WIRELESS_PID:
+            case AURA_ROG_STRIX_FLARE_II_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_NX_WIRELESS_DELUXE_2_4_PID:
+            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
+            case AURA_ROG_STRIX_SCOPE_II_PID:
+            case AURA_ROG_STRIX_SCOPE_II_RX_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 Direct;
         Direct.name                 = "Direct";
         Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
@@ -63,7 +105,9 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
         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.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;
+
         Breathing.speed_min         = AURA_KEYBOARD_SPEED_MIN;
         Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
         Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
@@ -92,7 +136,9 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
         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.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;
@@ -101,107 +147,120 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
         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);
+
+        if(!controller->is_per_led_keyboard)
+        {
+            Wave.colors_min             = 5;
+            Wave.colors_max             = 5;
+        }
+        else
+        {
+            Wave.colors_min             = 1;
+            Wave.colors_max             = 7;
+        }
+
+        Wave.colors.resize(Wave.colors_max);
         modes.push_back(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_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);
+        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 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 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 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 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);
+            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
     {
@@ -343,15 +402,42 @@ RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
 
 void RGBController_AuraTUFKeyboard::SetupZones()
 {
-    unsigned char layout = controller->GetLayout();
-
     std::map<int,layout_info> * keyboard_ptr;
 
     switch(pid)
     {
+        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:
+        case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
+        case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
+            keyboard_ptr = &AsusROGStrixScopeLayouts;
+            break;
+        case AURA_ROG_STRIX_SCOPE_II_PID:
+        case AURA_ROG_STRIX_SCOPE_II_RX_PID:
+            keyboard_ptr = &AsusROGStrixScopeIILayouts;
+            break;
+        case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
+            keyboard_ptr = &AsusROGStrixScopeII96WirelessLayouts;
+            break;
+        case AURA_ROG_STRIX_FLARE_II_PID:
+            keyboard_ptr = &AsusROGStrixFlareIILayouts;
+			break;
+        case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
+            keyboard_ptr = &AsusROGStrixFlareIIAnimateLayouts;
+            break;
+        case AURA_ROG_AZOTH_USB_PID:
+        case AURA_ROG_AZOTH_2_4_PID:
+            keyboard_ptr = &AsusROGAzothLayouts;
+            break;
         case AURA_ROG_FALCHION_WIRED_PID:
         case AURA_ROG_FALCHION_WIRELESS_PID:
             keyboard_ptr = &AsusFalchionLayouts;
@@ -374,12 +460,18 @@ void RGBController_AuraTUFKeyboard::SetupZones()
                     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())
     {
         /*---------------------------------------------------------*\
@@ -429,7 +521,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 {
     std::vector<led_color> led_color_list = {};
 
-    for(int i = 0; i < colors.size(); i++)
+    for(size_t i = 0; i < colors.size(); i++)
     {
         led_color_list.push_back({ leds[i].value, colors[i] });
     }
@@ -444,6 +536,11 @@ void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
 
 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]);
@@ -485,6 +582,12 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
             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)
@@ -499,7 +602,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
             color_mode = 1;
         }
 
-        if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE)
+        if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE || modes[active_mode].value == AURA_KEYBOARD_MODE_QUICKSAND)
         {
             /*----------------------------------------------------------*\
             | converting openrgb direction value to keyboard directions  |
@@ -524,6 +627,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
         }
     }
 
+
     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)

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h

@@ -13,8 +13,6 @@
 
 enum
 {
-    AURA_KEYBOARD_SPEED_MAX          = 0,
-    AURA_KEYBOARD_SPEED_DEFAULT      = 8,
     AURA_KEYBOARD_BRIGHTNESS_MIN     = 0,
     AURA_KEYBOARD_BRIGHTNESS_MAX     = 4,
     AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4,
@@ -22,17 +20,16 @@ enum
 
 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_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
 };
 
 class RGBController_AuraTUFKeyboard : public RGBController

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

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

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.h

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

Controllers/AsusAuraUSBController/RGBController_AsusROGAlly.cpp

@@ -0,0 +1,216 @@
+/*-----------------------------------------*\
+|  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 | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    Direct.brightness_min       = 0;
+    Direct.brightness_max       = 3;
+    Direct.brightness           = 3;
+    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 | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(1);
+    Static.brightness_min       = 0;
+    Static.brightness_max       = 3;
+    Static.brightness           = 3;
+    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 | MODE_FLAG_HAS_BRIGHTNESS;
+    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);
+    Breathing.brightness_min    = 0;
+    Breathing.brightness_max    = 3;
+    Breathing.brightness        = 3;
+    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 | MODE_FLAG_HAS_BRIGHTNESS;
+    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;
+    ColorCycle.brightness_min   = 0;
+    ColorCycle.brightness_max   = 3;
+    ColorCycle.brightness       = 3;
+    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 | MODE_FLAG_HAS_BRIGHTNESS;
+    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;
+    Rainbow.brightness_min      = 0;
+    Rainbow.brightness_max      = 3;
+    Rainbow.brightness          = 3;
+    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 | MODE_FLAG_HAS_BRIGHTNESS;
+    Strobing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Strobing.colors_min         = 1;
+    Strobing.colors_max         = 1;
+    Strobing.brightness_min     = 0;
+    Strobing.brightness_max     = 3;
+    Strobing.brightness         = 3;
+    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()
+{
+    controller->UpdateBrightness(modes[active_mode].brightness);
+
+    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, rog_ally_direction);
+    }
+}
+
+void RGBController_AsusROGAlly::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    controller->SaveMode();
+}

Controllers/AsusAuraUSBController/RGBController_AsusROGAlly.h

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  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/RGBController_AsusROGSpatha.cpp

@@ -0,0 +1,272 @@
+/*-----------------------------------------*\
+|  RGBController_AsusROGSpatha.cpp          |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 11/05/2023                        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusROGSpatha.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus Aura Spatha
+    @category Mouse
+    @type USB
+    @save :white_check_mark:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAsusAuraUSBSpatha
+    @comment This device allows indiviual modes for each zone,
+        which currently can't be implemented in OpenRGB.
+        Also there seem to be a firmware bug which causes static
+        to use a random colorand random to use a static color
+        that was previously set. This can be worked around by saving
+\*-------------------------------------------------------------------*/
+
+RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Controller* controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = "ASUS ROG Spatha";
+    vendor                      = "ASUS";
+    type                        = DEVICE_TYPE_MOUSE;
+    description                 = "ASUS Aura Mouse Device";
+    version                     = controller->GetVersion();
+    location                    = controller->GetDeviceLocation();
+    serial                      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = ASUS_ROG_SPATHA_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                = ASUS_ROG_SPATHA_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.brightness_min       = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
+    Static.brightness_max       = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
+    Static.brightness           = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
+    Static.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = ASUS_ROG_SPATHA_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.brightness_min    = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
+    Breathing.brightness        = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
+    Breathing.colors_min        = 2;
+    Breathing.colors_max        = 2;
+    Breathing.colors.resize(2);
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Breathing);
+
+    mode ColorCycle;
+    ColorCycle.name             = "Spectrum Cycle";
+    ColorCycle.value            = ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE;
+    ColorCycle.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    ColorCycle.brightness_min   = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
+    ColorCycle.brightness_max   = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
+    ColorCycle.brightness       = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
+    ColorCycle.colors_min       = 12;
+    ColorCycle.colors_max       = 12;
+    ColorCycle.colors.resize(12);
+    ColorCycle.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(ColorCycle);
+
+    mode Random;
+    Random.name                 = "Random";
+    Random.value                = ASUS_ROG_SPATHA_MODE_RANDOM;
+    Random.flags                = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Random.brightness_min       = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
+    Random.brightness_max       = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
+    Random.brightness           = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
+    Random.color_mode           = MODE_COLORS_NONE;
+    modes.push_back(Random);
+
+    mode Reactive;
+    Reactive.name               = "Reactive";
+    Reactive.value              = ASUS_ROG_SPATHA_MODE_REACTIVE;
+    Reactive.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Reactive.brightness_min     = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
+    Reactive.brightness_max     = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
+    Reactive.brightness         = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
+    Reactive.color_mode         = MODE_COLORS_PER_LED;
+    modes.push_back(Reactive);
+
+    mode Battery;
+    Battery.name               = "Battery";
+    Battery.value              = ASUS_ROG_SPATHA_MODE_BATTERY;
+    Battery.flags              = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Battery.brightness_min     = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
+    Battery.brightness_max     = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
+    Battery.brightness         = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
+    Battery.color_mode         = MODE_COLORS_NONE;
+    modes.push_back(Battery);
+
+    SetupZones();
+}
+
+RGBController_AsusROGSpatha::~RGBController_AsusROGSpatha()
+{
+    delete controller;
+}
+
+void RGBController_AsusROGSpatha::SetupZones()
+{
+
+    std::string zones_names[3] = {"Side", "Scroll Wheel", "Logo"};
+
+    for(unsigned char i = 0; i < 3; i++)
+    {
+        zone spatha_zone;
+
+        spatha_zone.name         = zones_names[i];
+        spatha_zone.type         = ZONE_TYPE_SINGLE;
+        spatha_zone.leds_min     = 1;
+        spatha_zone.leds_max     = 1;
+        spatha_zone.leds_count   = 1;
+        spatha_zone.matrix_map   = NULL;
+
+        zones.push_back(spatha_zone);
+
+        led spatha_led;
+
+        spatha_led.name          = zones_names[i];
+        spatha_led.value         = 1;
+
+        leds.push_back(spatha_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AsusROGSpatha::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_AsusROGSpatha::DeviceUpdateLEDs()
+{
+    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
+    {
+        controller->SendDirectSpatha(colors);
+    }
+    else
+    {
+        UpdateSingleLED(0);
+        UpdateSingleLED(1);
+        UpdateSingleLED(2);
+    }
+}
+
+void RGBController_AsusROGSpatha::UpdateZoneLEDs(int zone)
+{
+    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
+    {
+        controller->SendDirectSpatha(colors);
+    }
+    else
+    {
+        UpdateSingleLED(zone);
+    }
+}
+
+void RGBController_AsusROGSpatha::UpdateSingleLED(int led)
+{
+    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
+    {
+        controller->SendDirectSpatha(colors);
+    }
+    else
+    {
+        controller->SendUpdate(0x13 + led * 38, RGBGetRValue(colors[led]));
+        controller->SendUpdate(0x14 + led * 38, RGBGetGValue(colors[led]));
+        controller->SendUpdate(0x15 + led * 38, RGBGetBValue(colors[led]));
+    }
+}
+
+void RGBController_AsusROGSpatha::DeviceUpdateMode()
+{
+    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
+    {
+        return;
+    }
+    
+    /*-----------------------------------------------------*\
+    | Needed to overwrite direct                            |
+    \*-----------------------------------------------------*/
+    controller->ResetToSavedLighting();
+
+    /*-----------------------------------------------------*\
+    | Send data to all 3 zones                              |
+    \*-----------------------------------------------------*/
+    for(int i = 0; i < 3; i++)
+    {
+        controller->SendUpdate(0x11 + i * 38, modes[active_mode].value);
+
+        /*------------------------------------------------------------------*\
+        | This mouse has independent brightness for wired and wireless.      |
+        | Each is 4-bit in the same byte (wireless is the first/bigger one). |
+        | OpenRGB misses that feature, hence both are the same               |
+        \*------------------------------------------------------------------*/
+        controller->SendUpdate(0x12 + i * 38, (modes[active_mode].brightness << 4) + modes[active_mode].brightness);
+        
+        if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_BREATHING)
+        {
+            for(int j = 0; j < modes[active_mode].colors.size(); j++)
+            {
+                controller->SendUpdate(0x13 + j * 3 + i * 38, RGBGetRValue(modes[active_mode].colors[j]));
+                controller->SendUpdate(0x14 + j * 3 + i * 38, RGBGetGValue(modes[active_mode].colors[j]));
+                controller->SendUpdate(0x15 + j * 3 + i * 38, RGBGetBValue(modes[active_mode].colors[j]));
+            }
+        }
+    }
+}
+
+void RGBController_AsusROGSpatha::DeviceSaveMode()
+{
+    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
+    {
+        return;
+    }
+
+    unsigned int profile = controller->GetActiveProfile();
+    
+    /*-----------------------------------------------------*\
+    | Send data to all 3 zones                              |
+    \*-----------------------------------------------------*/
+    for(int i = 0; i < 3; i++)
+    {
+        controller->UpdateProfile(0x11 + i * 38, profile, modes[active_mode].value);
+        /*------------------------------------------------------------------*\
+        | This mouse has independent brightness for wired and wireless.      |
+        | Each is 4-bit in the same byte (wireless is the first/bigger one). |
+        | OpenRGB misses that feature, hence both are the same               |
+        \*------------------------------------------------------------------*/
+        controller->UpdateProfile(0x12 + i * 38, profile, (modes[active_mode].brightness << 4) + modes[active_mode].brightness);
+        
+        if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_BREATHING)
+        {
+            for(int j = 0; j < modes[active_mode].colors.size(); j++)
+            {
+                controller->UpdateProfile(0x13 + j * 3 + i * 38, profile, RGBGetRValue(modes[active_mode].colors[j]));
+                controller->UpdateProfile(0x14 + j * 3 + i * 38, profile, RGBGetGValue(modes[active_mode].colors[j]));
+                controller->UpdateProfile(0x15 + j * 3 + i * 38, profile, RGBGetBValue(modes[active_mode].colors[j]));
+            }
+        }
+        else if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_STATIC || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_REACTIVE)
+        {
+            controller->UpdateProfile(0x13 + i * 38, profile, RGBGetRValue(colors[i]));
+            controller->UpdateProfile(0x14 + i * 38, profile, RGBGetGValue(colors[i]));
+            controller->UpdateProfile(0x15 + i * 38, profile, RGBGetBValue(colors[i]));
+        }
+    }
+
+    controller->ResetToSavedLighting();
+}

Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.h

@@ -0,0 +1,51 @@
+/*-----------------------------------------*\
+|  RGBController_AsusROGSpatha.h           |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 11/05/2023                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraMouseGen1Controller.h"
+
+enum
+{
+    ASUS_ROG_SPATHA_BRIGHTNESS_MIN          = 0,
+    ASUS_ROG_SPATHA_BRIGHTNESS_MAX          = 15,
+    ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT      = 15
+};
+
+enum
+{
+    ASUS_ROG_SPATHA_MODE_DIRECT             = 0xFF,
+    ASUS_ROG_SPATHA_MODE_STATIC             = 0x01,
+    ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE     = 0x05,
+    ASUS_ROG_SPATHA_MODE_RANDOM             = 0x06,
+    ASUS_ROG_SPATHA_MODE_BREATHING          = 0x0A,
+    ASUS_ROG_SPATHA_MODE_BATTERY            = 0x0B,
+    ASUS_ROG_SPATHA_MODE_REACTIVE           = 0x0C,
+};
+
+class RGBController_AsusROGSpatha : public RGBController
+{
+public:
+    RGBController_AsusROGSpatha(AsusAuraMouseGen1Controller* controller_ptr);
+    ~RGBController_AsusROGSpatha();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    AsusAuraMouseGen1Controller*  controller;
+};

Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AsusAuraStrixEvolve.cpp    |
+|  RGBController_AsusROGStrixEvolve.cpp     |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
 |  USB controller driver                    |
@@ -7,7 +7,7 @@
 |  Mola19 11/30/2021                        |
 \*-----------------------------------------*/
 
-#include "RGBController_AsusAuraStrixEvolve.h"
+#include "RGBController_AsusROGStrixEvolve.h"
 
 /**------------------------------------------------------------------*\
     @name Asus Aura Strix Evolve
@@ -20,7 +20,7 @@
     @comment
 \*-------------------------------------------------------------------*/
 
-RGBController_AuraStrixEvolve::RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr)
+RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouseGen1Controller* controller_ptr)
 {
     controller                  = controller_ptr;
 
@@ -34,53 +34,53 @@ RGBController_AuraStrixEvolve::RGBController_AuraStrixEvolve(AuraStrixEvolveCont
 
     mode Direct;
     Direct.name                 = "Direct";
-    Direct.value                = 1;
+    Direct.value                = ASUS_ROG_STRIX_EVOLVE_MODE_DIRECT;
     Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.brightness_min       = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    Direct.brightness_max       = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    Direct.brightness           = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Direct.brightness_min       = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Direct.brightness_max       = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Direct.brightness           = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
     Direct.color_mode           = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Breathing;
     Breathing.name              = "Breathing";
-    Breathing.value             = 2;
+    Breathing.value             = ASUS_ROG_STRIX_EVOLVE_MODE_BREATHING;
     Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.brightness_min    = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    Breathing.brightness_max    = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    Breathing.brightness        = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Breathing.brightness_min    = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Breathing.brightness        = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
     Breathing.color_mode        = MODE_COLORS_PER_LED;
     modes.push_back(Breathing);
 
     mode ColorCycle;
     ColorCycle.name             = "Spectrum Cycle";
-    ColorCycle.value            = 3;
+    ColorCycle.value            = ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE;
     ColorCycle.flags            = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    ColorCycle.brightness_min   = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    ColorCycle.brightness_max   = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    ColorCycle.brightness       = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    ColorCycle.brightness_min   = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    ColorCycle.brightness_max   = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    ColorCycle.brightness       = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
     ColorCycle.color_mode       = MODE_COLORS_NONE;
     modes.push_back(ColorCycle);
 
     mode Reactive;
     Reactive.name               = "Reactive";
-    Reactive.value              = 4;
+    Reactive.value              = ASUS_ROG_STRIX_EVOLVE_MODE_REACTIVE;
     Reactive.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Reactive.brightness_min     = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    Reactive.brightness_max     = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    Reactive.brightness         = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Reactive.brightness_min     = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Reactive.brightness_max     = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Reactive.brightness         = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
     Reactive.color_mode         = MODE_COLORS_PER_LED;
     modes.push_back(Reactive);
 
     SetupZones();
 }
 
-RGBController_AuraStrixEvolve::~RGBController_AuraStrixEvolve()
+RGBController_AsusROGStrixEvolve::~RGBController_AsusROGStrixEvolve()
 {
     delete controller;
 }
 
-void RGBController_AuraStrixEvolve::SetupZones()
+void RGBController_AsusROGStrixEvolve::SetupZones()
 {
     zone mouse_zone;
 
@@ -103,58 +103,48 @@ void RGBController_AuraStrixEvolve::SetupZones()
     SetupColors();
 }
 
-void RGBController_AuraStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/)
+void RGBController_AsusROGStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/)
 {
 
 }
 
-void RGBController_AuraStrixEvolve::DeviceUpdateLEDs()
+void RGBController_AsusROGStrixEvolve::DeviceUpdateLEDs()
 {
-    unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-
-    controller->SendUpdate(0x1C, red);
-    controller->SendUpdate(0x1D, grn);
-    controller->SendUpdate(0x1E, blu);
+    UpdateSingleLED(0);
 }
 
-void RGBController_AuraStrixEvolve::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AsusROGStrixEvolve::UpdateZoneLEDs(int zone)
 {
-    DeviceUpdateLEDs();
+    UpdateSingleLED(zone);
 }
 
-void RGBController_AuraStrixEvolve::UpdateSingleLED(int /*led*/)
+void RGBController_AsusROGStrixEvolve::UpdateSingleLED(int led)
 {
-    DeviceUpdateLEDs();
+    controller->SendUpdate(0x1C, RGBGetRValue(colors[0]));
+    controller->SendUpdate(0x1D, RGBGetGValue(colors[0]));
+    controller->SendUpdate(0x1E, RGBGetBValue(colors[0]));
 }
 
-void RGBController_AuraStrixEvolve::DeviceUpdateMode()
+void RGBController_AsusROGStrixEvolve::DeviceUpdateMode()
 {
-    unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-
     controller->SendUpdate(0x19, modes[active_mode].value);
     controller->SendUpdate(0x1A, modes[active_mode].brightness);
-    controller->SendUpdate(0x1C, red);
-    controller->SendUpdate(0x1D, grn);
-    controller->SendUpdate(0x1E, blu);
 }
 
-void RGBController_AuraStrixEvolve::DeviceSaveMode()
+void RGBController_AsusROGStrixEvolve::DeviceSaveMode()
 {
-    unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-
     unsigned int profile = controller->GetActiveProfile();
 
+
     controller->UpdateProfile(0x19, profile, modes[active_mode].value);
     controller->UpdateProfile(0x1A, profile, modes[active_mode].brightness);
-    controller->UpdateProfile(0x1C, profile, red);
-    controller->UpdateProfile(0x1D, profile, grn);
-    controller->UpdateProfile(0x1E, profile, blu);
 
-    controller->SendSavePacket();
+    if(modes[active_mode].value != ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE)
+    {
+        controller->UpdateProfile(0x1C, profile, RGBGetRValue(colors[0]));
+        controller->UpdateProfile(0x1D, profile, RGBGetGValue(colors[0]));
+        controller->UpdateProfile(0x1E, profile, RGBGetBValue(colors[0]));
+    }
+
+    controller->ResetToSavedLighting();
 }

Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.h

@@ -0,0 +1,48 @@
+/*-----------------------------------------*\
+|  RGBController_AsusROGStrixEvolve.h       |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraMouseGen1Controller.h"
+
+enum
+{
+    ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN        = 0,
+    ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX        = 255,
+    ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT    = 255,
+};
+
+enum
+{
+    ASUS_ROG_STRIX_EVOLVE_MODE_DIRECT           = 0x01,
+    ASUS_ROG_STRIX_EVOLVE_MODE_BREATHING        = 0x02,
+    ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE   = 0x03,
+    ASUS_ROG_STRIX_EVOLVE_MODE_REACTIVE         = 0x04,
+};
+
+class RGBController_AsusROGStrixEvolve : public RGBController
+{
+public:
+    RGBController_AsusROGStrixEvolve(AsusAuraMouseGen1Controller* controller_ptr);
+    ~RGBController_AsusROGStrixEvolve();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    AsusAuraMouseGen1Controller*  controller;
+};

Controllers/AsusAuraUSBController/ROGStrixLC_Controller.cpp

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

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.cpp

@@ -55,8 +55,8 @@ std::string AsusCerberusKeyboardController::GetSerialString()
 std::string AsusCerberusKeyboardController::GetVersion()
 {
     char versionstr[5];
-    snprintf(versionstr, 3, "%X", version);
-    return(std::string(versionstr, 3));
+    snprintf(versionstr, 5, "%X", version);
+    return(std::string(versionstr));
 }
 
 void AsusCerberusKeyboardController::SetProfile

Controllers/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp

@@ -1,16 +1,20 @@
 #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)
@@ -26,6 +30,19 @@ void DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
     }
 }
 
+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);
@@ -40,5 +57,6 @@ 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);

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.cpp

@@ -0,0 +1,197 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,76 @@
+/*-----------------------------------------*\
+|  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_AsusSagarisKeyboard.cpp

@@ -0,0 +1,246 @@
+/*-----------------------------------------*\
+|  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);
+}