Address most of original review comments

Update file header comments and minor code cleanup
Initial commit for Airgoo Lustrous Commander controller (!1080 )
2024-09-22 21:20:05 -05:00 · 2024-09-22 19:39:09 -05:00 · 2024-09-22 19:27:18 -05:00 · 2024-09-22 23:54:18 +00:00 · 2024-09-22 23:52:08 +00:00 · 2024-09-22 23:50:54 +00:00
3351 changed files with 328675 additions and 227097 deletions
@@ -32,7 +32,10 @@ before_script:
 #-----------------------------------------------------------------------#
 "Supported Devices":
  <<: *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-amd64
+  tags:
+  - linux
+  - amd64
  stage: build
  script:
  - qmake
@@ -42,11 +45,7 @@ before_script:
  artifacts:
    name: "${CI_PROJECT_NAME}_Supported_Devices_${CI_COMMIT_SHORT_SHA}"
    paths:
-    - ./*.md
    - Supported Devices.csv
-    exclude:
-    - README.md
-    - CONTRIBUTING.md
    expire_in: 30 days

  rules:
@@ -57,18 +56,21 @@ before_script:
    allow_failure: true

 #-----------------------------------------------------------------------#
-# Linux (AppImage) 32-bit Build Target                                  #
+# Linux (AppImage) i386 Build Target                                    #
 #-----------------------------------------------------------------------#
-"Linux 32 AppImage":
+"Linux i386 AppImage":
  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-i386
+  tags:
+  - linux
+  - i386
  stage: build
  script:
  - export $(dpkg-architecture)
  - ./scripts/build-appimage.sh

  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_32_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_i386_${CI_COMMIT_SHORT_SHA}"
    paths:
    - OpenRGB-i386.AppImage
    - 60-openrgb.rules
@@ -83,18 +85,21 @@ before_script:
    allow_failure: true

 #-----------------------------------------------------------------------#
-# Linux (AppImage) 64-bit Build Target                                  #
+# Linux (AppImage) amd64 Build Target                                   #
 #-----------------------------------------------------------------------#
-"Linux 64 AppImage":
+"Linux amd64 AppImage":
  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
+  tags:
+  - linux
+  - amd64
  stage: build
  script:
  - export $(dpkg-architecture)
  - ./scripts/build-appimage.sh

  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_64_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_amd64_${CI_COMMIT_SHORT_SHA}"
    paths:
    - OpenRGB-x86_64.AppImage
    - 60-openrgb.rules
@@ -102,25 +107,25 @@ before_script:
    expire_in: 30 days

 #-----------------------------------------------------------------------#
-# Linux (.deb) Debian Buster (Legacy) 32-bit Build Target               #
+# Linux (AppImage) armhf Build Target                                   #
 #-----------------------------------------------------------------------#
-"Linux 32 .deb (Debian Buster)":
+"Linux armhf AppImage":
  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-armhf
+  tags:
+  - linux
+  - armhf
  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
-  - mv -v ../openrgb*.deb ./
+  - export $(dpkg-architecture)
+  - ./scripts/build-appimage.sh

  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_armhf_${CI_COMMIT_SHORT_SHA}"
    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.*deb
+    - OpenRGB-armhf.AppImage
+    - 60-openrgb.rules
+    - README.md
    expire_in: 30 days

  rules:
@@ -131,108 +136,53 @@ before_script:
    allow_failure: true

 #-----------------------------------------------------------------------#
-# Linux (.deb) Debian Buster (Legacy) 64-bit Build Target               #
+# Linux (AppImage) arm64 Build Target                                   #
 #-----------------------------------------------------------------------#
-"Linux 64 .deb (Debian Buster)":
+"Linux arm64 AppImage":
  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-arm64
+  tags:
+  - linux
+  - arm64
+  stage: build
+  script:
+  - export $(dpkg-architecture)
+  - ./scripts/build-appimage.sh
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_arm64_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - OpenRGB-arm64.AppImage
+    - 60-openrgb.rules
+    - README.md
+    expire_in: 30 days
+
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Bookworm i386 Build Target                        #
+#-----------------------------------------------------------------------#
+"Linux i386 .deb (Debian Bookworm)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-i386
+  tags:
+  - linux
+  - i386
  stage: build
  script:
  - ./scripts/build-package-files.sh debian/changelog
  - dpkg-architecture -l
  - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.*deb
-  - mv -v ../openrgb*.deb ./
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.*deb
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
-#-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bullseye 32-bit Build Target                      #
-#-----------------------------------------------------------------------#
-"Linux 32 .deb (Debian Bullseye)":
-  <<: *ccache_init
-  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
-  - mv -v ../openrgb*.deb ./
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.*deb
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
-#-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bullseye 64-bit Build Target                      #
-#-----------------------------------------------------------------------#
-"Linux 64 .deb (Debian Bullseye)":
-  <<: *ccache_init
-  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
-  - mv -v ../openrgb*.deb ./
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.*deb
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
-#-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bookworm 32-bit Build Target                      #
-#-----------------------------------------------------------------------#
-"Linux 32 .deb (Debian Bookworm)":
-  <<: *ccache_init
-  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
  - mv -v ../openrgb*.deb ./

  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_i386_deb_${CI_COMMIT_SHORT_SHA}"
    paths:
    - openrgb*.deb
    exclude:
@@ -247,11 +197,14 @@ before_script:
    allow_failure: true

 #-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bookworm 64-bit Build Target                      #
+# Linux (.deb) Debian Bookworm amd64 Build Target                       #
 #-----------------------------------------------------------------------#
-"Linux 64 .deb (Debian Bookworm)":
+"Linux amd64 .deb (Debian Bookworm)":
  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
+  tags:
+  - linux
+  - amd64
  stage: build
  script:
  - ./scripts/build-package-files.sh debian/changelog
@@ -261,7 +214,7 @@ before_script:
  - mv -v ../openrgb*.deb ./

  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_amd64_deb_${CI_COMMIT_SHORT_SHA}"
    paths:
    - openrgb*.deb
    exclude:
@@ -276,31 +229,28 @@ before_script:
    allow_failure: true

 #-----------------------------------------------------------------------#
-# Linux (.rpm, f35) 64-bit Build Target                                 #
+# Linux (.deb) Debian Bookworm armhf Build Target                       #
 #-----------------------------------------------------------------------#
-"Linux 64 f35 rpm":
-  image: fedora:35
+"Linux armhf .deb (Debian Bookworm)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-armhf
+  tags:
+  - linux
+  - armhf
  stage: build
  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
-  - cd /root/rpmbuild/SOURCES
-  - tar -cf OpenRGB.tar.gz OpenRGB/
-  - cd ..
-  - dnf builddep SPECS/OpenRGB.spec -y
-  - rpmbuild -ba SPECS/OpenRGB.spec
-  - cd RPMS/x86_64/
-  - mv openrgb*.rpm ${CI_PROJECT_DIR}/
-  - cd ${CI_PROJECT_DIR}
+  - ./scripts/build-package-files.sh debian/changelog
+  - dpkg-architecture -l
+  - dpkg-buildpackage -us -B
+  - rm -v ../openrgb-dbgsym*.deb
+  - mv -v ../openrgb*.deb ./

  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_64_rpm_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_armhf_deb_${CI_COMMIT_SHORT_SHA}"
    paths:
-    - openrgb*.rpm
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.deb
    expire_in: 30 days

  rules:
@@ -311,10 +261,42 @@ before_script:
    allow_failure: true

 #-----------------------------------------------------------------------#
-# Linux (.rpm, f36) 64-bit Build Target                                 #
+# Linux (.deb) Debian Bookworm arm64 Build Target                       #
 #-----------------------------------------------------------------------#
-"Linux 64 f36 rpm":
-  image: fedora:36
+"Linux arm64 .deb (Debian Bookworm)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-arm64
+  tags:
+  - linux
+  - arm64
+  stage: build
+  script:
+  - ./scripts/build-package-files.sh debian/changelog
+  - dpkg-architecture -l
+  - dpkg-buildpackage -us -B
+  - rm -v ../openrgb-dbgsym*.deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_arm64_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.deb
+    expire_in: 30 days
+
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
+#-----------------------------------------------------------------------#
+# Linux (.rpm, F40) 64-bit Build Target                                 #
+#-----------------------------------------------------------------------#
+"Linux 64 F40 rpm":
+  image: fedora:40
  stage: build
  script:
  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel -y
@@ -346,73 +328,9 @@ before_script:
    allow_failure: true

 #-----------------------------------------------------------------------#
-# Debian 32 Buster test                                                 #
+# Debian i386 Bookworm test                                             #
 #-----------------------------------------------------------------------#
-"Debian 32 Buster":
-  image: i386/debian:buster
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
-  - openrgb --version
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 32 .deb (Debian Buster)"
-  needs:
-  - "Linux 32 .deb (Debian Buster)"
-
-#-----------------------------------------------------------------------#
-# Debian 64 Buster test                                                 #
-#-----------------------------------------------------------------------#
-"Debian 64 Buster":
-  image: amd64/debian:buster
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-  - openrgb --version
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 64 .deb (Debian Buster)"
-  needs:
-  - "Linux 64 .deb (Debian Buster)"
-
-#-----------------------------------------------------------------------#
-# Debian 32 Bullseye test                                               #
-#-----------------------------------------------------------------------#
-"Debian 32 Bullseye":
-  image: i386/debian:bullseye
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
-  - openrgb --version
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 32 .deb (Debian Bullseye)"
-  needs:
-  - "Linux 32 .deb (Debian Bullseye)"
-
-#-----------------------------------------------------------------------#
-# Debian 64 Bullseye test                                               #
-#-----------------------------------------------------------------------#
-"Debian 64 Bullseye":
-  image: amd64/debian:bullseye
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-  - openrgb --version
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 64 .deb (Debian Bullseye)"
-  needs:
-  - "Linux 64 .deb (Debian Bullseye)"
-
-#-----------------------------------------------------------------------#
-# Debian 32 Bookworm test                                               #
-#-----------------------------------------------------------------------#
-"Debian 32 Bookworm":
+"Debian i386 Bookworm":
  image: i386/debian:bookworm
  stage: test
  script:
@@ -421,14 +339,14 @@ before_script:
  - openrgb --version
  - apt remove -y openrgb
  dependencies:
-  - "Linux 32 .deb (Debian Bookworm)"
+  - "Linux i386 .deb (Debian Bookworm)"
  needs:
-  - "Linux 32 .deb (Debian Bookworm)"
+  - "Linux i386 .deb (Debian Bookworm)"

 #-----------------------------------------------------------------------#
-# Debian 64 Bookworm test                                               #
+# Debian amd64 Bookworm test                                            #
 #-----------------------------------------------------------------------#
-"Debian 64 Bookworm":
+"Debian amd64 Bookworm":
  image: amd64/debian:bookworm
  stage: test
  script:
@@ -437,30 +355,14 @@ before_script:
  - openrgb --version
  - apt remove -y openrgb
  dependencies:
-  - "Linux 64 .deb (Debian Bookworm)"
+  - "Linux amd64 .deb (Debian Bookworm)"
  needs:
-  - "Linux 64 .deb (Debian Bookworm)"
+  - "Linux amd64 .deb (Debian Bookworm)"

 #-----------------------------------------------------------------------#
-# Ubuntu 64 20.04LTS test                                               #
+# Ubuntu amd64 22.04 test                                               #
 #-----------------------------------------------------------------------#
-"Ubuntu 64 20.04LTS":
-  image: ubuntu:focal
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-  - openrgb --version
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 64 .deb (Debian Buster)"
-  needs:
-  - "Linux 64 .deb (Debian Buster)"
-
-#-----------------------------------------------------------------------#
-# Ubuntu 64 22.04 test                                                  #
-#-----------------------------------------------------------------------#
-"Ubuntu 64 22.04LTS":
+"Ubuntu amd64 22.04LTS":
  image: ubuntu:jammy
  stage: test
  script:
@@ -469,39 +371,40 @@ before_script:
  - openrgb --version
  - apt remove -y openrgb
  dependencies:
-  - "Linux 64 .deb (Debian Bookworm)"
+  - "Linux amd64 .deb (Debian Bookworm)"
  needs:
-  - "Linux 64 .deb (Debian Bookworm)"
+  - "Linux amd64 .deb (Debian Bookworm)"

 #-----------------------------------------------------------------------#
-# Fedora 64 v35 test                                                    #
+# Ubuntu amd64 24.04 test                                               #
 #-----------------------------------------------------------------------#
-"Fedora 64 v35":
-  image: fedora:35
+"Ubuntu amd64 24.04LTS":
+  image: ubuntu:noble
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+  - openrgb --version
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux amd64 .deb (Debian Bookworm)"
+  needs:
+  - "Linux amd64 .deb (Debian Bookworm)"
+
+#-----------------------------------------------------------------------#
+# Fedora 64 v40 test                                                    #
+#-----------------------------------------------------------------------#
+"Fedora 64 v40":
+  image: fedora:40
  stage: test
  script:
  - yum -y localinstall ./openrgb*64.rpm
  - openrgb --version
  - yum -y remove openrgb
  dependencies:
-  - "Linux 64 f35 rpm"
+  - "Linux 64 F40 rpm"
  needs:
-  - "Linux 64 f35 rpm"
-
-#-----------------------------------------------------------------------#
-# Fedora 64 v36 test                                                    #
-#-----------------------------------------------------------------------#
-"Fedora 64 v36":
-  image: fedora:36
-  stage: test
-  script:
-  - yum -y localinstall ./openrgb*64.rpm
-  - openrgb --version
-  - yum -y remove openrgb
-  dependencies:
-  - "Linux 64 f36 rpm"
-  needs:
-  - "Linux 64 f36 rpm"
+  - "Linux 64 F40 rpm"

 #-----------------------------------------------------------------------#
 # Windows (32-bit) Build Target                                         #
@@ -43,6 +43,7 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/EVGAGP102GPUController/
 /Controllers/EVGAPascalGPUController/
 /Controllers/EVGATuringGPUController/                       @TheRogueZeta
+/Controllers/EVGASMBusController/                           @balika011
 /Controllers/EVGAUSBController/                             @Dr_No
 /Controllers/EVisionKeyboardController/
 /Controllers/EspurnaController/
@@ -13,7 +13,7 @@
 /*-----------------------------------------------------*\
 | OpenRGB includes                                      |
 \*-----------------------------------------------------*/
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "Detector.h"
 #include "RGBController.h"

@@ -57,6 +57,7 @@ void DetectBloodyB820R(hid_device_info* info, const std::string& name)
 }

 REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
+REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W70_MAX_PID,     2,      0xFF33,     0x0518);
 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);
@@ -10,6 +10,7 @@
 \*---------------------------------------------------------*/

 #include "BloodyB820RController.h"
+#include "StringUtils.h"

 /*-------------------------------------------------------------------------------------*\
 | The controller for this device should pass a packet of 64 bytes where the subsequent  |
@@ -35,14 +36,15 @@ BloodyB820RController::~BloodyB820RController()

 std::string BloodyB820RController::GetSerial()
 {
-    const int szTemp    = HID_MAX_STR;
-    wchar_t   tmpName[szTemp];
+    wchar_t serial_string[HID_MAX_STR];
+    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);

-    hid_get_serial_number_string(dev, tmpName, szTemp);
-    std::wstring wName  = std::wstring(tmpName);
-    std::string serial  = std::string(wName.begin(), wName.end());
+    if(ret != 0)
+    {
+        return("");
+    }

-    return(serial);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 std::string BloodyB820RController::GetLocation()
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 #define HID_MAX_STR                     255
@@ -145,7 +145,7 @@ static const char *led_names[] =
    @save :x:
    @direct :white_check_mark:
    @effects :x:
-    @detectors A4TechDetector
+    @detectors DetectBloodyB820R
    @comment The A4Tech Bloody B820R keyboard controller currently
        supports the full size (ANSI layout).
 \*-------------------------------------------------------------------*/
@@ -10,7 +10,7 @@
 \*---------------------------------------------------------*/

 #include "BloodyMouseController.h"
-#include "LogManager.h"
+#include "StringUtils.h"

 BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
 {
@@ -33,21 +33,15 @@ uint16_t BloodyMouseController::GetPid()

 std::string BloodyMouseController::GetSerial()
 {
-    const uint8_t   sz  = HID_MAX_STR;
-    wchar_t         tmp[sz];
+    wchar_t serial_string[HID_MAX_STR];
+    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);

-    int ret             = hid_get_serial_number_string(dev, tmp, sz);
-
-    if (ret != 0)
+    if(ret != 0)
    {
-        LOG_DEBUG("[BloodyMouse] Get HID Serial string failed");
        return("");
    }

-    std::wstring w_tmp  = std::wstring(tmp);
-    std::string serial  = std::string(w_tmp.begin(), w_tmp.end());
-
-    return(serial);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 std::string BloodyMouseController::GetLocation()
@@ -12,13 +12,14 @@
 #pragma once

 #include <string>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 /*-----------------------------------------------------*\
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
 #define BLOODY_W60_PRO_PID                          0x37EA
+#define BLOODY_W70_MAX_PID                          0x79EF
 #define BLOODY_W90_MAX_PID                          0x3666

 /*-----------------------------------------------------*\
@@ -109,6 +109,7 @@ void RGBController_BloodyMouse::SetupZones()
        case BLOODY_W60_PRO_PID:
            layout = w60_pro;
            break;
+        case BLOODY_W70_MAX_PID:
        case BLOODY_W90_MAX_PID:
            layout = w90_max;
            break;
@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "AMDWraithPrismController.h"
+#include "StringUtils.h"

 AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const char* path)
 {
@@ -55,10 +56,7 @@ std::string AMDWraithPrismController::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 std::string AMDWraithPrismController::GetFirmwareVersionString()
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
@@ -9,7 +9,7 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "Detector.h"
 #include "AMDWraithPrismController.h"
 #include "RGBController.h"
@@ -13,6 +13,7 @@
 #include <cstring>
 #include <thread>
 #include "AOCKeyboardController.h"
+#include "StringUtils.h"

 using namespace std::chrono_literals;

@@ -42,10 +43,7 @@ std::string AOCKeyboardController::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 void AOCKeyboardController::SetLightingConfig
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 /*-----------------------------------------*\
@@ -35,10 +35,10 @@ layout_values aoc_keyboard_offset_values =
            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,
+        /* 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,    0,   10,                      57,   72,   87,
+        /* LSFT    \     Z     X     C     V     B     N     M     ,     .     /   RSFT             ARWU          NP1   NP2   NP3  NPEN */
+            30,    0,   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
    },
@@ -11,6 +11,7 @@

 #include <cstring>
 #include "AOCMouseController.h"
+#include "StringUtils.h"

 AOCMouseController::AOCMouseController(hid_device* dev_handle, const char* path)
 {
@@ -38,10 +39,7 @@ std::string AOCMouseController::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 /*-------------------------------------------------------------------------------------------------*\
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 /*-----------------------------------------*\
@@ -11,6 +11,7 @@

 #include <cstring>
 #include "AOCMousematController.h"
+#include "StringUtils.h"

 AOCMousematController::AOCMousematController(hid_device* dev_handle, const char* path)
 {
@@ -38,10 +39,7 @@ std::string AOCMousematController::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 /*-------------------------------------------------------------------------------------------------*\
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 /*-----------------------------------------*\
@@ -15,6 +15,7 @@
 #include "RGBController.h"
 #include "ResourceManager.h"
 #include "SettingsManager.h"
+#include "StringUtils.h"
 #include "ASRockPolychromeUSBController.h"
 #include "dmiinfo.h"

@@ -80,10 +81,7 @@ std::string PolychromeUSBController::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 void PolychromeUSBController::SetDeviceInfo()
@@ -13,7 +13,7 @@
 #pragma once

 #include <string>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 /*----------------------------------------------------------------------------------------------*\
@@ -156,7 +156,6 @@ protected:
        );

 private:
-    unsigned int  led_count;
    std::string   device_name;
    unsigned char configtable[12];
    bool          rgswapconfig[8] = { 0 };
@@ -13,7 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <vector>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "Detector.h"
 #include "ASRockPolychromeUSBController.h"
 #include "RGBController.h"
@@ -31,7 +31,6 @@ public:
    void        DeviceUpdateMode();

 private:
-    bool                            initializedMode;
    PolychromeUSBController*        controller;
    std::vector<PolychromeZoneInfo> zones_info;

@@ -169,7 +169,7 @@ void RGBController_ASRockASRRGBSMBus::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_ASRockASRRGBSMBus::DeviceUpdateLEDs()
 {
-    for(int led = 0; led < colors.size(); led++)
+    for(unsigned int led = 0; led < colors.size(); led++)
    {
        UpdateSingleLED(led);
    }
@@ -290,7 +290,7 @@ void RGBController_ASRockPolychromeV2SMBus::ResizeZone(int /*zone*/, int /*new_s

 void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateLEDs()
 {
-    for(int led = 0; led < colors.size(); led++)
+    for(unsigned int led = 0; led < colors.size(); led++)
    {
        UpdateSingleLED(led);
    }
@@ -0,0 +1,117 @@
+/*---------------------------------------------------------*\
+| AirgooLustrousCommanderController.cpp                     |
+|                                                           |
+|   Driver for Airgoo Lustrous Commander                    |
+|                                                           |
+|   Zacahry Guinn                               07 Feb 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <cstring>
+#include "AirgooLustrousCommanderController.h"
+
+AirgooLustrousCommanderController::AirgooLustrousCommanderController(hid_device* dev_handle, const char* path)
+{
+    dev                     = dev_handle;
+    location                = path;
+
+    /*-----------------------------------------------------*\
+    | Initialize controller                                 |
+    \*-----------------------------------------------------*/
+    InitController();
+}
+
+AirgooLustrousCommanderController::~AirgooLustrousCommanderController()
+{
+    /*-----------------------------------------------------*\
+    | Close HID device                                      |
+    \*-----------------------------------------------------*/
+    hid_close(dev);
+}
+
+void AirgooLustrousCommanderController::InitController()
+{
+    unsigned char   usb_buf[AIRGOO_LUSTROUS_COMMANDER_PACKET_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Send initialization packet                            |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = 0x55;
+    usb_buf[0x03]       = 0xAA;
+
+    hid_write(dev, usb_buf, AIRGOO_LUSTROUS_COMMANDER_PACKET_SIZE);
+
+    //expecting the device to return AA 55 01
+    hid_read(dev, usb_buf, AIRGOO_LUSTROUS_COMMANDER_PACKET_SIZE);
+
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = 0x55;
+    usb_buf[0x03]       = 0xAA;
+    usb_buf[0x04]       = 0x01;
+
+    //looks like the client software awknolleges? it returns a 0x01 in pos 4 of the buffer array
+    hid_write(dev, usb_buf, AIRGOO_LUSTROUS_COMMANDER_PACKET_SIZE);
+
+    //device will send aa 55 00 back and it seems that we should be ready to send commands at this point
+}
+
+std::string AirgooLustrousCommanderController::GetLocationString()
+{
+    return("HID: " + location);
+}
+
+void AirgooLustrousCommanderController::UpdateDevice
+    (
+    unsigned char   mode,
+    unsigned char   red,
+    unsigned char   grn,
+    unsigned char   blu,
+    unsigned char   speed
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]       = 0x00;
+
+    switch(mode)
+    {
+        case 1: //static
+            usb_buf[0x01]       = 0x09; //number of bytes in package
+            usb_buf[0x02]       = 0xFF;
+            usb_buf[0x03]       = 0x00;
+            usb_buf[0x04]       = 0xF0;
+            usb_buf[0x05]       = red; //Red
+            usb_buf[0x06]       = grn; //Green
+            usb_buf[0x07]       = blu; //Blue
+            usb_buf[0x08]       = 0x05;
+            usb_buf[0x09]       = 0x05;
+            usb_buf[0x0A]       = 0xFE;
+        break;
+        case 2://rainbow
+            usb_buf[0x01]       = 0x05; //number of bytes in package
+            usb_buf[0x02]       = 0xFF;
+            usb_buf[0x03]       = 0x06;
+            usb_buf[0x04]       = 0x01; //type like wheel or rolling
+            usb_buf[0x05]       = speed; //speed
+            usb_buf[0x06]       = 0xFE;
+    }
+
+    hid_write(dev, usb_buf, AIRGOO_LUSTROUS_COMMANDER_PACKET_SIZE);
+}
+
+void AirgooLustrousCommanderController::SetFanMode()
+{
+
+}
@@ -0,0 +1,45 @@
+/*---------------------------------------------------------*\
+| AirgooLustrousCommanderController.h                       |
+|                                                           |
+|   Driver for Airgoo Lustrous Commander                    |
+|                                                           |
+|   Zacahry Guinn                               07 Feb 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <vector>
+#include <hidapi.h>
+#include "RGBController.h"
+
+#define AIRGOO_LUSTROUS_COMMANDER_PACKET_SIZE       65
+#define AIRGOO_LUSTROUS_COMMANDER_NUM_RGB_CHANNELS  2
+#define AIRGOO_LUSTROUS_COMMANDER_NUM_FAN_CHANNELS  4
+
+class AirgooLustrousCommanderController
+{
+public:
+    AirgooLustrousCommanderController(hid_device* dev_handle, const char* path);
+    ~AirgooLustrousCommanderController();
+
+    std::string GetLocationString();
+
+    void        SetFanMode();
+    void        UpdateDevice
+                (
+                unsigned char   mode,
+                unsigned char   red,
+                unsigned char   grn,
+                unsigned char   blu,
+                unsigned char   speed
+                );
+
+private:
+    hid_device*             dev;
+    std::string             location;
+
+    void        InitController();
+};
@@ -0,0 +1,51 @@
+/*---------------------------------------------------------*\
+| AirgooLustrousCommanderControllerDetect.cpp               |
+|                                                           |
+|   Detector for Airgoo Lustrous Commander                  |
+|                                                           |
+|   Zacahry Guinn                               07 Feb 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <vector>
+#include <hidapi.h>
+#include "Detector.h"
+#include "AirgooLustrousCommanderController.h"
+#include "RGBController.h"
+#include "RGBController_AirgooLustrousCommander.h"
+
+/*---------------------------------------------------------*\
+| Airgoo vendor ID                                          |
+\*---------------------------------------------------------*/
+#define AIRGOO_VID                                  0x1A86
+
+/*---------------------------------------------------------*\
+| Lustrous Commander product IDs                            |
+\*---------------------------------------------------------*/
+#define AIRGOO_LUSTROUS_COMMANDER_PID               0xE6E0
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAirgooCommanderControllers                                                       *
+*                                                                                          *
+*       Tests the USB address to see if a Airgoo RGB controller exists there.              *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAirgooLustrousCommanderHIDControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AirgooLustrousCommanderController*     controller     = new AirgooLustrousCommanderController(dev, info->path);
+        RGBController_AirgooLustrousCommander* rgb_controller = new RGBController_AirgooLustrousCommander(controller);
+        rgb_controller->name                                  = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR("Airgoo Lustrous Commander",  DetectAirgooLustrousCommanderHIDControllers, AIRGOO_VID, AIRGOO_LUSTROUS_COMMANDER_PID);
@@ -0,0 +1,192 @@
+/*---------------------------------------------------------*\
+| RGBController_AirgooLustrousCommander.cpp                 |
+|                                                           |
+|   RGBController for Airgoo Lustrous Commander             |
+|                                                           |
+|   Zacahry Guinn                               07 Feb 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "RGBController_AirgooLustrousCommander.h"
+
+RGBController_AirgooLustrousCommander::RGBController_AirgooLustrousCommander(AirgooLustrousCommanderController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    vendor      = "Airgoo";
+    description = "Lustrous Commander";
+    type        = DEVICE_TYPE_LEDSTRIP;
+    location    = controller->GetLocationString();
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = 1;
+    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 Shift;
+    // Shift.name       = "Shift";
+    // Shift.value      = 1;
+    // Shift.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    // Shift.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    // Shift.colors_min           = 1;
+    // Shift.colors_max           = 16;
+    // Shift.colors.resize(Shift.colors_max);
+    // Shift.speed_min            = 0;
+    // Shift.speed_max            = 255;
+    // Shift.speed                = 05;
+    // Shift.brightness_min       = 100;
+    // Shift.brightness_max       = 0;
+    // Shift.brightness           = 0;
+    // modes.push_back(Shift);
+
+    // mode Pulse;
+    // Pulse.name       = "Pulse";
+    // Pulse.value      = 2;
+    // Pulse.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    // Pulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    // modes.push_back(Pulse);
+
+    // mode Gradual;
+    // Gradual.name       = "Gradual";
+    // Gradual.value      = 3;
+    // Gradual.flags      = MODE_FLAstd::cout << "@@@@@@@Init Contoller@@@@@@@" << std::endl;ORS_MODE_SPECIFIC;
+    // modes.push_back(Gradual);
+
+    // mode StarLight;
+    // StarLight.name       = "StarLight";
+    // StarLight.value      = 4;
+    // StarLight.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    // StarLight.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    // modes.push_back(StarLight);
+
+    mode Rainbow;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = 2;
+    Rainbow.flags     = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min            = 1;
+    Rainbow.speed_max            = 255;
+    Rainbow.speed                = 50;
+    Rainbow.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
+
+    // mode ColorWave;
+    // ColorWave.name       = "Color Wave";
+    // ColorWave.value      = 6;
+    // ColorWave.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    // ColorWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    // modes.push_back(ColorWave);
+
+    // mode ColorPulse;
+    // ColorPulse.name       = "Color Pulse";
+    // ColorPulse.value      = 7;
+    // ColorPulse.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    // ColorPulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    // modes.push_back(ColorPulse);
+
+    // mode ColorMeteor;
+    // ColorMeteor.name       = "Color Meteor";
+    // ColorMeteor.value      = 8;
+    // ColorMeteor.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    // ColorMeteor.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    // modes.push_back(ColorMeteor);
+
+    SetupZones();
+}
+
+RGBController_AirgooLustrousCommander::~RGBController_AirgooLustrousCommander()
+{
+    delete controller;
+}
+
+void RGBController_AirgooLustrousCommander::SetupZones()
+{
+    std::atomic<bool> first_run;
+    first_run = 0;
+
+    if(zones.size() == 0)
+    {
+        first_run = 1;
+    }
+
+    zones.resize(3);
+
+    for(unsigned int i = 1; i < (AIRGOO_LUSTROUS_COMMANDER_NUM_RGB_CHANNELS + 1); i++)
+    {
+        zones[i].name               = "RGB Port " + std::to_string(i);
+        zones[i].type               = ZONE_TYPE_LINEAR;
+        zones[i].leds_min           = 0;
+        zones[i].leds_max           = 34;
+
+        if(first_run)
+        {
+            zones[i].leds_count     = 0;
+        }
+    }
+
+    leds.clear();
+    colors.clear();
+
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        for (unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
+        {
+            led new_led;
+            new_led.name            = zones[zone_idx].name + " LED " + std::to_string(led_idx+1);
+
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_AirgooLustrousCommander::ResizeZone(int zone, int new_size)
+{
+    if((size_t) zone >= zones.size())
+    {
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
+
+        SetupZones();
+    }
+}
+
+void RGBController_AirgooLustrousCommander::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_AirgooLustrousCommander::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AirgooLustrousCommander::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AirgooLustrousCommander::DeviceUpdateMode()
+{
+    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]);
+    }
+    controller->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed);
+}
@@ -0,0 +1,35 @@
+/*---------------------------------------------------------*\
+| RGBController_AirgooLustrousCommander.cpp                 |
+|                                                           |
+|   RGBController for Airgoo Lustrous Commander             |
+|                                                           |
+|   Zacahry Guinn                               07 Feb 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AirgooLustrousCommanderController.h"
+
+class RGBController_AirgooLustrousCommander : public RGBController
+{
+public:
+    RGBController_AirgooLustrousCommander(AirgooLustrousCommanderController* controller_ptr);
+    ~RGBController_AirgooLustrousCommander();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AirgooLustrousCommanderController*  controller;
+    std::vector<int>                    fanleds{0};
+};
@@ -19,6 +19,7 @@
 #include "RGBController.h"
 #include "AlienwareController.h"
 #include "LogManager.h"
+#include "StringUtils.h"

 typedef uint32_t alienware_platform_id;

@@ -30,7 +31,8 @@ static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
 {
    { 0x0C01,   4 },    // Dell G5 SE 5505
    { 0x0A01,  16 },    // Dell G7 15 7500
-    { 0x0E03,   4 }     // Dell G15   5511
+    { 0x0E03,   4 },    // Dell G15   5511
+    { 0x0E0A,   4 }     // Dell G15   5530

 };

@@ -46,7 +48,8 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
                  "Light Bar 4",    "Light Bar 5",  "Light Bar 6",
                  "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
-    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } }
+    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } },
+    { 0x0E0A,   { "Left",           "Middle",       "Right",        "Numpad"    } }
 };

 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
@@ -87,9 +90,7 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
    /*-----------------------------------------------------*\
    | Get serial number                                     |
    \*-----------------------------------------------------*/
-    std::wstring tmp_serial_number;
-    tmp_serial_number   = info.serial_number;
-    serial_number       = std::string(tmp_serial_number.begin(), tmp_serial_number.end());
+    serial_number       = StringUtils::wstring_to_string(info.serial_number);

    /*-----------------------------------------------------*\
    | Get zone information by checking firmware             |
@@ -654,7 +655,7 @@ void AlienwareController::UpdateDim()

    for(size_t i = 0; i < zones.size(); i++)
    {
-        dim_zone_map[zones[i].dim].emplace_back(i);
+        dim_zone_map[zones[i].dim].emplace_back((uint8_t)i);
    }

    for(std::pair<const uint8_t, std::vector<uint8_t>> &pair : dim_zone_map)
@@ -681,7 +682,7 @@ bool AlienwareController::UpdateDirect()

    for(size_t i = 0; i < zones.size(); i++)
    {
-        color_zone_map[zones[i].color[0]].emplace_back(i);
+        color_zone_map[zones[i].color[0]].emplace_back((uint8_t)i);
    }

    for(std::pair<const RGBColor, std::vector<uint8_t>> &pair : color_zone_map)
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 /*----------------------------------------------------------------------------------------------*\
@@ -20,7 +20,8 @@
 /*---------------------------------------------------------*\
 | Alienware product ID                                      |
 \*---------------------------------------------------------*/
-#define ALIENWARE_G_SERIES_PID                      0x0550
+#define ALIENWARE_G_SERIES_PID1                      0x0550
+#define ALIENWARE_G_SERIES_PID2                      0x0551

 void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
 {
@@ -35,4 +36,5 @@ void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
    }
 }

-REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID);
+REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID1);
+REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID2);
@@ -12,6 +12,7 @@

 #include <cstring>
 #include "AlienwareAW410KController.h"
+#include "StringUtils.h"

 AlienwareAW410KController::AlienwareAW410KController(hid_device* dev_handle, const char* path)
 {
@@ -35,15 +36,13 @@ 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);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 void AlienwareAW410KController::SendCommit()
@@ -13,7 +13,7 @@
 #pragma once

 #include <string>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 enum
@@ -11,6 +11,7 @@

 #include <cstring>
 #include "AlienwareAW510KController.h"
+#include "StringUtils.h"

 AlienwareAW510KController::AlienwareAW510KController(hid_device* dev_handle, const char* path)
 {
@@ -33,12 +34,14 @@ std::string AlienwareAW510KController::GetDeviceLocation()
 std::string AlienwareAW510KController::GetSerialString()
 {
    wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
+    if(ret != 0)
+    {
+        return("");
+    }

-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 void AlienwareAW510KController::SendCommit()
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 enum
@@ -7,7 +7,7 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "Detector.h"
 #include "AlienwareAW510KController.h"
 #include "AlienwareAW410KController.h"
@@ -10,6 +10,7 @@
 \*---------------------------------------------------------*/

 #include "AnnePro2Controller.h"
+#include "StringUtils.h"

 using namespace std::chrono_literals;

@@ -39,10 +40,7 @@ std::string AnnePro2Controller::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 void AnnePro2Controller::SendDirect(unsigned char frame_count, unsigned char * frame_data)
@@ -13,7 +13,7 @@

 #include <string>
 #include <vector>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 class AnnePro2Controller
@@ -13,7 +13,7 @@
 #include "AnnePro2Controller.h"
 #include "RGBController.h"
 #include "RGBController_AnnePro2.h"
-#include <hidapi/hidapi.h>
+#include <hidapi.h>

 /*---------------------------------------------------------*\
 | Anne Pro 2 vendor IDs                                     |
@@ -47,5 +47,5 @@ REGISTER_DETECTOR("Arctic RGB controller", DetectArcticControllers);
 /*---------------------------------------------------------------------------------------------------------*\
 | Entries for dynamic UDEV rules                                                                            |
 |                                                                                                           |
-| DUMMY_DEVICE_DETECTOR("Arctic RGB controller", DetectArcticControllers, 0x1a86, 0x7523 )                  |
+| DUMMY_DEVICE_DETECTOR("Arctic RGB controller", DetectArcticControllers, 0x1A86, 0x7523 )                  |
 \*---------------------------------------------------------------------------------------------------------*/
@@ -11,6 +11,7 @@

 #include <cstring>
 #include "AsusAuraCoreController.h"
+#include "StringUtils.h"

 #define AURA_CORE_MAX_MESSAGE_SIZE  64

@@ -49,10 +50,7 @@ std::string AuraCoreController::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 void AuraCoreController::SendBrightness
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 enum AuraCoreDeviceType
@@ -15,12 +15,10 @@
 #include "RGBController.h"
 #include "RGBController_AsusAuraCore.h"
 #include "RGBController_AsusAuraCoreLaptop.h"
-#include <hidapi/hidapi.h>
+#include <hidapi.h>

 #define AURA_CORE_VID                   0x0B05

-#define AURA_STRIX_SCAR_15_PID          0x19B6
-
 /******************************************************************************************\
 *                                                                                          *
 *   DetectAuraCoreControllers                                                              *
@@ -10,43 +10,9 @@
 \*---------------------------------------------------------*/

 #include "AsusAuraCoreLaptopController.h"
+#include "dmiinfo.h"
 #include "SettingsManager.h"
-
-static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT       +
-                          ASUSAURACORELAPTOP_LIGHTBARCOUNT  +
-                          ASUSAURACORELAPTOP_LIDCOUNT       ] =
-{
-/*00        ESC  F1   F2   F3   F4   F5   F6   F7   F8   F9  */
-            21,  23,  24,  25,  26,  28,  29,  30,  31,  33,
-
-/*10        F10  F11  F12  DEL   `    1    2    3    4    5  */
-            34,  35,  36,  37,  42,  43,  44,  45,  46,  47,
-
-/*20         6    7    8    9    0    -    =   BSP  BSP  BSP */
-            48,  49,  50,  51,  52,  53,  54,  55,  56,  57,
-
-/*30        PLY  TAB   Q    W    E    R    T    Y    U    I  */
-            58,  63,  64,  65,  66,  67,  68,  69,  70,  71,
-
-/*40         O    P    [    ]    \   STP  CAP   A    S    D  */
-            72,  73,  74,  75,  76,  79,  84,  85,  86,  87,
-
-/*50         F    G    H    J    K    L    ;    '   ENT  PRV */
-            88,  89,  90,  91,  92,  93,  94,  95,  98, 100,
-
-/*60        LSH   Z    X    C    V    B    N    M    ,    .  */
-           105, 107, 108, 109, 110, 111, 112, 113, 114, 115,
-
-/*70         /   RSH  UP   NXT LCTL  LFN LWIN LALT  SPC RALT */
-           116, 119, 139, 121, 126, 127, 128, 129, 131, 135,
-
-/*80       RCTL  LFT  DWN  RGT  PRT KSTN  VDN  VUP MICM HPFN */
-           137, 159, 160, 161, 142, 175,   2,   3,   4,   5,
-
-/*90       ARMC  LB1  LB2  LB3  LB4  LB5  LB6 LOGO LIDL LIDR */
-             6, 174, 173, 172, 171, 170, 169, 167, 176, 177,
-
-};
+#include "StringUtils.h"

 static std::string power_zones[ASUSAURACORELAPTOP_POWER_ZONES] =
 {
@@ -66,20 +32,40 @@ static std::string power_states[ASUSAURACORELAPTOP_POWER_STATES] =

 AsusAuraCoreLaptopController::AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path)
 {
-    const uint8_t sz    = HID_MAX_STR;
-    wchar_t       tmp[sz];
+    dev                     = dev_handle;
+    location                = path;

-    dev                 = dev_handle;
-    location            = path;
+    /*---------------------------------------------------------*\
+    | The motherboard name will uniquely ID the laptop to       |
+    |   determine the metadata of the device.                   |
+    \*---------------------------------------------------------*/
+    DMIInfo dmi_info;
+    std::string dmi_name    = dmi_info.getMainboard();
+    bool not_found          = true;

-    hid_get_manufacturer_string(dev, tmp, sz);
-    std::wstring wName = std::wstring(tmp);
-    device_name = std::string(wName.begin(), wName.end());
+    for(uint16_t i = 0; i < AURA_CORE_LAPTOP_DEVICE_COUNT; i++)
+    {
+        if(aura_core_laptop_device_list[i]->dmi_name == dmi_name)
+        {
+            /*---------------------------------------------------------*\
+            | Set device ID                                             |
+            \*---------------------------------------------------------*/
+            not_found       = false;
+            device_index    = i;
+            break;
+        }
+    }

-    hid_get_product_string(dev, tmp, sz);
-    wName = std::wstring(tmp);
-    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
+    if(not_found)
+    {
+        LOG_ERROR("[%s] device capabilities not found. Please creata a new device request.",
+                  dmi_name.c_str());
+        return;
+    }

+    /*---------------------------------------------------------*\
+    | Only set power config for known devices                   |
+    \*---------------------------------------------------------*/
    SetPowerConfigFromJSON();
 }

@@ -88,28 +74,81 @@ AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController()
    hid_close(dev);
 }

-std::string AsusAuraCoreLaptopController::GetDeviceName()
+const aura_core_laptop_device* AsusAuraCoreLaptopController::GetDeviceData()
 {
-    return device_name;
+    return aura_core_laptop_device_list[device_index];
+}
+
+std::string AsusAuraCoreLaptopController::GetDeviceDescription()
+{
+    /*---------------------------------------------------------*\
+    | Get device name from HID manufacturer and product strings |
+    \*---------------------------------------------------------*/
+    wchar_t name_string[HID_MAX_STR];
+
+    hid_get_manufacturer_string(dev, name_string, HID_MAX_STR);
+    std::string name = StringUtils::wstring_to_string(name_string);
+
+    hid_get_product_string(dev, name_string, HID_MAX_STR);
+    name.append(" ").append(StringUtils::wstring_to_string(name_string));
+    return name;
+}
+
+unsigned int AsusAuraCoreLaptopController::GetKeyboardLayout()
+{
+    const uint8_t index                                     = 6;
+    uint8_t result                                          = 0;
+    uint8_t rd_buf[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID };
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID,
+                                                                ASUSAURACORELAPTOP_CMD_LAYOUT,
+                                                                0x20,
+                                                                0x31,
+                                                                0x00,
+                                                                0x10  };
+
+    /*---------------------------------------------------------*\
+    | Clear the read buffer to ensure we read the right packet  |
+    \*---------------------------------------------------------*/
+    do
+    {
+        result = hid_read_timeout(dev, rd_buf, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE, 10);
+    }
+    while(result > 0);
+
+    memset(&rd_buf[1],     0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - 1);
+    memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
+
+    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+    result = hid_get_feature_report(dev, rd_buf, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+
+    LOG_DEBUG("[%s] GetKeyboardLayout %02X %02X %02X %02X   %02X %02X %02X {%02X}   %02X %02X %02X %02X",
+              aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
+              rd_buf[5],  rd_buf[6],  rd_buf[7],  rd_buf[8],  rd_buf[9],  rd_buf[10],
+              rd_buf[11], rd_buf[12], rd_buf[13], rd_buf[14], rd_buf[15], rd_buf[16]);
+
+    if(result > 0)
+    {
+        return rd_buf[12];
+    }
+
+    LOG_DEBUG("[%s] GetKeyboardLayout: An error occurred! Setting layout to ANSI",
+              aura_core_laptop_device_list[device_index]->dmi_name.c_str());
+    return ASUSAURACORELAPTOP_LAYOUT_ANSI;
 }

 std::string AsusAuraCoreLaptopController::GetSerial()
 {
-    const uint8_t sz    = HID_MAX_STR;
-    wchar_t       tmp[sz];
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);

-    int ret             = hid_get_serial_number_string(dev, tmp, sz);
-
-    if (ret != 0)
+    if(ret != 0)
    {
-        LOG_DEBUG("[%s] Get HID Serial string failed", device_name.c_str());
+        LOG_DEBUG("[%s] Get HID Serial string failed",
+                  aura_core_laptop_device_list[device_index]->dmi_name.c_str());
        return("");
    }

-    std::wstring w_tmp  = std::wstring(tmp);
-    std::string serial  = std::string(w_tmp.begin(), w_tmp.end());
-
-    return serial;
+    return(StringUtils::wstring_to_string(serial_string));
 }

 std::string AsusAuraCoreLaptopController::GetLocation()
@@ -137,35 +176,50 @@ void AsusAuraCoreLaptopController::SetMode(uint8_t mode, uint8_t speed, uint8_t
        current_random      = random;
        current_direction   = direction;

+        if(current_mode == ASUSAURACORELAPTOP_MODE_DIRECT)
+        {
+            SendInitDirectMode();
+            return;
+        }
+
        SendUpdate();
        SendBrightness();
    }
 }

-void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)
+void AsusAuraCoreLaptopController::SendInitDirectMode()
+{
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT };
+    memset(&buffer[2], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - 2);
+
+    LOG_DEBUG("[%s] Resetting device for direct control", aura_core_laptop_device_list[device_index]->dmi_name.c_str());
+    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+}
+
+void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor *> colors)
 {
    /*---------------------------------------------------------*\
    | The keyboard zone is a set of 168 keys (indexed from 0)   |
    |   sent in 11 packets of 16 triplets. The Lid and Lightbar |
    |   zones are sent in one final packet afterwards.          |
    \*---------------------------------------------------------*/
-    const uint8_t  key_set                                  = 167;
-    const uint8_t  led_count                                = 178;
-    const uint16_t map_size                                 = 3 * led_count;
-    const uint8_t leds_per_packet                           = 16;
+    const uint8_t   key_set                                 = 167;
+    const uint8_t   led_count                               = colors.size();
+    const uint16_t  map_size                                = 3 * led_count;
+    const uint8_t   leds_per_packet                         = 16;
    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT,
                                                                0x00, 0x01, 0x01, 0x01, 0x00, leds_per_packet, 0x00 };
-    uint8_t key_buf[map_size];
+    uint8_t*        key_buf                                 = new uint8_t[map_size];

    memset(key_buf, 0, map_size);

-    for(size_t led_index = 0; led_index < colors.size(); led_index++)
+    for(size_t led_index = 0; led_index < led_count; led_index++)
    {
-        uint16_t offset         = 3 * packet_map[led_index];
+        std::size_t buf_idx     = (led_index * 3);

-        key_buf[offset]         = RGBGetRValue(colors[led_index]);
-        key_buf[offset + 1]     = RGBGetGValue(colors[led_index]);
-        key_buf[offset + 2]     = RGBGetBValue(colors[led_index]);
+        key_buf[buf_idx]        = RGBGetRValue(*colors[led_index]);
+        key_buf[buf_idx + 1]    = RGBGetGValue(*colors[led_index]);
+        key_buf[buf_idx + 2]    = RGBGetBValue(*colors[led_index]);
    }

    for(size_t i = 0; i < key_set; i+=leds_per_packet)
@@ -175,11 +229,20 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)
        if(leds_remaining < leds_per_packet)
        {
            buffer[07]          = leds_remaining;
+
+            memset(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
+                   0,
+                   ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - ASUSAURACORELAPTOP_DATA_BYTE);
        }

        buffer[06]              = (uint8_t)i;
        memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * i], (3 * buffer[07]));

+        LOG_DEBUG("[%s] Sending buffer @ index %d thru index %d",
+                  aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
+                  i,
+                  i + buffer[07]);
+
        hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
    }

@@ -187,15 +250,31 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)
    buffer[5] = 0x00;
    buffer[6] = 0x00;
    buffer[7] = 0x00;
-    memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * key_set], (3 * (led_count - key_set)));
+
+    memset(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
+           0,
+           ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - ASUSAURACORELAPTOP_DATA_BYTE);
+
+    if(led_count > key_set)
+    {
+        memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
+               &key_buf[3 * key_set],
+               (3 * (led_count - key_set)));
+    }
+
+    LOG_DEBUG("[%s] Sending buffer @ index %d thru index %d",
+              aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
+              key_set,
+              led_count);

    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+    delete[] key_buf;
 }

 void AsusAuraCoreLaptopController::SendBrightness()
 {
-    const uint8_t index                                     = 2;
-    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS };
+    const uint8_t index                                     = 5;
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS, 0xC5, 0xC4};

    memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
    buffer[4] = current_brightness;
@@ -288,6 +367,8 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
        device_settings[section_power]  = pcfg;
        settings_manager->SetSettings(detector_name, device_settings);
        settings_manager->SaveSettings();
+        LOG_DEBUG("[%s] default power config saved to openrgb.json",
+                  aura_core_laptop_device_list[device_index]->dmi_name.c_str());
    }
    else
    {
@@ -298,7 +379,9 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
            if(device_settings[section_power].contains(key_name))
            {
                power_config[i].state   = device_settings[section_power][key_name];
-                LOG_DEBUG("[%s] Reading power config for %s: %s", device_name.c_str(), key_name.c_str(), ((power_config[i].state) ? "On" : "Off"));
+                LOG_DEBUG("[%s] Reading power config for %s: %s",
+                          aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
+                          key_name.c_str(), ((power_config[i].state) ? "On" : "Off"));
            }
        }
    }
@@ -308,7 +391,7 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
    |   With thanks to AsusCtl for helping to decipher the packet captures          |
    |   https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-aura/src/usb.rs#L150  |
    \*-----------------------------------------------------------------------------*/
-    bool flag_array[] =
+    bool flag_array[32] =
    {
        power_config[0].state,      power_config[4].state,
        power_config[1].state,      power_config[5].state,
@@ -325,7 +408,9 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
    };

    uint32_t flags      = PackPowerFlags(flag_array);
-    LOG_DEBUG("[%s] Sending power config Logo+KB: %02X Lightbar: %02X Lid Edges: %02X Raw: %08X", device_name.c_str(), (flags & 0xFF), ((flags >> 8)  & 0xFF), ((flags >> 16)  & 0xFF), flags);
+    LOG_DEBUG("[%s] Sending power config Logo+KB: %02X Lightbar: %02X Lid Edges: %02X Raw: %08X",
+              aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
+              (flags & 0xFF), ((flags >> 8)  & 0xFF), ((flags >> 16)  & 0xFF), flags);
    SendPowerConfig(flags);
 }

@@ -13,11 +13,12 @@

 #include <string>
 #include <vector>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "LogManager.h"
 #include "RGBController.h"
 #include "ResourceManager.h"
 #include "RGBControllerKeyNames.h"
+#include "AsusAuraCoreLaptopDevices.h"

 #define NA                                      0xFFFFFFFF
 #define HID_MAX_STR                             255
@@ -33,7 +34,7 @@
 #define ASUSAURACORELAPTOP_POWER_ZONES          4
 #define ASUSAURACORELAPTOP_POWER_STATES         4
 #define ASUSAURACORELAPTOP_BRIGHTNESS_MIN       0
-#define ASUSAURACORELAPTOP_BRIGHTNESS_MAX       255
+#define ASUSAURACORELAPTOP_BRIGHTNESS_MAX       3 // No device has proven to have 256 keyboard brightness levels, only 0..3

 enum
 {
@@ -83,6 +84,7 @@ enum
    ASUSAURACORELAPTOP_CMD_UPDATE               = 0xB3,
    ASUSAURACORELAPTOP_CMD_APPLY                = 0xB4,
    ASUSAURACORELAPTOP_CMD_SET                  = 0xB5,
+    ASUSAURACORELAPTOP_CMD_LAYOUT               = 0x05,
 };

 enum
@@ -92,6 +94,12 @@ enum
    ASUSAURACORELAPTOP_SPEED_FASTEST            = 0xF5, // Fastest speed
 };

+enum aura_core_laptop_layout
+{
+    ASUSAURACORELAPTOP_LAYOUT_ANSI              = 0x01,     /* US ANSI Layout                   */
+    ASUSAURACORELAPTOP_LAYOUT_ISO               = 0x02,     /* EURO ISO Layout                  */
+};
+
 struct p_state
 {
    std::string zone;
@@ -104,33 +112,36 @@ public:
    AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path);
    ~AsusAuraCoreLaptopController();

-    std::string             GetDeviceName();
-    std::string             GetSerial();
-    std::string             GetLocation();
+    const aura_core_laptop_device*  GetDeviceData();
+    std::string                     GetDeviceDescription();
+    std::string                     GetSerial();
+    unsigned int                    GetKeyboardLayout();
+    std::string                     GetLocation();

-    void                    SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction);
-    void                    SetLedsDirect(std::vector<RGBColor> colors);
+    void                            SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction);
+    void                            SetLedsDirect(std::vector<RGBColor *>colors);
+    void                            SendInitDirectMode();
 private:
-    std::string             device_name;
-    std::string             location;
-    hid_device*             dev;
+    hid_device*                     dev;
+    uint16_t                        device_index;
+    std::string                     location;

-    uint8_t                 current_mode;
-    uint8_t                 current_speed;
-    uint8_t                 current_direction;
+    uint8_t                         current_mode;
+    uint8_t                         current_speed;
+    uint8_t                         current_direction;

-    RGBColor                current_c1;
-    RGBColor                current_c2;
-    uint8_t                 current_brightness;
-    uint8_t                 current_random;
+    RGBColor                        current_c1;
+    RGBColor                        current_c2;
+    uint8_t                         current_brightness;
+    uint8_t                         current_random;

-    void                    SendApply();
-    void                    SendBrightness();
-    void                    SendSet();
-    void                    SendUpdate();
+    void                            SendApply();
+    void                            SendBrightness();
+    void                            SendSet();
+    void                            SendUpdate();

-    void                    SetPowerConfigFromJSON();
-    void                    SendPowerConfig(uint32_t flags);
-    uint32_t                PackPowerFlags(bool flags[]);
-    std::vector<p_state>    PowerConfigArray();
+    void                            SetPowerConfigFromJSON();
+    void                            SendPowerConfig(uint32_t flags);
+    uint32_t                        PackPowerFlags(bool flags[]);
+    std::vector<p_state>            PowerConfigArray();
 };
@@ -0,0 +1,347 @@
+#include "AsusAuraCoreLaptopDevices.h"
+
+/*-------------------------------------------------------------------------*\
+|  Aura Core Key Values                                                     |
+|    NULL values are keys that are handed to the KLM but are removed as     |
+|    a part of customisation. They are included to maintain expected key    |
+|    count is aligned to the value count.                                   |
+\*-------------------------------------------------------------------------*/
+
+std::vector<unsigned int> aura_core_laptop_15_values =
+{
+    /* ESC          F1    F2    F3    F4    F5    F6    F7    F8    F9   F10   F11   F12         DEL  */
+        21,         23,   24,   25,   26,   28,   29,   30,   31,   33,   34,   35,   36,
+    /* BKTK    1     2     3     4     5     6     7     8     9     0     -     =   BSPC        PLAY  */
+        42,   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,   54,   55,
+    /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \         STOP  */
+        63,   64,   65,   66,   67,   68,   69,   70,   71,   72,   73,   74,   75,   76,
+    /* CPLK    A     S     D     F     G     H     J     K     L     ;     "     #   ENTR        PREV  */
+        84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,   95,   96,   98,
+    /* LSFT  ISO\    Z     X     C     V     B     N     M     ,     .     /   RSFT        ARWU  NEXT  */
+       105,  106,  107,  108,  109,  110,  111,  112,  113,  114,  115,  116,  119,
+    /* LCTL  LWIN  LALT              SPC               RALT  RFNC  RMNU  RCTL        ARWL  ARWD  ARWR  */
+       126,  128,  129,              131,              135,  136,  136,  137,
+};
+
+std::vector<unsigned int> aura_core_laptop_17_values =
+{
+    /* ESC          F1    F2    F3    F4    F5    F6    F7    F8    F9   F10   F11   F12   NULL  NULL  PAUS                          */
+        21,         23,   24,   25,   26,   28,   29,   30,   31,   33,   34,   35,   36,    0,    0,   39,
+    /* BKTK    1     2     3     4     5     6     7     8     9     0     -     =   BSPC  NULL  NULL  NULL  NMLK  NMDV  NMTM  NMMI  */
+        42,   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,   54,   56,    0,    0,    0,   59,   60,   61,   62,
+    /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   NULL  NULL  NULL  NM7   NM8   NM9   NMPL  */
+        63,   64,   65,   66,   67,   68,   69,   70,   71,   72,   73,   74,   75,   76,    0,    0,    0,   80,   81,   82,   83,
+    /* CPLK    A     S     D     F     G     H     J     K     L     ;     "     #   ENTR                    NM4   NM5   NM6         */
+        84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,   95,   96,   98,                    101,  102,  103,
+    /* LSFT  ISO\    Z     X     C     V     B     N     M     ,     .     /   RSFT              ARWU        NM1   NM2   NM3   NMER  */
+       105,  106,  107,  108,  109,  110,  111,  112,  113,  114,  115,  116,  119,              139,        122,  123,  124,  125,
+    /* LCTL  LWIN  LALT              SPC               RALT  RFNC  RMNU  RCTL              ARWL  ARWD  ARWR        NM0   NMPD        */
+       126,  128,  129,              131,              135,  136,  136,  137,              159,  160,  161,        144,  145,
+};
+
+std::vector<unsigned int> aura_core_laptop_18_values =
+{
+    /* ESC          F1    F2    F3    F4    F5    F6    F7    F8    F9   F10   F11   F12   NULL  NULL  PAUS                          */
+        21,         23,   24,   25,   26,   28,   29,   30,   31,   33,   34,   35,   36,    0,    0,   39,
+    /* BKTK    1     2     3     4     5     6     7     8     9     0     -     =   BSPC  NULL  NULL  NULL  NMLK  NMDV  NMTM  NMMI  */
+        42,   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,   54,   56,    0,    0,    0,   59,   60,   61,   62,
+    /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   NULL  NULL  NULL  NM7   NM8   NM9   NMPL  */
+        63,   64,   65,   66,   67,   68,   69,   70,   71,   72,   73,   74,   75,   76,    0,    0,    0,   80,   81,   82,   83,
+    /* CPLK    A     S     D     F     G     H     J     K     L     ;     "     #   ENTR                    NM4   NM5   NM6         */
+        84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,   95,   96,   98,                    101,  102,  103,
+    /* LSFT  ISO\    Z     X     C     V     B     N     M     ,     .     /   RSFT              ARWU        NM1   NM2   NM3   NMER  */
+        105,  106,  107,  108,  109,  110,  111,  112,  113,  114,  115,  116,  119,              121,        122,  123,  124,  125,
+    /* LCTL  LWIN  LALT              SPC               RALT  RFNC  RMNU  RCTL              ARWL  ARWD  ARWR        NM0   NMPD        */
+        126,  128,  129,              131,              135,  136,  136,  137,              141,  142,  143,        144,  145,
+};
+
+/*-------------------------------------------------------------------------*\
+|  KEYMAPS                                                                  |
+\*-------------------------------------------------------------------------*/
+keyboard_keymap_overlay_values g533zm_layout
+{
+    KEYBOARD_SIZE_SEVENTY_FIVE,
+    {
+        aura_core_laptop_15_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,      15,          37,        KEY_EN_DELETE,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Delete
+        {   0,      1,      15,          58,        KEY_EN_MEDIA_PLAY_PAUSE,    KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
+        {   0,      2,      15,          79,        KEY_EN_MEDIA_STOP,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
+        {   0,      3,      15,         100,        KEY_EN_MEDIA_PREVIOUS,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
+        {   0,      4,      13,         139,        KEY_EN_UP_ARROW,            KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Up Arrow
+        {   0,      4,      15,         121,        KEY_EN_MEDIA_NEXT,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
+        {   0,      5,      12,         159,        KEY_EN_LEFT_ARROW,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Arrow
+        {   0,      5,      13,         160,        KEY_EN_DOWN_ARROW,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Down Arrow
+        {   0,      5,      14,         161,        KEY_EN_RIGHT_ARROW,         KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Right Arrow
+    }
+};
+
+keyboard_keymap_overlay_values g713rw_keyboard_layout
+{
+    KEYBOARD_SIZE_FULL,
+    {
+        aura_core_laptop_17_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       2,           2,        KEY_EN_MEDIA_VOLUME_DOWN,   KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Row and add Volume Down
+        {   0,      0,       3,           3,        KEY_EN_MEDIA_VOLUME_UP,     KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Volume Up
+        {   0,      0,       4,           4,        KEY_EN_MEDIA_MUTE,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute
+        {   0,      0,       5,           5,        "Key: Fan",                 KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "Fan" key
+        {   0,      0,       6,           6,        "Key: ROG",                 KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "ROG" key
+        {   0,      6,       1,         127,        KEY_EN_LEFT_FUNCTION,       KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Fuction
+        {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
+        {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
+        {   0,      6,      10,         136,        KEY_EN_RIGHT_FUNCTION,      KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Fuction
+        {   0,      6,      10,         136,        KEY_EN_RIGHT_WINDOWS,       KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Win Key
+
+        {   0,      1,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },
+        {   0,      1,      15,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
+        {   0,      1,      15,          38,        KEY_EN_DELETE,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Delete key
+        {   0,      1,      17,          40,        KEY_EN_PRINT_SCREEN,        KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Print Screen key
+        {   0,      1,      18,          41,        KEY_EN_HOME,                KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Home key
+        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      3,      13,          76,        KEY_EN_ANSI_BACK_SLASH,     KEYBOARD_OPCODE_SWAP_ONLY,          }, // Force ANSI | even on ISO layouts
+        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      5,      12,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // gap before arrow up key
+        {   0,      5,      13,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
+
+        {   0,      6,      11,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // 1 empty key before arrow keys
+        {   0,      6,      15,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
+        {   0,      6,      16,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // 1 empty key between numpad 0 and .
+
+        // Close numpad gap completely
+        {   0,      1,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      5,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      6,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+
+        // Move Arrow keys
+        {   0,      5,      13,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Remove Arrow Up
+        {   0,      6,      13,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Remove Arrow Down
+        {   0,      6,      12,         139,        KEY_EN_UP_ARROW,            KEYBOARD_OPCODE_SWAP_ONLY,          },  // Shift Arrow Up
+        {   0,      7,      11,         159,        KEY_EN_LEFT_ARROW,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      7,      12,         160,        KEY_EN_DOWN_ARROW,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      7,      13,         161,        KEY_EN_RIGHT_ARROW,         KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+    }
+};
+
+keyboard_keymap_overlay_values g713rw_lightbar_layout
+{
+    KEYBOARD_SIZE_EMPTY,
+    {
+        {   /* Values not set in empty keyboard */   },
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       0,         174,        "Lightbar L1",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
+        {   0,      0,       1,         173,        "Lightbar L2",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
+        {   0,      0,       2,         172,        "Lightbar L3",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L3
+        {   0,      0,       3,         171,        "Lightbar R3",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R3
+        {   0,      0,       4,         170,        "Lightbar R2",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
+        {   0,      0,       5,         169,        "Lightbar R1",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R1
+    }
+};
+
+keyboard_keymap_overlay_values g814jv_keyboard_layout
+{
+    KEYBOARD_SIZE_FULL,
+    {
+        aura_core_laptop_18_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+     /*---------------------------------------------------------------------------------------------------------*\
+    | Edit Keys                                                                                                 |
+    |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+    \*---------------------------------------------------------------------------------------------------------*/
+     {   0,      0,       2,           2,        KEY_EN_MEDIA_VOLUME_DOWN,   KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Row and add Volume Down
+     {   0,      0,       3,           3,        KEY_EN_MEDIA_VOLUME_UP,     KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Volume Up
+     {   0,      0,       4,           4,        KEY_EN_MEDIA_MUTE,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute
+     {   0,      0,       5,           5,        "Key: Fan",                 KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "Fan" key
+     {   0,      0,       6,           6,        "Key: ROG",                 KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "ROG" key
+     {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
+     {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
+     {   0,      6,       1,         127,        KEY_EN_LEFT_FUNCTION,       KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Fuction
+     {   0,      6,      11,         136,        KEY_EN_PRINT_SCREEN,        KEYBOARD_OPCODE_SWAP_ONLY,          },  // Replace Right Fuction with PrtSc
+     {   0,      6,      12,         136,        KEY_EN_RIGHT_WINDOWS,       KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Win Key
+     {   0,      1,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      1,      14,          38,        KEY_EN_DELETE,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Insert a Delete key
+     {   0,      1,      16,          40,        KEY_EN_PRINT_SCREEN,        KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Print Screen key
+     {   0,      1,      17,          41,        KEY_EN_HOME,                KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Home key
+     {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      3,      13,          76,        KEY_EN_ANSI_BACK_SLASH,     KEYBOARD_OPCODE_SWAP_ONLY,          }, // Force ANSI | even on ISO layouts
+     {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  }, // Numpad gap
+     {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      5,      12,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      5,      13,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      5,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      6,      15,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     }
+};
+
+keyboard_keymap_overlay_values g814jv_lightbar_layout
+{
+    KEYBOARD_SIZE_EMPTY,
+    {
+        {   /* Values not set in empty keyboard */   },
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       0,         173,        "Lightbar L1",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
+        {   0,      0,       1,         172,        "Lightbar L2",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
+        {   0,      0,       2,         170,        "Lightbar R2",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
+        {   0,      0,       3,         169,        "Lightbar R1",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
+    }
+};
+
+
+/*-------------------------------------------------------------------------*\
+|  AURA CORE LAPTOP DEVICES                                                 |
+\*-------------------------------------------------------------------------*/
+
+/*-------------------------------------------------------------*\
+|  ASUS ROG Strix SCAR 15                                       |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       7 Rows, 16 Columns                                      |
+\*-------------------------------------------------------------*/
+static const aura_core_laptop_zone g533zm_zone =
+{
+    ZONE_EN_KEYBOARD,
+    &g533zm_layout
+};
+
+static const aura_core_laptop_device g533zm_device =
+{
+    "G533ZM",
+    {
+        &g533zm_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    }
+};
+
+/*-------------------------------------------------------------*\
+|  ASUS ROG Strix SCAR G713RW                                   |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       7 Rows, 20 Columns                                      |
+\*-------------------------------------------------------------*/
+static const aura_core_laptop_zone g713rw_keyboard_zone =
+{
+    ZONE_EN_KEYBOARD,
+    &g713rw_keyboard_layout
+};
+
+static const aura_core_laptop_zone g713rw_lightbar_zone =
+{
+    "Lightbar",
+    &g713rw_lightbar_layout
+};
+
+static const aura_core_laptop_device g713rw_device =
+{
+    "G713RW",
+    {
+        &g713rw_keyboard_zone,
+        &g713rw_lightbar_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    }
+};
+/*-------------------------------------------------------------*\
+|  ASUS ROG Strix G18 (G814JV)                                  |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       7 Rows, 16 Columns                                      |
+\*-------------------------------------------------------------*/
+
+static const aura_core_laptop_zone g814rw_keyboard_zone =
+{
+    ZONE_EN_KEYBOARD,
+    &g814jv_keyboard_layout
+};
+
+static const aura_core_laptop_zone g814jv_lightbar_zone =
+{
+    "Lightbar",
+    &g814jv_lightbar_layout
+};
+
+static const aura_core_laptop_device g814jv_device =
+{
+    "G814JV",
+    {
+        &g814rw_keyboard_zone,
+        &g814jv_lightbar_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    }
+};
+
+/*-------------------------------------------------------------------------*\
+|  DEVICE MASTER LIST                                                       |
+\*-------------------------------------------------------------------------*/
+const aura_core_laptop_device* aura_core_laptop_device_list_data[] =
+{
+/*-----------------------------------------------------------------*\
+|  KEYBOARDS                                                        |
+\*-----------------------------------------------------------------*/
+    &g533zm_device,
+    &g713rw_device,
+    &g814jv_device,
+};
+
+const unsigned int AURA_CORE_LAPTOP_DEVICE_COUNT = (sizeof(aura_core_laptop_device_list_data) / sizeof(aura_core_laptop_device_list_data[ 0 ]));
+const aura_core_laptop_device** aura_core_laptop_device_list = aura_core_laptop_device_list_data;
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include "RGBController.h"
+#include "RGBControllerKeyNames.h"
+#include "KeyboardLayoutManager.h"
+
+#define AURA_CORE_LAPTOP_ZONES_MAX      6
+
+enum aura_core_kb_layout
+{
+    AURA_CORE_LAPTOP_KB_LAYOUT_ANSI     = 0x01,     /* US ANSI Layout                   */
+    AURA_CORE_LAPTOP_KB_LAYOUT_ISO      = 0x02,     /* EURO ISO Layout                  */
+    AURA_CORE_LAPTOP_KB_LAYOUT_ABNT     = 0x03,     /* Brazilian Layout                 */
+    AURA_CORE_LAPTOP_KB_LAYOUT_JIS      = 0x04,     /* Japanese Layout                  */
+};
+
+typedef struct
+{
+    std::string                         name;
+    keyboard_keymap_overlay_values*     layout_new;
+}   aura_core_laptop_zone;
+
+typedef struct
+{
+    uint8_t                             zone;
+    uint8_t                             row;
+    uint8_t                             col;
+    uint8_t                             index;
+    const char*                         name;
+}   aura_core_laptop_led;
+
+typedef struct
+{
+    std::string                         dmi_name;
+    const aura_core_laptop_zone*        zones[AURA_CORE_LAPTOP_ZONES_MAX];
+}   aura_core_laptop_device;
+
+/*-----------------------------------------------------*\
+| Aura Core Laptop Protocol Keyboards                   |
+\*-----------------------------------------------------*/
+#define AURA_STRIX_SCAR_15_PID                      0x19B6
+
+/*-----------------------------------------------------*\
+| These constant values are defined in                  |
+| AsusAuraCoreLaptopDevices.cpp                         |
+\*-----------------------------------------------------*/
+extern const unsigned int AURA_CORE_LAPTOP_DEVICE_COUNT;
+extern const aura_core_laptop_device** aura_core_laptop_device_list;
@@ -11,129 +11,6 @@

 #include "RGBController_AsusAuraCoreLaptop.h"

-static unsigned int matrix_map[ASUSAURACORELAPTOP_KEY_HEIGHT][ASUSAURACORELAPTOP_KEY_WIDTH] =
-{
-    {  NA,  NA,  86,  87,  88,  89,  90,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
-    {   0,  NA,   1,   2,   3,   4,  NA,   5,   6,   7,   8,  NA,   9,  10,  11,  12,  13,  NA },
-    {  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  NA },
-    {  31,  NA,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  NA,  45,  NA },
-    {  46,  NA,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  NA,  58,  NA,  59,  NA },
-    {  60,  NA,  61,  62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  NA,  72,  NA,  73,  NA },
-    {  74,  75,  76,  77,  NA,  NA,  NA,  78,  NA,  NA,  NA,  79,  80,  81,  82,  83,  84,  85 }
-};
-
-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,                 //10
-    KEY_EN_F11,
-    KEY_EN_F12,
-    KEY_EN_DELETE,
-
-    KEY_EN_BACK_TICK,
-    KEY_EN_1,
-    KEY_EN_2,
-    KEY_EN_3,
-    KEY_EN_4,
-    KEY_EN_5,
-    KEY_EN_6,                   //20
-    KEY_EN_7,
-    KEY_EN_8,
-    KEY_EN_9,
-    KEY_EN_0,
-    KEY_EN_MINUS,
-    KEY_EN_EQUALS,
-    KEY_EN_BACKSPACE,
-    KEY_EN_BACKSPACE,
-    KEY_EN_BACKSPACE,
-    KEY_EN_MEDIA_PLAY_PAUSE,    //30
-
-    KEY_EN_TAB,
-    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,                   //40
-    KEY_EN_P,
-    KEY_EN_LEFT_BRACKET,
-    KEY_EN_RIGHT_BRACKET,
-    KEY_EN_ANSI_BACK_SLASH,
-    KEY_EN_MEDIA_STOP,
-
-    KEY_EN_CAPS_LOCK,
-    KEY_EN_A,
-    KEY_EN_S,
-    KEY_EN_D,
-    KEY_EN_F,                   //50
-    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_MEDIA_PREVIOUS,
-
-    KEY_EN_LEFT_SHIFT,          //60
-    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,       //70
-    KEY_EN_RIGHT_SHIFT,
-    KEY_EN_UP_ARROW,
-    KEY_EN_MEDIA_NEXT,
-
-    KEY_EN_LEFT_CONTROL,
-    KEY_EN_LEFT_FUNCTION,
-    KEY_EN_LEFT_WINDOWS,
-    KEY_EN_LEFT_ALT,
-    KEY_EN_SPACE,
-    KEY_EN_RIGHT_ALT,
-    KEY_EN_RIGHT_CONTROL,       //80
-    KEY_EN_LEFT_ARROW,
-    KEY_EN_DOWN_ARROW,
-    KEY_EN_RIGHT_ARROW,
-    KEY_EN_PRINT_SCREEN,
-    "Asus Keystone",
-
-    KEY_EN_MEDIA_VOLUME_DOWN,
-    KEY_EN_MEDIA_VOLUME_UP,
-    "Key: Mic On/Off",
-    "Key: HyperFan",
-    "Key: Armoury Crate",       //90
-
-    "Lightbar LED 1",
-    "Lightbar LED 2",
-    "Lightbar LED 3",
-    "Lightbar LED 4",
-    "Lightbar LED 5",
-    "Lightbar LED 6",
-
-    "Logo",
-    "Lid Left",
-    "Lid Right",                //99
-};
-
 /**------------------------------------------------------------------*\
    @name AsusAuraCoreLaptop
    @category DEVICE_TYPE_KEYBOARD
@@ -150,18 +27,24 @@ static const char *led_names[] =
        * Awake (Normal Usage)
        * Sleeping
        * Shutdown / Power Off
+
+        MatrixMaps can be found in ArmouryCrate (it needs a chance to download device data)
+        Default path is:
+            C:\ProgramData\ASUS\ROG Live Service\DeviceContent\<Model name>\<Model name>.csv
+        (Model name is the code like G814JV - can be found in the error in logs)
 \*-------------------------------------------------------------------*/

 RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController *controller_ptr)
 {
-    controller                  = controller_ptr;
+    controller                              = controller_ptr;
+    const aura_core_laptop_device* aura_dev = controller->GetDeviceData();

-    name                        = "Asus Aura Core Laptop";
-    vendor                      = "Asus";
-    type                        = DEVICE_TYPE_KEYBOARD;
-    description                 = controller->GetDeviceName();
-    serial                      = controller->GetSerial();
-    location                    = controller->GetLocation();
+    name                                    = aura_dev->dmi_name;
+    vendor                                  = "Asus";
+    type                                    = DEVICE_TYPE_KEYBOARD;
+    description                             = controller->GetDeviceDescription();
+    serial                                  = controller->GetSerial();
+    location                                = controller->GetLocation();

    mode Direct;
    Direct.name                 = "Direct";
@@ -375,8 +258,9 @@ RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreL
    Off.color_mode              = MODE_COLORS_NONE;
    modes.push_back(Off);

-    Init_Controller();
    SetupZones();
+
+    SetMode(active_mode);
 }

 RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
@@ -384,70 +268,131 @@ RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
    delete controller;
 }

-void RGBController_AsusAuraCoreLaptop::Init_Controller()
-{
-    /*-------------------------------------------------*\
-    | Create the keyboard zone and add the matix map    |
-    \*-------------------------------------------------*/
-    zone KB_zone;
-    KB_zone.name                = "Keyboard Zone";
-    KB_zone.type                = ZONE_TYPE_MATRIX;
-    KB_zone.leds_min            = ASUSAURACORELAPTOP_KEYCOUNT;
-    KB_zone.leds_max            = ASUSAURACORELAPTOP_KEYCOUNT;
-    KB_zone.leds_count          = ASUSAURACORELAPTOP_KEYCOUNT;
-
-    KB_zone.matrix_map          = new matrix_map_type;
-    KB_zone.matrix_map->height  = ASUSAURACORELAPTOP_KEY_HEIGHT;
-    KB_zone.matrix_map->width   = ASUSAURACORELAPTOP_KEY_WIDTH;
-    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
-    zones.push_back(KB_zone);
-
-    zone lightbar;
-    lightbar.name               = "Lightbar Zone";
-    lightbar.type               = ZONE_TYPE_LINEAR;
-    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;
-    lid.name                    = "Lid Zone";
-    lid.type                    = ZONE_TYPE_LINEAR;
-    lid.leds_min                = ASUSAURACORELAPTOP_LIDCOUNT;
-    lid.leds_max                = ASUSAURACORELAPTOP_LIDCOUNT;
-    lid.leds_count              = ASUSAURACORELAPTOP_LIDCOUNT;
-    lid.matrix_map              = NULL;
-
-    zones.push_back(lid);
-}
-
 void RGBController_AsusAuraCoreLaptop::SetupZones()
 {
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
-    leds.clear();
-    colors.clear();
+    std::string physical_size;
+    KEYBOARD_LAYOUT new_layout;
+    unsigned int max_led_value              = 0;
+
+    const aura_core_laptop_device* aura_dev = controller->GetDeviceData();
+    unsigned int layout                     = controller->GetKeyboardLayout();
+
+    switch(layout)
+    {
+        case ASUSAURACORELAPTOP_LAYOUT_ISO:
+            new_layout = KEYBOARD_LAYOUT_ISO_QWERTY;
+            break;
+
+        case ASUSAURACORELAPTOP_LAYOUT_ANSI:
+        default:
+            new_layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
+            break;
+    }
+    LOG_DEBUG("[%s] layout set as %d", description.c_str(), new_layout);

    /*---------------------------------------------------------*\
-    | Set up zones                                              |
+    | Fill in zones from the device data                        |
    \*---------------------------------------------------------*/
-    for(std::size_t zone_index = 0; zone_index < zones.size(); zone_index++)
+    for(size_t i = 0; i < AURA_CORE_LAPTOP_ZONES_MAX; i++)
    {
-        int zone_offset = (int)leds.size();
+        LOG_DEBUG("[%s] setting up zone %d", description.c_str(), i);

-        for(unsigned int led_index = 0; led_index < zones[zone_index].leds_count; led_index++)
+        if(aura_dev->zones[i] == NULL)
        {
-            led new_led;
-            new_led.value   = led_index + zone_offset;
-            new_led.name    = led_names[new_led.value];
-            leds.push_back(new_led);
+            break;
+        }
+        else
+        {
+            zone new_zone;
+
+            new_zone.name                   = aura_dev->zones[i]->name;
+
+            if(aura_dev->zones[i]->layout_new != NULL)
+            {
+                KeyboardLayoutManager new_kb(new_layout,
+                                             aura_dev->zones[i]->layout_new->base_size,
+                                             aura_dev->zones[i]->layout_new->key_values);
+
+                if(aura_dev->zones[i]->layout_new->base_size != KEYBOARD_SIZE_EMPTY ||
+                   aura_dev->zones[i]->layout_new->edit_keys.size() > 0)
+                {
+                    /*---------------------------------------------------------*\
+                    | Minor adjustments to keyboard layout                      |
+                    \*---------------------------------------------------------*/
+                    keyboard_keymap_overlay_values* temp    = aura_dev->zones[i]->layout_new;
+                    new_kb.ChangeKeys(*temp);
+
+                    if(new_kb.GetRowCount() == 1 || new_kb.GetColumnCount() == 1)
+                    {
+                        if(new_kb.GetKeyCount() == 1)
+                        {
+                            new_zone.type               = ZONE_TYPE_SINGLE;
+                        }
+                        else
+                        {
+                            new_zone.type               = ZONE_TYPE_LINEAR;
+                        }
+                    }
+                    else
+                    {
+                        new_zone.type               = ZONE_TYPE_MATRIX;
+                        matrix_map_type * new_map   = new matrix_map_type;
+                        new_zone.matrix_map         = new_map;
+
+                        /*---------------------------------------------------------*\
+                        | Trusting the layout handed to the KLM is correct use the  |
+                        |   row & column counts to set the matrix height & width    |
+                        \*---------------------------------------------------------*/
+                        new_map->height             = new_kb.GetRowCount();
+                        new_map->width              = new_kb.GetColumnCount();
+                        new_map->map                = new unsigned int[new_map->height * new_map->width];
+
+                        new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT);
+                    }
+
+                    /*---------------------------------------------------------*\
+                    | Create LEDs for the Matrix zone                           |
+                    |   Place keys in the layout to populate the matrix         |
+                    \*---------------------------------------------------------*/
+                    new_zone.leds_count             = new_kb.GetKeyCount();
+                    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);
+                        max_led_value               = std::max(max_led_value, new_led.value);
+                        leds.push_back(new_led);
+                    }
+                }
+
+                /*---------------------------------------------------------*\
+                | Add 1 the max_led_value to account for the 0th index      |
+                \*---------------------------------------------------------*/
+                max_led_value++;
+            }
+
+            LOG_DEBUG("[%s] Creating a %s zone: %s with %d LEDs", name.c_str(),
+                      ((new_zone.type == ZONE_TYPE_MATRIX) ? "matrix": "linear"),
+                      new_zone.name.c_str(), new_zone.leds_count);
+            new_zone.leds_min                   = new_zone.leds_count;
+            new_zone.leds_max                   = new_zone.leds_count;
+            zones.push_back(new_zone);
        }
    }

    SetupColors();
+
+    /*---------------------------------------------------------*\
+    | Create a buffer map of pointers which contains the        |
+    |   layout order of colors the device expects.              |
+    \*---------------------------------------------------------*/
+    buffer_map.resize(max_led_value, &null_color);
+
+    for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        buffer_map[leds[led_idx].value] = &colors[led_idx];
+    }
 }

 void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/)
@@ -459,36 +404,35 @@ void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/

 void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
 {
-    controller->SetLedsDirect(colors);
-}
-
-void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int zone)
-{
-    std::vector<RGBColor> colour;
-    for(size_t i = 0; i < zones[zone].leds_count; i++)
+    for(size_t i = 85; i < leds.size(); i++)
    {
-        colour.push_back(zones[zone].colors[i]);
+        LOG_DEBUG("[%s] Setting %s @ LED index %d and buffer index %d to R: %02X G: %02X B: %02X",
+                  name.c_str(),
+                  leds[i].name.c_str(),
+                  i,
+                  leds[i].value,
+                  RGBGetRValue(colors[i]),
+                  RGBGetGValue(colors[i]),
+                  RGBGetBValue(colors[i]));
    }

-    controller->SetLedsDirect(colour);
+    controller->SetLedsDirect(buffer_map);
 }

-void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int led)
+void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int /*zone*/)
 {
-    std::vector<RGBColor> colour;
-    colour.push_back(colors[led]);
+    controller->SetLedsDirect(buffer_map);
+}

-    controller->SetLedsDirect(colour);
+void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int /*led*/)
+{
+    controller->SetLedsDirect(buffer_map);
 }

 void RGBController_AsusAuraCoreLaptop::DeviceUpdateMode()
 {
    mode set_mode       = modes[active_mode];

-    if(set_mode.value == ASUSAURACORELAPTOP_MODE_DIRECT)
-    {
-        return;
-    }
    uint8_t random      = (set_mode.color_mode == MODE_COLORS_RANDOM) ? 0xFF : 0;
    RGBColor color1     = (set_mode.colors.size() > 0) ? set_mode.colors[0] : 0;
    RGBColor color2     = (set_mode.colors.size() > 1) ? set_mode.colors[1] : 0;
@@ -11,6 +11,7 @@

 #pragma once

+#include <algorithm>
 #include <vector>
 #include "RGBController.h"
 #include "AsusAuraCoreLaptopController.h"
@@ -31,7 +32,8 @@ public:
    void                DeviceUpdateMode();

 private:
-    void                Init_Controller();
+    RGBColor                            null_color              = 0;
+    std::vector<RGBColor *>             buffer_map;

-    AsusAuraCoreLaptopController*      controller;
+    AsusAuraCoreLaptopController*       controller;
 };
@@ -90,6 +90,7 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti Gaming"            , Detec
 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 A4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_A4G_GAMING,         0x2A);
 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);
@@ -131,10 +132,13 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG Vega 64 Strix"                       , Detec
 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 RX 5700 XT Strix 08G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING_05C3,        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 STRIX RX 560 Gaming"                 , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING_04BE,            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);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 590 Gaming"                 , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX590_STRIX_GAMING,                    0x29);
@@ -32,7 +32,7 @@ int RGBController_AuraGPU::GetDeviceMode()
        break;
    }

-    for(int mode = 0; mode < modes.size(); mode++)
+    for(unsigned int mode = 0; mode < modes.size(); mode++)
    {
        if(modes[mode].value == dev_mode)
        {
@@ -11,6 +11,7 @@

 #include <cstring>
 #include "AsusAuraHeadsetStandController.h"
+#include "StringUtils.h"

 AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path)
 {
@@ -38,10 +39,7 @@ std::string AuraHeadsetStandController::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 std::string AuraHeadsetStandController::GetVersion()
@@ -11,7 +11,7 @@

 #pragma once

-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 enum
@@ -11,6 +11,7 @@

 #include <cstring>
 #include "AsusAuraKeyboardController.h"
+#include "StringUtils.h"

 AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path)
 {
@@ -38,10 +39,7 @@ std::string AuraKeyboardController::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 void AuraKeyboardController::SendDirect
@@ -13,7 +13,7 @@

 #include <string>
 #include <vector>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 class AuraKeyboardController
@@ -12,6 +12,7 @@
 #include <cstring>
 #include "AsusAuraMonitorController.h"
 #include "LogManager.h"
+#include "StringUtils.h"

 AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid)
 {
@@ -40,10 +41,7 @@ std::string AuraMonitorController::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 void AuraMonitorController::BeginUpdate()
@@ -11,7 +11,7 @@

 #pragma once

-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 enum
@@ -13,7 +13,7 @@

 /**------------------------------------------------------------------*\
    @name Asus Aura Monitor
-    @category LEDStrip
+    @category Accessory
    @type USB
    @save :x:
    @direct :white_check_mark:
@@ -28,7 +28,7 @@ RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* cont

    name        = "ASUS Aura Monitor";
    vendor      = "ASUS";
-    type        = DEVICE_TYPE_LEDSTRIP;
+    type        = DEVICE_TYPE_ACCESSORY;
    description = "ASUS Aura Monitor Device";
    location    = controller->GetDeviceLocation();
    serial      = controller->GetSerialString();
@@ -11,6 +11,7 @@

 #include <cstring>
 #include "AsusAuraMouseController.h"
+#include "StringUtils.h"

 AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid)
 {
@@ -65,10 +66,7 @@ std::string AuraMouseController::GetSerialString()
        return("");
    }

-    std::wstring serial_wstring = serial_string;
-    std::string return_string = CleanSerial(serial_wstring);
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 std::string AuraMouseController::GetVersion(bool wireless, int protocol)
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"
 #include "AsusAuraMouseDevices.h"

@@ -55,6 +55,7 @@
 #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_M3_GEN_II_PID                          0x1A9B
 #define AURA_TUF_M5_PID                                 0x1898

 #define AURA_ROG_SPATHA_X_DOCK_FAKE_PID                 0xFFFF
@@ -636,6 +637,20 @@ static std::map<int,mouse_type> aura_mouse_devices =
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
    },
+    {
+        AURA_TUF_M3_GEN_II_PID, // TUF M3 Gen II
+        {
+            0,
+            0,
+            0,
+            100,
+            false,
+            1,
+            false,
+            { AURA_MOUSE_ZONE_LOGO },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
+        }
+    },
    {
        AURA_TUF_M5_PID, // TUF M5
        {
@@ -13,6 +13,7 @@
 #include <chrono>
 #include <thread>
 #include "AsusAuraMouseGen1Controller.h"
+#include "StringUtils.h"

 AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid)
 {
@@ -41,10 +42,7 @@ std::string AsusAuraMouseGen1Controller::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 std::string AsusAuraMouseGen1Controller::GetVersion()
@@ -13,7 +13,7 @@

 #include <string>
 #include <vector>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 #define HID_MAX_STR 255
@@ -221,7 +221,7 @@ void RGBController_AsusROGSpatha::DeviceUpdateMode()

        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++)
+            for(unsigned 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]));
@@ -255,7 +255,7 @@ void RGBController_AsusROGSpatha::DeviceSaveMode()

        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++)
+            for(unsigned 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]));
@@ -1,14 +1,17 @@
-/*-----------------------------------------*\
-|  AsusAuraMousematController.cpp           |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/10/2022   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusAuraMousematController.cpp                            |
+|                                                           |
+|   Driver for ASUS Aura mousemat                           |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                10 Jan 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

-#include "AsusAuraMousematController.h"
 #include <cstring>
+#include "AsusAuraMousematController.h"
+#include "StringUtils.h"

 AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path)
 {
@@ -36,10 +39,7 @@ std::string AuraMousematController::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 std::string AuraMousematController::GetVersion()
@@ -1,17 +1,18 @@
-/*-----------------------------------------*\
-|  AsusAuraMousematController.h             |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/10/2022   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
+/*---------------------------------------------------------*\
+| AsusAuraMousematController.h                              |
+|                                                           |
+|   Driver for ASUS Aura mousemat                           |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                10 Jan 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once

+#include <hidapi.h>
+#include "RGBController.h"

 enum
 {
@@ -1,11 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMousemat.cpp       |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/10/2022   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraMousemat.cpp                        |
+|                                                           |
+|   RGBController for ASUS Aura mousemat                    |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                10 Jan 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #include "RGBController_AsusAuraMousemat.h"

@@ -1,13 +1,16 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMousemat.h         |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 06/04/2021                        |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraMousemat.h                          |
+|                                                           |
+|   RGBController for ASUS Aura mousemat                    |
+|                                                           |
+|   Mola19                                      06 Apr 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once
+
 #include "RGBController.h"
 #include "AsusAuraMousematController.h"

@@ -1,28 +1,32 @@
-/*-------------------------------------------------------------------*\
-|  AsusAuraRyuoAIOController.cpp                                      |
-|                                                                     |
-|  Driver for the ASUS Aura Ryuo AIO                                  |
-|    lighting controller                                              |
-|                                                                     |
-|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
-|  using snipets from Chris M (Dr.No)                                 |
-\*-------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusAuraRyuoAIOController.cpp                             |
+|                                                           |
+|   Driver for ASUS Aura Ryuo                               |
+|                                                           |
+|   Cooper Hall (geobot19 / Geo_bot)            08 Apr 2022 |
+|   using snipets from Chris M (Dr.No)                      |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #include "AsusAuraRyuoAIOController.h"

 AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
 {
-	/*-----------------------------------------------------*\
-	| Add addressable devices                               |
-	|    Manually adding device info for now                |
-	|    TODO: Implement config table accurately            |
-	\*-----------------------------------------------------*/
-	device_info.push_back({0x00, 0x00, 12, 0, AuraDeviceType::FIXED});
+    /*-----------------------------------------------------*\
+    | Add addressable devices                               |
+    |    Manually adding device info for now                |
+    |    TODO: Implement config table accurately            |
+    \*-----------------------------------------------------*/
+    device_info.push_back({0x00, 0x00, 12, 0, AuraDeviceType::FIXED});
 }

 AsusAuraRyuoAIOController::~AsusAuraRyuoAIOController()
 {
-	hid_close(dev);
+    /*---------------------------------------------------------*\
+    | HID device is closed in the base class                    |
+    \*---------------------------------------------------------*/
 }

 std::string AsusAuraRyuoAIOController::GetLocation()
@@ -32,10 +36,10 @@ std::string AsusAuraRyuoAIOController::GetLocation()

 void AsusAuraRyuoAIOController::SetMode(unsigned char /*channel*/, unsigned char /*mode*/, unsigned char /*red*/, unsigned char /*grn*/, unsigned char /*blu*/)
 {
-	/*---------------------------------------------------------*\
-	| This interface is not used in this controller however is  |
-	|   required by the abstract class                          |
-	\*---------------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | This interface is not used in this controller however is  |
+    |   required by the abstract class                          |
+    \*---------------------------------------------------------*/
 }

 void AsusAuraRyuoAIOController::SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour)
@@ -1,20 +1,22 @@
-/*-------------------------------------------------------------------*\
-|  AsusAuraRyuoAIOController.h                                        |
-|                                                                     |
-|  Driver for the ASUS Aura Ryuo AIO                                  |
-|    lighting controller                                              |
-|                                                                     |
-|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
-|  using snipets from Chris M (Dr.No)                                 |
-\*-------------------------------------------------------------------*/
-
-#include <string>
-#include <hidapi/hidapi.h>
-#include "RGBController.h"
-#include "AsusAuraUSBController.h"
+/*---------------------------------------------------------*\
+| AsusAuraRyuoAIOController.h                               |
+|                                                           |
+|   Driver for ASUS Aura Ryuo                               |
+|                                                           |
+|   Cooper Hall (geobot19 / Geo_bot)            08 Apr 2022 |
+|   using snipets from Chris M (Dr.No)                      |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once

+#include <string>
+#include <hidapi.h>
+#include "RGBController.h"
+#include "AsusAuraUSBController.h"
+
 #define ASUSAURARYUOAIOCONTROLLER_TIMEOUT        250
 #define ASUSAURARYUOAIOCONTROLLER_HID_MAX_STR    255

@@ -1,12 +1,14 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_AsusAuraRyuoAIO.cpp                                  |
-|                                                                     |
-|  Driver for the ASUS Aura Ryuo AIO                                  |
-|    lighting controller                                              |
-|                                                                     |
-|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
-|  using snipets from Chris M (Dr.No)                                 |
-\*-------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraRyuoAIO.cpp                         |
+|                                                           |
+|   RGBController for ASUS Aura Ryuo                        |
+|                                                           |
+|   Cooper Hall (geobot19 / Geo_bot)            08 Apr 2022 |
+|   using snipets from Chris M (Dr.No)                      |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #include "RGBControllerKeyNames.h"
 #include "RGBController_AsusAuraRyuoAIO.h"
@@ -178,7 +180,7 @@ void RGBController_AsusAuraRyuoAIO::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_AsusAuraRyuoAIO::DeviceUpdateLEDs()
 {
-    for(int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
    {
        UpdateZoneLEDs(zone_idx);
    }
@@ -203,7 +205,7 @@ void RGBController_AsusAuraRyuoAIO::DeviceUpdateMode()

 int RGBController_AsusAuraRyuoAIO::GetLED_Zone(int led_idx)
 {
-    for(int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
    {
        int zone_start = zones[zone_idx].start_idx;
        int zone_end = zone_start + zones[zone_idx].leds_count - 1;
@@ -1,18 +1,21 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_AsusAuraRyuoAIO.h                                    |
-|                                                                     |
-|  Driver for the ASUS Aura Ryuo AIO                                  |
-|    lighting controller                                              |
-|                                                                     |
-|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
-|  using snipets from Chris M (Dr.No)                                 |
-\*-------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraRyuoAIO.h                           |
+|                                                           |
+|   RGBController for ASUS Aura Ryuo                        |
+|                                                           |
+|   Cooper Hall (geobot19 / Geo_bot)            08 Apr 2022 |
+|   using snipets from Chris M (Dr.No)                      |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once
+
+#include <vector>
 #include "LogManager.h"
 #include "RGBController.h"
 #include "AsusAuraRyuoAIOController.h"
-#include <vector>

 class RGBController_AsusAuraRyuoAIO : public RGBController
 {
@@ -1,21 +1,23 @@
-/*-----------------------------------------*\
-|  AsusAuraTUFKeyboardController.cpp        |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Mola19 03/03/2021                        |
-\*-----------------------------------------*/
-
-#include "AsusAuraTUFKeyboardController.h"
+/*---------------------------------------------------------*\
+| AsusAuraTUFKeyboardController.cpp                         |
+|                                                           |
+|   Driver for ASUS Aura TUF keyboard                       |
+|                                                           |
+|   Mola19                                      03 Mar 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

+#include <cmath>
 #include <cstring>
-#include <string>
-#include <vector>
 #include <math.h>
+#include <string>
 #include <stdio.h>
 #include <string.h>
-#include <cmath>
+#include <vector>
+#include "AsusAuraTUFKeyboardController.h"
+#include "StringUtils.h"

 AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version)
 {
@@ -69,10 +71,7 @@ std::string AuraTUFKeyboardController::GetSerialString()
        return("");
    }

-    std::wstring serial_wstring = serial_string;
-    std::string return_string = clean_serial(serial_wstring);
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 std::string AuraTUFKeyboardController::GetVersion()
@@ -1,20 +1,21 @@
-/*-----------------------------------------*\
-|  AsusAuraTUFKeyboardController.h          |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Mola19 03/03/2021                        |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusAuraTUFKeyboardController.h                           |
+|                                                           |
+|   Driver for ASUS Aura TUF keyboard                       |
+|                                                           |
+|   Mola19                                      03 Mar 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

-#include "RGBController.h"
-#include "AsusAuraTUFKeyboardLayouts.h"
+#pragma once

 #include <string>
 #include <vector>
-#include <hidapi/hidapi.h>
-
-#pragma once
+#include <hidapi.h>
+#include "RGBController.h"
+#include "AsusAuraTUFKeyboardLayouts.h"

 enum
 {
@@ -1,19 +1,21 @@
-/*-----------------------------------------*\
-|  AsusAuraTUFKeyboardController.h          |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Mola19 10/02/2021                        |
-\*-----------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include <vector>
-#include <map>
-#include "RGBController.h"
+/*---------------------------------------------------------*\
+| AsusAuraTUFKeyboardLayouts.h                              |
+|                                                           |
+|   Layouts for ASUS Aura TUF keyboard                      |
+|                                                           |
+|   Mola19                                      02 Nov 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once

+#include <map>
+#include <vector>
+#include "RGBControllerKeyNames.h"
+#include "RGBController.h"
+
 enum
 {
    ASUS_TUF_K7_LAYOUT_CA    = 1,
@@ -1,15 +1,17 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraTUFKeyboard.cpp    |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 03/03/2020                        |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraTUFKeyboard.cpp                     |
+|                                                           |
+|   RGBController for ASUS Aura TUF keyboard                |
+|                                                           |
+|   Mola19                                      03 Mar 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

-#include "RGBController_AsusAuraTUFKeyboard.h"
-#include <vector>
 #include <cmath>
+#include <vector>
+#include "RGBController_AsusAuraTUFKeyboard.h"

 /**------------------------------------------------------------------*\
    @name Asus Aura TUF Keyboard
@@ -138,7 +140,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
        Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
        Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
        if(controller->is_per_led_keyboard) Wave.flags |= MODE_FLAG_HAS_DIRECTION_UD;
-        
+
        Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
        Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
        Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
@@ -1,13 +1,16 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraTUFKeyboard.h      |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 03/03/2021                        |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraTUFKeyboard.h                       |
+|                                                           |
+|   RGBController for ASUS Aura TUF keyboard                |
+|                                                           |
+|   Mola19                                      03 Mar 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once
+
 #include "RGBController.h"
 #include "AsusAuraTUFKeyboardController.h"

@@ -1,14 +1,16 @@
-/*-----------------------------------------*\
-|  AsusAuraAddressableController.cpp        |
-|                                           |
-|  Driver for ASUS Aura RGB Addressable     |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusAuraAddressableController.cpp                         |
+|                                                           |
+|   Driver for ASUS Aura addressable controller             |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                18 Jan 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

-#include "AsusAuraAddressableController.h"
 #include <cstring>
+#include "AsusAuraAddressableController.h"

 AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
 {
@@ -1,20 +1,21 @@
-/*-----------------------------------------*\
-|  AsusAuraAddressableController.h          |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  Addressable RGB lighting controller      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "AsusAuraUSBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
+/*---------------------------------------------------------*\
+| AsusAuraAddressableController.h                           |
+|                                                           |
+|   Driver for ASUS Aura addressable controller             |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                18 Jan 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once

+#include <string>
+#include <hidapi.h>
+#include "RGBController.h"
+#include "AsusAuraUSBController.h"
+
 enum
 {
    AURA_ADDRESSABLE_CONTROL_MODE_EFFECT            = 0x3B,     /* Effect control mode                  */
@@ -1,14 +1,16 @@
-/*-----------------------------------------*\
-|  AsusAuraMainboardController.cpp          |
-|                                           |
-|  Driver for ASUS Aura RGB USB mainboard   |
-|  lighting controller                      |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusAuraMainboardController.cpp                           |
+|                                                           |
+|   Driver for ASUS Aura mainboard                          |
+|                                                           |
+|   Martin Hartl (inlart)                       25 Apr 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

-#include "AsusAuraMainboardController.h"
 #include <cstring>
+#include "AsusAuraMainboardController.h"

 AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path), mode(AURA_MODE_DIRECT)
 {
@@ -37,6 +39,7 @@ AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const c
    for(int i = 0; i < num_addressable_headers; i++)
    {
        device_info.push_back({effect_channel, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
+        effect_channel++;
    }
 }

@@ -1,20 +1,21 @@
-/*-----------------------------------------*\
-|  AsusAuraMainboardController.h            |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB Mainboard RGB lighting controller    |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "AsusAuraUSBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
+/*---------------------------------------------------------*\
+| AsusAuraMainboardController.h                             |
+|                                                           |
+|   Driver for ASUS Aura mainboard                          |
+|                                                           |
+|   Martin Hartl (inlart)                       25 Apr 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once

+#include <string>
+#include <hidapi.h>
+#include "RGBController.h"
+#include "AsusAuraUSBController.h"
+
 enum
 {
    AURA_MAINBOARD_CONTROL_MODE_EFFECT            = 0x35,     /* Effect control mode                  */
@@ -1,16 +1,18 @@
-/*-----------------------------------------*\
-|  AsusAuraUSBController.cpp                |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
-
-#include "AsusAuraUSBController.h"
-#include "LogManager.h"
+/*---------------------------------------------------------*\
+| AsusAuraUSBController.cpp                                 |
+|                                                           |
+|   Driver for ASUS Aura USB device                         |
+|                                                           |
+|   Martin Hartl (inlart)                       25 Apr 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #include <cstring>
+#include "AsusAuraUSBController.h"
+#include "LogManager.h"
+#include "StringUtils.h"

 AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path)
 {
@@ -51,10 +53,7 @@ std::string AuraUSBController::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 const std::vector<AuraDeviceInfo>& AuraUSBController::GetAuraDevices() const
@@ -1,20 +1,21 @@
-/*-----------------------------------------*\
-|  AsusAuraUSBController.h                  |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusAuraUSBController.h                                   |
+|                                                           |
+|   Driver for ASUS Aura USB device                         |
+|                                                           |
+|   Martin Hartl (inlart)                       25 Apr 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

-#include "RGBController.h"
-#include "LogManager.h"
+#pragma once

 #include <string>
 #include <vector>
-#include <hidapi/hidapi.h>
-
-#pragma once
+#include <hidapi.h>
+#include "RGBController.h"
+#include "LogManager.h"

 enum
 {
@@ -104,7 +105,6 @@ protected:
        );
 private:
    char                        device_name[16];
-    unsigned int                led_count;

    void GetConfigTable();

@@ -1,13 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMainboard.cpp      |
-|                                           |
-|  RGB controller for Asus Aura USB         |
-|  mainboards                               |
-|                                           |
-|  rytypete 8/30/2023                       |
-|  based on RGBController_AsusAuraUSB.cpp   |
-|  code                                     |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraMainboard.cpp                       |
+|                                                           |
+|   RGBController for ASUS Aura mainboard                   |
+|                                                           |
+|   rytypete                                    30 Aug 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #include "RGBController_AsusAuraMainboard.h"

@@ -1,15 +1,16 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMainboard.h        |
-|                                           |
-|  RGB controller for Asus Aura USB         |
-|  mainboards                               |
-|                                           |
-|  rytypete 8/30/2023                       |
-|  based on RGBController_AsusAuraUSB.h     |
-|  code                                     |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraMainboard.h                         |
+|                                                           |
+|   RGBController for ASUS Aura mainboard                   |
+|                                                           |
+|   rytypete                                    30 Aug 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once
+
 #include "RGBController_AsusAuraUSB.h"
 #include "AsusAuraMainboardController.h"

@@ -1,11 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraUSB.cpp            |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraUSB.cpp                             |
+|                                                           |
+|   RGBController for ASUS Aura USB device                  |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                18 Jan 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #include "RGBController_AsusAuraUSB.h"

@@ -1,13 +1,16 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraUSB.h              |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraUSB.h                               |
+|                                                           |
+|   RGBController for ASUS Aura USB device                  |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                18 Jan 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once
+
 #include "RGBController.h"
 #include "AsusAuraUSBController.h"

@@ -1,3 +1,14 @@
+/*---------------------------------------------------------*\
+| AsusAuraUSBControllerDetect.cpp                           |
+|                                                           |
+|   Detector for ASUS Aura USB devices                      |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <stdexcept>
+#include <hidapi.h>
 #include "Detector.h"
 #include "AsusAuraAddressableController.h"
 #include "AsusAuraHeadsetStandController.h"
@@ -25,8 +36,6 @@
 #include "RGBController_AsusROGStrixEvolve.h"
 #include "RGBController_AsusAuraMonitor.h"
 #include "RGBController_AsusAuraRyuoAIO.h"
-#include <stdexcept>
-#include <hidapi/hidapi.h>
 #include "dmiinfo.h"

 #define AURA_USB_VID                                  0x0B05
@@ -406,6 +415,7 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless Bluetooth",
 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 M3 Gen II",                           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_TUF_M3_GEN_II_PID,                           2,  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);
@@ -1,14 +1,17 @@
-/*-----------------------------------------*\
-|  AsusROGAllyController.cpp                |
-|                                           |
-|  Driver for ASUS ROG Ally lighting        |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/12/2023   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusROGAllyController.cpp                                 |
+|                                                           |
+|   Driver for ASUS ROG Ally                                |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                12 Jul 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

-#include "AsusROGAllyController.h"
 #include <cstring>
+#include "AsusROGAllyController.h"
+#include "StringUtils.h"

 ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path)
 {
@@ -38,10 +41,7 @@ std::string ROGAllyController::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 std::string ROGAllyController::GetVersion()
@@ -57,7 +57,7 @@ void ROGAllyController::SendInitialization()

    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));
@@ -77,7 +77,7 @@ void ROGAllyController::SendInitialization()
    usb_buf[0x0C]   = 0x6E;
    usb_buf[0x0D]   = 0x63;
    usb_buf[0x0E]   = 0x2E;
-    
+
    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
 }

@@ -175,4 +175,3 @@ void ROGAllyController::SaveMode()

    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
 }
-
@@ -1,17 +1,19 @@
-/*-----------------------------------------*\
-|  AsusROGAllyController.h                  |
-|                                           |
-|  Definitions and types for ASUS ROG Ally  |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/12/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
+/*---------------------------------------------------------*\
+| AsusROGAllyController.h                                   |
+|                                                           |
+|   Driver for ASUS ROG Ally                                |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                12 Jul 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once

+#include <hidapi.h>
+#include "RGBController.h"
+
 enum
 {
    ROG_ALLY_MODE_STATIC           = 0,
@@ -46,7 +48,7 @@ public:
    std::string GetVersion();

    void SendInitialization();
-    
+
    void UpdateBrightness
        (
            unsigned char           brightness
@@ -1,11 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AsusROGAlly.cpp            |
-|                                           |
-|  Generic RGB Interface for Asus ROG Ally  |
-|  controller driver                        |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/12/2023   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusROGAlly.cpp                             |
+|                                                           |
+|   RGBController for ASUS ROG Ally                         |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                12 Jul 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #include "RGBController_AsusROGAlly.h"

@@ -1,11 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AsusROGAlly.cpp            |
-|                                           |
-|  Generic RGB Interface for Asus ROG Ally  |
-|  controller driver                        |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/12/2023   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusROGAlly.h                               |
+|                                                           |
+|   RGBController for ASUS ROG Ally                         |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                12 Jul 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once

@@ -1,12 +1,13 @@
-/*-------------------------------------------------------------------*\
-|  AsusROGStrixLCController.cpp                                       |
-|                                                                     |
-|  Driver for the ASUS Aura Liquid Cooler (LC) series                 |
-|    of lighting controllers                                          |
-|                                                                     |
-|  Chris M (Dr_No)          17 Jan 2022                               |
-|                                                                     |
-\*-------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusROGStrixLCController.cpp                              |
+|                                                           |
+|   Driver for ASUS Aura liquid cooler                      |
+|                                                           |
+|   Chris M (Dr_No)                             17 Jan 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #include "AsusROGStrixLCController.h"

@@ -1,20 +1,21 @@
-/*-------------------------------------------------------------------*\
-|  AsusROGStrixLCController.h                                         |
-|                                                                     |
-|  Driver for the ASUS Aura Liquid Cooler (LC) series                 |
-|    of lighting controllers                                          |
-|                                                                     |
-|  Chris M (Dr_No)          17 Jan 2022                               |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include <string>
-#include <hidapi/hidapi.h>
-#include "RGBController.h"
-#include "AsusAuraUSBController.h"
+/*---------------------------------------------------------*\
+| AsusROGStrixLCController.h                                |
+|                                                           |
+|   Driver for ASUS Aura liquid cooler                      |
+|                                                           |
+|   Chris M (Dr_No)                             17 Jan 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once

+#include <string>
+#include <hidapi.h>
+#include "RGBController.h"
+#include "AsusAuraUSBController.h"
+
 #define ROGSTRIXLC_CONTROLLER_TIMEOUT 250
 #define HID_MAX_STR 255

@@ -1,12 +1,13 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_AsusROGStrixLC.cpp                                   |
-|                                                                     |
-|  Driver for the ASUS Aura Liquid Cooler (LC) series                 |
-|    of lighting controllers                                          |
-|                                                                     |
-|  Chris M (Dr_No)          17 Jan 2022                               |
-|                                                                     |
-\*-------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusROGStrixLC.cpp                          |
+|                                                           |
+|   RGBController for ASUS Aura liquid cooler               |
+|                                                           |
+|   Chris M (Dr_No)                             17 Jan 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #include "RGBControllerKeyNames.h"
 #include "RGBController_AsusROGStrixLC.h"
@@ -180,7 +181,7 @@ void RGBController_AsusROGStrixLC::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_AsusROGStrixLC::DeviceUpdateLEDs()
 {
-    for(int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
    {
        UpdateZoneLEDs(zone_idx);
    }
@@ -205,7 +206,7 @@ void RGBController_AsusROGStrixLC::DeviceUpdateMode()

 int RGBController_AsusROGStrixLC::GetLED_Zone(int led_idx)
 {
-    for(int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
    {
        int zone_start  = zones[zone_idx].start_idx;
        int zone_end    = zone_start + zones[zone_idx].leds_count - 1;
@@ -1,18 +1,20 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_AsusROGStrixLC.h                                     |
-|                                                                     |
-|  Driver for the ASUS Aura Liquid Cooler (LC) series                 |
-|    of lighting controllers                                          |
-|                                                                     |
-|  Chris M (Dr_No)          17 Jan 2022                               |
-|                                                                     |
-\*-------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusROGStrixLC.h                            |
+|                                                           |
+|   RGBController for ASUS Aura liquid cooler               |
+|                                                           |
+|   Chris M (Dr_No)                             17 Jan 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once
+
+#include <vector>
 #include "LogManager.h"
 #include "RGBController.h"
 #include "AsusROGStrixLCController.h"
-#include <vector>

 class RGBController_AsusROGStrixLC : public RGBController
 {
@@ -1,11 +1,13 @@
-/*-----------------------------------------*\
-|  AsusCerberusKeyboardController.cpp       |
-|                                           |
-|  Driver for ASUS Cerberus USB lighting    |
-|  controller                               |
-|                                           |
-|  Mola19 05/28/2022                        |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusCerberusKeyboardController.cpp                        |
+|                                                           |
+|   Driver for ASUS Cerberus keyboard                       |
+|                                                           |
+|   Mola19                                      28 May 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #include <cmath>
 #include <cstring>
@@ -15,6 +17,7 @@
 #include <string.h>
 #include <vector>
 #include "AsusCerberusKeyboardController.h"
+#include "StringUtils.h"

 #define ASUS_CERBERUS_KB_PACKET_SIZE 8

@@ -45,10 +48,7 @@ std::string AsusCerberusKeyboardController::GetSerialString()
        return("");
    }

-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }

 std::string AsusCerberusKeyboardController::GetVersion()
@@ -1,17 +1,19 @@
-/*-----------------------------------------*\
-|  AsusCerberusKeyboardController.h         |
-|                                           |
-|  Definitions and types for ASUS Cerberus  |
-|  USB RGB lighting controller              |
-|                                           |
-|  Mola19 03/03/2021                        |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusCerberusKeyboardController.h                          |
+|                                                           |
+|   Driver for ASUS Cerberus keyboard                       |
+|                                                           |
+|   Mola19                                      03 Mar 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/

 #pragma once

 #include <string>
 #include <vector>
-#include <hidapi/hidapi.h>
+#include <hidapi.h>
 #include "RGBController.h"

 enum
@@ -25,7 +27,6 @@ enum
    CERBERUS_KEYBOARD_MODE_CUSTOM       = 7,
 };

-
 class AsusCerberusKeyboardController
 {
 public:
--- a/Show More
+++ b/Show More