From 65e7edc452279bbcf8c4e1204b979c63f464aaaa Mon Sep 17 00:00:00 2001 From: Mola19 Date: Wed, 8 Nov 2023 23:22:12 +0000 Subject: [PATCH] add support for Asus ROG Spatha and restructure Asus Strix Evolve --- .../AsusAuraMouseGen1Controller.cpp | 174 +++++++++++ ...roller.h => AsusAuraMouseGen1Controller.h} | 12 +- .../AsusAuraStrixEvolveController.cpp | 146 ---------- .../AsusAuraUSBControllerDetect.cpp | 28 +- .../RGBController_AsusAuraStrixEvolve.h | 40 --- .../RGBController_AsusROGSpatha.cpp | 272 ++++++++++++++++++ .../RGBController_AsusROGSpatha.h | 51 ++++ ...p => RGBController_AsusROGStrixEvolve.cpp} | 92 +++--- .../RGBController_AsusROGStrixEvolve.h | 48 ++++ OpenRGB.pro | 10 +- 10 files changed, 622 insertions(+), 251 deletions(-) create mode 100644 Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.cpp rename Controllers/AsusAuraUSBController/{AsusAuraStrixEvolveController.h => AsusAuraMouseGen1Controller.h} (74%) delete mode 100644 Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.cpp delete mode 100644 Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h create mode 100644 Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.cpp create mode 100644 Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.h rename Controllers/AsusAuraUSBController/{RGBController_AsusAuraStrixEvolve.cpp => RGBController_AsusROGStrixEvolve.cpp} (54%) create mode 100644 Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.h diff --git a/Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.cpp b/Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.cpp new file mode 100644 index 00000000..a6920e14 --- /dev/null +++ b/Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.cpp @@ -0,0 +1,174 @@ +/*-----------------------------------------*\ +| AsusAuraMouseGen1Controller.cpp | +| | +| Driver for ASUS Aura RGB USB | +| lighting controller | +| | +| Mola19 11/30/2021 | +\*-----------------------------------------*/ + +#include "AsusAuraMouseGen1Controller.h" + +#include +#include +#include + +AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid) +{ + dev = dev_handle; + location = path; + device_pid = pid; +} + +AsusAuraMouseGen1Controller::~AsusAuraMouseGen1Controller() +{ + hid_close(dev); +} + +std::string AsusAuraMouseGen1Controller::GetDeviceLocation() +{ + return("HID: " + location); +} + +std::string AsusAuraMouseGen1Controller::GetSerialString() +{ + wchar_t serial_string[HID_MAX_STR]; + int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR); + + if(ret != 0) + { + return(""); + } + + std::wstring return_wstring = serial_string; + std::string return_string(return_wstring.begin(), return_wstring.end()); + + return(return_string); +} + +std::string AsusAuraMouseGen1Controller::GetVersion() +{ + unsigned char usb_buf[9] = { 0x0C, 0xC4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; + usb_buf[3] = (device_pid == 0x1824) ? 0x02 : 0x00; + hid_send_feature_report(dev, usb_buf, 9); + + unsigned char usb_buf_out[9] = { 0x0C }; + hid_get_feature_report(dev, usb_buf_out, 9); + + return std::string("1." + std::to_string(usb_buf_out[3])); +} + +int AsusAuraMouseGen1Controller::GetActiveProfile() +{ + unsigned char profile; + + unsigned char profile_amount = 0; + unsigned char profile_key = 0; + + switch(device_pid) + { + case 0x185B: + profile_amount = 3; + profile_key = 0xF0; + break; + case 0x181C: + case 0x1824: + default: + profile_amount = 6; + profile_key = 0x60; + break; + } + + do + { + unsigned char usb_buf[9] = { 0x0C, 0xDF, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; + hid_send_feature_report(dev, usb_buf, 9); + + unsigned char usb_buf_out[9] = { 0x0C }; + hid_get_feature_report(dev, usb_buf_out, 9); + + profile = usb_buf_out[4]; + } while(profile < profile_key || profile > profile_key + profile_amount - 1); + + return (profile % 16) + 1; +} + +void AsusAuraMouseGen1Controller::SendUpdate + ( + unsigned char key, + unsigned char value + ) +{ + unsigned char usb_buf[9]; + + memset(usb_buf, 0x00, 9); + + usb_buf[0x00] = 0x0C; + usb_buf[0x01] = 0xC4; + usb_buf[0x02] = 0x0F; + usb_buf[0x03] = 0x00; + usb_buf[0x04] = key; + usb_buf[0x05] = value; + hid_send_feature_report(dev, usb_buf, 9); + + unsigned char buf_in[9]; + buf_in[0] = 0x0C; + hid_get_feature_report(dev, buf_in, 9); +} + + +void AsusAuraMouseGen1Controller::UpdateProfile + ( + unsigned char key, + unsigned char profile, + unsigned char value + ) +{ + unsigned char usb_buf[9]; + + memset(usb_buf, 0x00, 9); + + usb_buf[0x00] = 0x0C; + usb_buf[0x01] = 0xDE; + usb_buf[0x02] = key; + usb_buf[0x03] = profile; + usb_buf[0x04] = value; + hid_send_feature_report(dev, usb_buf, 9); + + unsigned char buf_in[9]; + buf_in[0] = 0x0C; + hid_get_feature_report(dev, buf_in, 9); +} + +void AsusAuraMouseGen1Controller::SendDirectSpatha(std::vector colors) +{ + unsigned char usb_buf[33]; + + memset(usb_buf, 0x00, 33); + + usb_buf[0x00] = 0x10; + usb_buf[0x01] = 0x00; + usb_buf[0x02] = 0xF0; + usb_buf[0x03] = 0x00; + + for(unsigned char i = 0; i < 3; i++) + { + usb_buf[4 + i * 3] = RGBGetRValue(colors[i]); + usb_buf[5 + i * 3] = RGBGetGValue(colors[i]); + usb_buf[6 + i * 3] = RGBGetBValue(colors[i]); + } + + hid_send_feature_report(dev, usb_buf, 33); +} + +void AsusAuraMouseGen1Controller::ResetToSavedLighting() +{ + unsigned char usb_buf[9]; + + memset(usb_buf, 0x00, 9); + + usb_buf[0x00] = 0x0C; + usb_buf[0x01] = 0xC4; + + hid_send_feature_report(dev, usb_buf, 9); +} diff --git a/Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.h b/Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.h similarity index 74% rename from Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.h rename to Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.h index ec2f71a7..59eead36 100644 --- a/Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.h +++ b/Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.h @@ -1,5 +1,5 @@ /*-----------------------------------------*\ -| AsusAuraStrixEvolveController.h | +| AsusAuraMouseGen1Controller.h | | | | Definitions and types for ASUS Aura | | USB RGB lighting controller | @@ -10,17 +10,18 @@ #include "RGBController.h" #include +#include #include #pragma once #define HID_MAX_STR 255 -class AuraStrixEvolveController +class AsusAuraMouseGen1Controller { public: - AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid); - virtual ~AuraStrixEvolveController(); + AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid); + virtual ~AsusAuraMouseGen1Controller(); std::string GetDeviceLocation(); std::string GetSerialString(); @@ -39,8 +40,9 @@ public: unsigned char profile, unsigned char value ); + void SendDirectSpatha(std::vector colors); - void SendSavePacket(); + void ResetToSavedLighting(); uint16_t device_pid; diff --git a/Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.cpp b/Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.cpp deleted file mode 100644 index fe3474e1..00000000 --- a/Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.cpp +++ /dev/null @@ -1,146 +0,0 @@ -/*-----------------------------------------*\ -| AsusAuraStrixEvolveController.cpp | -| | -| Driver for ASUS Aura RGB USB | -| lighting controller | -| | -| Mola19 11/30/2021 | -\*-----------------------------------------*/ - -#include "AsusAuraStrixEvolveController.h" - -#include -#include -#include - -AuraStrixEvolveController::AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid) -{ - dev = dev_handle; - location = path; - device_pid = pid; -} - -AuraStrixEvolveController::~AuraStrixEvolveController() -{ - hid_close(dev); -} - -std::string AuraStrixEvolveController::GetDeviceLocation() -{ - return("HID: " + location); -} - -std::string AuraStrixEvolveController::GetSerialString() -{ - wchar_t serial_string[HID_MAX_STR]; - int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR); - - if(ret != 0) - { - return(""); - } - - std::wstring return_wstring = serial_string; - std::string return_string(return_wstring.begin(), return_wstring.end()); - - return(return_string); -} - -std::string AuraStrixEvolveController::GetVersion() -{ - unsigned char usb_buf[9] = { 0x0c, 0xc4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; - hid_send_feature_report(dev, usb_buf, 9); - - unsigned char usb_buf_out[9] = { 0x0c }; - hid_get_feature_report(dev, usb_buf_out, 9); - - return std::string("1." + std::to_string(usb_buf_out[3])); -} - -int AuraStrixEvolveController::GetActiveProfile() -{ - int profile; - - do - { - unsigned char usb_buf[9] = { 0x0c, 0xdf, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; - hid_send_feature_report(dev, usb_buf, 9); - - unsigned char usb_buf_out[9] = { 0x0c }; - hid_get_feature_report(dev, usb_buf_out, 9); - - profile = usb_buf_out[4] % 16; - } while (profile > 2); - - return profile + 1; -} - -void AuraStrixEvolveController::SendUpdate - ( - unsigned char key, - unsigned char value - ) -{ - unsigned char usb_buf[9]; - - /*-----------------------------------------------------*\ - | Zero out buffer | - \*-----------------------------------------------------*/ - memset(usb_buf, 0x00, 9); - - /*-----------------------------------------------------*\ - | Set up message packet | - \*-----------------------------------------------------*/ - usb_buf[0x00] = 0x0c; - usb_buf[0x01] = 0xc4; - usb_buf[0x02] = 0x0f; - usb_buf[0x03] = 0x00; - usb_buf[0x04] = key; - usb_buf[0x05] = value; - hid_send_feature_report(dev, usb_buf, 9); -} - - -void AuraStrixEvolveController::UpdateProfile - ( - unsigned char key, - unsigned char profile, - unsigned char value - ) -{ - unsigned char usb_buf[9]; - - /*-----------------------------------------------------*\ - | Zero out buffer | - \*-----------------------------------------------------*/ - memset(usb_buf, 0x00, 9); - - /*-----------------------------------------------------*\ - | Set up message packet | - \*-----------------------------------------------------*/ - usb_buf[0x00] = 0x0c; - usb_buf[0x01] = 0xde; - usb_buf[0x02] = key; - usb_buf[0x03] = profile; - usb_buf[0x04] = value; - hid_send_feature_report(dev, usb_buf, 9); - std::this_thread::sleep_for(std::chrono::milliseconds(5)); -} - -void AuraStrixEvolveController::SendSavePacket() -{ - unsigned char usb_buf[9]; - - /*-----------------------------------------------------*\ - | Zero out buffer | - \*-----------------------------------------------------*/ - memset(usb_buf, 0x00, 9); - - /*-----------------------------------------------------*\ - | Set up message packet | - \*-----------------------------------------------------*/ - usb_buf[0x00] = 0x0c; - usb_buf[0x01] = 0xc4; - - hid_send_feature_report(dev, usb_buf, 9); -} diff --git a/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp b/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp index 13f6adb7..2d085755 100644 --- a/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp +++ b/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp @@ -5,9 +5,9 @@ #include "AsusAuraTUFKeyboardController.h" #include "AsusAuraMainboardController.h" #include "AsusAuraMouseController.h" -#include "AsusAuraMousematController.h" #include "AsusROGAllyController.h" -#include "AsusAuraStrixEvolveController.h" +#include "AsusAuraMouseGen1Controller.h" +#include "AsusAuraMousematController.h" #include "AsusAuraMonitorController.h" #include "AsusAuraRyuoAIOController.h" #include "RGBController.h" @@ -20,7 +20,8 @@ #include "RGBController_AsusAuraMousemat.h" #include "RGBController_AsusROGAlly.h" #include "RGBController_ROGStrixLC_Controller.h" -#include "RGBController_AsusAuraStrixEvolve.h" +#include "RGBController_AsusROGSpatha.h" +#include "RGBController_AsusROGStrixEvolve.h" #include "RGBController_AsusAuraMonitor.h" #include "RGBController_AsusAuraRyuoAIO.h" #include @@ -66,6 +67,8 @@ \*-----------------------------------------------------------------*/ #define AURA_ROG_STRIX_EVOLVE_PID 0x185B +#define AURA_ROG_SPATHA_WIRED_PID 0x181C +#define AURA_ROG_SPATHA_WIRELESS_PID 0x1824 /*-----------------------------------------------------------------*\ | MOUSEMATS | @@ -241,8 +244,21 @@ void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name if(dev) { - AuraStrixEvolveController* controller = new AuraStrixEvolveController(dev, info->path, info->product_id); - RGBController_AuraStrixEvolve* rgb_controller = new RGBController_AuraStrixEvolve(controller); + AsusAuraMouseGen1Controller* controller = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id); + RGBController_AsusROGStrixEvolve* rgb_controller = new RGBController_AsusROGStrixEvolve(controller); + rgb_controller->name = name; + ResourceManager::get()->RegisterRGBController(rgb_controller); + } +} + +void DetectAsusAuraUSBSpatha(hid_device_info* info, const std::string& name) +{ + hid_device* dev = hid_open_path(info->path); + + if(dev) + { + AsusAuraMouseGen1Controller* controller = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id); + RGBController_AsusROGSpatha* rgb_controller = new RGBController_AsusROGSpatha(controller); rgb_controller->name = name; ResourceManager::get()->RegisterRGBController(rgb_controller); } @@ -372,6 +388,8 @@ REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3", DetectAs REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_TUF_M5_PID, 2, 0xFF01); REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Evolve", DetectAsusAuraUSBStrixEvolve, AURA_USB_VID, AURA_ROG_STRIX_EVOLVE_PID, 1, 0x0008); +REGISTER_HID_DETECTOR_IP("ASUS ROG Spatha Wired", DetectAsusAuraUSBSpatha, AURA_USB_VID, AURA_ROG_SPATHA_WIRED_PID, 1, 0x0008); +REGISTER_HID_DETECTOR_IP("ASUS ROG Spatha Wireless", DetectAsusAuraUSBSpatha, AURA_USB_VID, AURA_ROG_SPATHA_WIRELESS_PID, 1, 0x0008); /*-----------------------------------------------------------------*\ | MOUSEMATS | diff --git a/Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h b/Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h deleted file mode 100644 index 43a88df8..00000000 --- a/Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h +++ /dev/null @@ -1,40 +0,0 @@ -/*-----------------------------------------*\ -| RGBController_AsusAuraStrixEvolve.h | -| | -| Generic RGB Interface for Asus Aura | -| USB controller driver | -| | -| Mola19 11/30/2021 | -\*-----------------------------------------*/ - -#pragma once -#include "RGBController.h" -#include "AsusAuraStrixEvolveController.h" - -enum -{ - AURA_STRIX_EVOLVE_BRIGHTNESS_MIN = 0, - AURA_STRIX_EVOLVE_BRIGHTNESS_MAX = 255, - AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT = 255 -}; - -class RGBController_AuraStrixEvolve : public RGBController -{ -public: - RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr); - ~RGBController_AuraStrixEvolve(); - - void SetupZones(); - - void ResizeZone(int zone, int new_size); - - void DeviceUpdateLEDs(); - void UpdateZoneLEDs(int zone); - void UpdateSingleLED(int led); - - void DeviceUpdateMode(); - void DeviceSaveMode(); - -private: - AuraStrixEvolveController* controller; -}; diff --git a/Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.cpp b/Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.cpp new file mode 100644 index 00000000..68367f61 --- /dev/null +++ b/Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.cpp @@ -0,0 +1,272 @@ +/*-----------------------------------------*\ +| RGBController_AsusROGSpatha.cpp | +| | +| Generic RGB Interface for Asus Aura | +| USB controller driver | +| | +| Mola19 11/05/2023 | +\*-----------------------------------------*/ + +#include "RGBController_AsusROGSpatha.h" + +/**------------------------------------------------------------------*\ + @name Asus Aura Spatha + @category Mouse + @type USB + @save :white_check_mark: + @direct :white_check_mark: + @effects :white_check_mark: + @detectors DetectAsusAuraUSBSpatha + @comment This device allows indiviual modes for each zone, + which currently can't be implemented in OpenRGB. + Also there seem to be a firmware bug which causes static + to use a random colorand random to use a static color + that was previously set. This can be worked around by saving +\*-------------------------------------------------------------------*/ + +RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Controller* controller_ptr) +{ + controller = controller_ptr; + + name = "ASUS ROG Spatha"; + vendor = "ASUS"; + type = DEVICE_TYPE_MOUSE; + description = "ASUS Aura Mouse Device"; + version = controller->GetVersion(); + location = controller->GetDeviceLocation(); + serial = controller->GetSerialString(); + + mode Direct; + Direct.name = "Direct"; + Direct.value = ASUS_ROG_SPATHA_MODE_DIRECT; + Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; + Direct.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Direct); + + mode Static; + Static.name = "Static"; + Static.value = ASUS_ROG_SPATHA_MODE_STATIC; + Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS; + Static.brightness_min = ASUS_ROG_SPATHA_BRIGHTNESS_MIN; + Static.brightness_max = ASUS_ROG_SPATHA_BRIGHTNESS_MAX; + Static.brightness = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT; + Static.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Static); + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = ASUS_ROG_SPATHA_MODE_BREATHING; + Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS; + Breathing.brightness_min = ASUS_ROG_SPATHA_BRIGHTNESS_MIN; + Breathing.brightness_max = ASUS_ROG_SPATHA_BRIGHTNESS_MAX; + Breathing.brightness = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT; + Breathing.colors_min = 2; + Breathing.colors_max = 2; + Breathing.colors.resize(2); + Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; + modes.push_back(Breathing); + + mode ColorCycle; + ColorCycle.name = "Spectrum Cycle"; + ColorCycle.value = ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE; + ColorCycle.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + ColorCycle.brightness_min = ASUS_ROG_SPATHA_BRIGHTNESS_MIN; + ColorCycle.brightness_max = ASUS_ROG_SPATHA_BRIGHTNESS_MAX; + ColorCycle.brightness = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT; + ColorCycle.colors_min = 12; + ColorCycle.colors_max = 12; + ColorCycle.colors.resize(12); + ColorCycle.color_mode = MODE_COLORS_MODE_SPECIFIC; + modes.push_back(ColorCycle); + + mode Random; + Random.name = "Random"; + Random.value = ASUS_ROG_SPATHA_MODE_RANDOM; + Random.flags = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS; + Random.brightness_min = ASUS_ROG_SPATHA_BRIGHTNESS_MIN; + Random.brightness_max = ASUS_ROG_SPATHA_BRIGHTNESS_MAX; + Random.brightness = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT; + Random.color_mode = MODE_COLORS_NONE; + modes.push_back(Random); + + mode Reactive; + Reactive.name = "Reactive"; + Reactive.value = ASUS_ROG_SPATHA_MODE_REACTIVE; + Reactive.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS; + Reactive.brightness_min = ASUS_ROG_SPATHA_BRIGHTNESS_MIN; + Reactive.brightness_max = ASUS_ROG_SPATHA_BRIGHTNESS_MAX; + Reactive.brightness = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT; + Reactive.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Reactive); + + mode Battery; + Battery.name = "Battery"; + Battery.value = ASUS_ROG_SPATHA_MODE_BATTERY; + Battery.flags = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS; + Battery.brightness_min = ASUS_ROG_SPATHA_BRIGHTNESS_MIN; + Battery.brightness_max = ASUS_ROG_SPATHA_BRIGHTNESS_MAX; + Battery.brightness = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT; + Battery.color_mode = MODE_COLORS_NONE; + modes.push_back(Battery); + + SetupZones(); +} + +RGBController_AsusROGSpatha::~RGBController_AsusROGSpatha() +{ + delete controller; +} + +void RGBController_AsusROGSpatha::SetupZones() +{ + + std::string zones_names[3] = {"Side", "Scroll Wheel", "Logo"}; + + for(unsigned char i = 0; i < 3; i++) + { + zone spatha_zone; + + spatha_zone.name = zones_names[i]; + spatha_zone.type = ZONE_TYPE_SINGLE; + spatha_zone.leds_min = 1; + spatha_zone.leds_max = 1; + spatha_zone.leds_count = 1; + spatha_zone.matrix_map = NULL; + + zones.push_back(spatha_zone); + + led spatha_led; + + spatha_led.name = zones_names[i]; + spatha_led.value = 1; + + leds.push_back(spatha_led); + } + + SetupColors(); +} + +void RGBController_AsusROGSpatha::ResizeZone(int /*zone*/, int /*new_size*/) +{ + +} + +void RGBController_AsusROGSpatha::DeviceUpdateLEDs() +{ + if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT) + { + controller->SendDirectSpatha(colors); + } + else + { + UpdateSingleLED(0); + UpdateSingleLED(1); + UpdateSingleLED(2); + } +} + +void RGBController_AsusROGSpatha::UpdateZoneLEDs(int zone) +{ + if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT) + { + controller->SendDirectSpatha(colors); + } + else + { + UpdateSingleLED(zone); + } +} + +void RGBController_AsusROGSpatha::UpdateSingleLED(int led) +{ + if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT) + { + controller->SendDirectSpatha(colors); + } + else + { + controller->SendUpdate(0x13 + led * 38, RGBGetRValue(colors[led])); + controller->SendUpdate(0x14 + led * 38, RGBGetGValue(colors[led])); + controller->SendUpdate(0x15 + led * 38, RGBGetBValue(colors[led])); + } +} + +void RGBController_AsusROGSpatha::DeviceUpdateMode() +{ + if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT) + { + return; + } + + /*-----------------------------------------------------*\ + | Needed to overwrite direct | + \*-----------------------------------------------------*/ + controller->ResetToSavedLighting(); + + /*-----------------------------------------------------*\ + | Send data to all 3 zones | + \*-----------------------------------------------------*/ + for(int i = 0; i < 3; i++) + { + controller->SendUpdate(0x11 + i * 38, modes[active_mode].value); + + /*------------------------------------------------------------------*\ + | This mouse has independent brightness for wired and wireless. | + | Each is 4-bit in the same byte (wireless is the first/bigger one). | + | OpenRGB misses that feature, hence both are the same | + \*------------------------------------------------------------------*/ + controller->SendUpdate(0x12 + i * 38, (modes[active_mode].brightness << 4) + modes[active_mode].brightness); + + if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_BREATHING) + { + for(int j = 0; j < modes[active_mode].colors.size(); j++) + { + controller->SendUpdate(0x13 + j * 3 + i * 38, RGBGetRValue(modes[active_mode].colors[j])); + controller->SendUpdate(0x14 + j * 3 + i * 38, RGBGetGValue(modes[active_mode].colors[j])); + controller->SendUpdate(0x15 + j * 3 + i * 38, RGBGetBValue(modes[active_mode].colors[j])); + } + } + } +} + +void RGBController_AsusROGSpatha::DeviceSaveMode() +{ + if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT) + { + return; + } + + unsigned int profile = controller->GetActiveProfile(); + + /*-----------------------------------------------------*\ + | Send data to all 3 zones | + \*-----------------------------------------------------*/ + for(int i = 0; i < 3; i++) + { + controller->UpdateProfile(0x11 + i * 38, profile, modes[active_mode].value); + /*------------------------------------------------------------------*\ + | This mouse has independent brightness for wired and wireless. | + | Each is 4-bit in the same byte (wireless is the first/bigger one). | + | OpenRGB misses that feature, hence both are the same | + \*------------------------------------------------------------------*/ + controller->UpdateProfile(0x12 + i * 38, profile, (modes[active_mode].brightness << 4) + modes[active_mode].brightness); + + if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_BREATHING) + { + for(int j = 0; j < modes[active_mode].colors.size(); j++) + { + controller->UpdateProfile(0x13 + j * 3 + i * 38, profile, RGBGetRValue(modes[active_mode].colors[j])); + controller->UpdateProfile(0x14 + j * 3 + i * 38, profile, RGBGetGValue(modes[active_mode].colors[j])); + controller->UpdateProfile(0x15 + j * 3 + i * 38, profile, RGBGetBValue(modes[active_mode].colors[j])); + } + } + else if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_STATIC || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_REACTIVE) + { + controller->UpdateProfile(0x13 + i * 38, profile, RGBGetRValue(colors[i])); + controller->UpdateProfile(0x14 + i * 38, profile, RGBGetGValue(colors[i])); + controller->UpdateProfile(0x15 + i * 38, profile, RGBGetBValue(colors[i])); + } + } + + controller->ResetToSavedLighting(); +} diff --git a/Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.h b/Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.h new file mode 100644 index 00000000..2cab610f --- /dev/null +++ b/Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.h @@ -0,0 +1,51 @@ +/*-----------------------------------------*\ +| RGBController_AsusROGSpatha.h | +| | +| Generic RGB Interface for Asus Aura | +| USB controller driver | +| | +| Mola19 11/05/2023 | +\*-----------------------------------------*/ + +#pragma once +#include "RGBController.h" +#include "AsusAuraMouseGen1Controller.h" + +enum +{ + ASUS_ROG_SPATHA_BRIGHTNESS_MIN = 0, + ASUS_ROG_SPATHA_BRIGHTNESS_MAX = 15, + ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT = 15 +}; + +enum +{ + ASUS_ROG_SPATHA_MODE_DIRECT = 0xFF, + ASUS_ROG_SPATHA_MODE_STATIC = 0x01, + ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE = 0x05, + ASUS_ROG_SPATHA_MODE_RANDOM = 0x06, + ASUS_ROG_SPATHA_MODE_BREATHING = 0x0A, + ASUS_ROG_SPATHA_MODE_BATTERY = 0x0B, + ASUS_ROG_SPATHA_MODE_REACTIVE = 0x0C, +}; + +class RGBController_AsusROGSpatha : public RGBController +{ +public: + RGBController_AsusROGSpatha(AsusAuraMouseGen1Controller* controller_ptr); + ~RGBController_AsusROGSpatha(); + + void SetupZones(); + + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void DeviceUpdateMode(); + void DeviceSaveMode(); + +private: + AsusAuraMouseGen1Controller* controller; +}; diff --git a/Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp b/Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.cpp similarity index 54% rename from Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp rename to Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.cpp index 2b88eb02..040ab1ee 100644 --- a/Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp +++ b/Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.cpp @@ -1,5 +1,5 @@ /*-----------------------------------------*\ -| RGBController_AsusAuraStrixEvolve.cpp | +| RGBController_AsusROGStrixEvolve.cpp | | | | Generic RGB Interface for Asus Aura | | USB controller driver | @@ -7,7 +7,7 @@ | Mola19 11/30/2021 | \*-----------------------------------------*/ -#include "RGBController_AsusAuraStrixEvolve.h" +#include "RGBController_AsusROGStrixEvolve.h" /**------------------------------------------------------------------*\ @name Asus Aura Strix Evolve @@ -20,7 +20,7 @@ @comment \*-------------------------------------------------------------------*/ -RGBController_AuraStrixEvolve::RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr) +RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouseGen1Controller* controller_ptr) { controller = controller_ptr; @@ -34,53 +34,53 @@ RGBController_AuraStrixEvolve::RGBController_AuraStrixEvolve(AuraStrixEvolveCont mode Direct; Direct.name = "Direct"; - Direct.value = 1; + Direct.value = ASUS_ROG_STRIX_EVOLVE_MODE_DIRECT; Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS; - Direct.brightness_min = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN; - Direct.brightness_max = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX; - Direct.brightness = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT; + Direct.brightness_min = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN; + Direct.brightness_max = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX; + Direct.brightness = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT; Direct.color_mode = MODE_COLORS_PER_LED; modes.push_back(Direct); mode Breathing; Breathing.name = "Breathing"; - Breathing.value = 2; + Breathing.value = ASUS_ROG_STRIX_EVOLVE_MODE_BREATHING; Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS; - Breathing.brightness_min = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN; - Breathing.brightness_max = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX; - Breathing.brightness = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT; + Breathing.brightness_min = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN; + Breathing.brightness_max = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX; + Breathing.brightness = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT; Breathing.color_mode = MODE_COLORS_PER_LED; modes.push_back(Breathing); mode ColorCycle; ColorCycle.name = "Spectrum Cycle"; - ColorCycle.value = 3; + ColorCycle.value = ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE; ColorCycle.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; - ColorCycle.brightness_min = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN; - ColorCycle.brightness_max = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX; - ColorCycle.brightness = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT; + ColorCycle.brightness_min = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN; + ColorCycle.brightness_max = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX; + ColorCycle.brightness = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT; ColorCycle.color_mode = MODE_COLORS_NONE; modes.push_back(ColorCycle); mode Reactive; Reactive.name = "Reactive"; - Reactive.value = 4; + Reactive.value = ASUS_ROG_STRIX_EVOLVE_MODE_REACTIVE; Reactive.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS; - Reactive.brightness_min = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN; - Reactive.brightness_max = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX; - Reactive.brightness = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT; + Reactive.brightness_min = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN; + Reactive.brightness_max = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX; + Reactive.brightness = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT; Reactive.color_mode = MODE_COLORS_PER_LED; modes.push_back(Reactive); SetupZones(); } -RGBController_AuraStrixEvolve::~RGBController_AuraStrixEvolve() +RGBController_AsusROGStrixEvolve::~RGBController_AsusROGStrixEvolve() { delete controller; } -void RGBController_AuraStrixEvolve::SetupZones() +void RGBController_AsusROGStrixEvolve::SetupZones() { zone mouse_zone; @@ -103,58 +103,48 @@ void RGBController_AuraStrixEvolve::SetupZones() SetupColors(); } -void RGBController_AuraStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/) +void RGBController_AsusROGStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/) { } -void RGBController_AuraStrixEvolve::DeviceUpdateLEDs() +void RGBController_AsusROGStrixEvolve::DeviceUpdateLEDs() { - unsigned char red = RGBGetRValue(colors[0]); - unsigned char grn = RGBGetGValue(colors[0]); - unsigned char blu = RGBGetBValue(colors[0]); - - controller->SendUpdate(0x1C, red); - controller->SendUpdate(0x1D, grn); - controller->SendUpdate(0x1E, blu); + UpdateSingleLED(0); } -void RGBController_AuraStrixEvolve::UpdateZoneLEDs(int /*zone*/) +void RGBController_AsusROGStrixEvolve::UpdateZoneLEDs(int zone) { - DeviceUpdateLEDs(); + UpdateSingleLED(zone); } -void RGBController_AuraStrixEvolve::UpdateSingleLED(int /*led*/) +void RGBController_AsusROGStrixEvolve::UpdateSingleLED(int led) { - DeviceUpdateLEDs(); + controller->SendUpdate(0x1C, RGBGetRValue(colors[0])); + controller->SendUpdate(0x1D, RGBGetGValue(colors[0])); + controller->SendUpdate(0x1E, RGBGetBValue(colors[0])); } -void RGBController_AuraStrixEvolve::DeviceUpdateMode() +void RGBController_AsusROGStrixEvolve::DeviceUpdateMode() { - unsigned char red = RGBGetRValue(colors[0]); - unsigned char grn = RGBGetGValue(colors[0]); - unsigned char blu = RGBGetBValue(colors[0]); - controller->SendUpdate(0x19, modes[active_mode].value); controller->SendUpdate(0x1A, modes[active_mode].brightness); - controller->SendUpdate(0x1C, red); - controller->SendUpdate(0x1D, grn); - controller->SendUpdate(0x1E, blu); } -void RGBController_AuraStrixEvolve::DeviceSaveMode() +void RGBController_AsusROGStrixEvolve::DeviceSaveMode() { - unsigned char red = RGBGetRValue(colors[0]); - unsigned char grn = RGBGetGValue(colors[0]); - unsigned char blu = RGBGetBValue(colors[0]); - unsigned int profile = controller->GetActiveProfile(); + controller->UpdateProfile(0x19, profile, modes[active_mode].value); controller->UpdateProfile(0x1A, profile, modes[active_mode].brightness); - controller->UpdateProfile(0x1C, profile, red); - controller->UpdateProfile(0x1D, profile, grn); - controller->UpdateProfile(0x1E, profile, blu); - controller->SendSavePacket(); + if(modes[active_mode].value != ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE) + { + controller->UpdateProfile(0x1C, profile, RGBGetRValue(colors[0])); + controller->UpdateProfile(0x1D, profile, RGBGetGValue(colors[0])); + controller->UpdateProfile(0x1E, profile, RGBGetBValue(colors[0])); + } + + controller->ResetToSavedLighting(); } diff --git a/Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.h b/Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.h new file mode 100644 index 00000000..accd64c0 --- /dev/null +++ b/Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.h @@ -0,0 +1,48 @@ +/*-----------------------------------------*\ +| RGBController_AsusROGStrixEvolve.h | +| | +| Generic RGB Interface for Asus Aura | +| USB controller driver | +| | +| Mola19 11/30/2021 | +\*-----------------------------------------*/ + +#pragma once +#include "RGBController.h" +#include "AsusAuraMouseGen1Controller.h" + +enum +{ + ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN = 0, + ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX = 255, + ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT = 255, +}; + +enum +{ + ASUS_ROG_STRIX_EVOLVE_MODE_DIRECT = 0x01, + ASUS_ROG_STRIX_EVOLVE_MODE_BREATHING = 0x02, + ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE = 0x03, + ASUS_ROG_STRIX_EVOLVE_MODE_REACTIVE = 0x04, +}; + +class RGBController_AsusROGStrixEvolve : public RGBController +{ +public: + RGBController_AsusROGStrixEvolve(AsusAuraMouseGen1Controller* controller_ptr); + ~RGBController_AsusROGStrixEvolve(); + + void SetupZones(); + + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void DeviceUpdateMode(); + void DeviceSaveMode(); + +private: + AsusAuraMouseGen1Controller* controller; +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index 5b1598d0..c10e079e 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -364,9 +364,9 @@ HEADERS += Controllers/AsusAuraUSBController/AsusAuraMouseController.h \ Controllers/AsusAuraUSBController/AsusAuraMousematController.h \ Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h \ + Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.h \ Controllers/AsusAuraUSBController/AsusROGAllyController.h \ Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.h \ - Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.h \ Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h \ Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardLayouts.h \ Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.h \ @@ -377,9 +377,10 @@ HEADERS += Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.h \ Controllers/AsusAuraUSBController/RGBController_AsusROGAlly.h \ Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.h \ - Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h \ Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h \ Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.h \ + Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.h \ + Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.h \ Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.h \ Controllers/AsusAuraUSBController/ROGStrixLC_Controller.h \ Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.h \ @@ -980,10 +981,10 @@ SOURCES += Controllers/AsusAuraUSBController/AsusAuraMainboardController.cpp \ Controllers/AsusAuraUSBController/AsusAuraMonitorController.cpp \ Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp \ + Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.cpp \ Controllers/AsusAuraUSBController/AsusAuraMousematController.cpp \ Controllers/AsusAuraUSBController/AsusROGAllyController.cpp \ Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.cpp \ - Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.cpp \ Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp \ Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp \ Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp \ @@ -994,9 +995,10 @@ SOURCES += Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.cpp \ Controllers/AsusAuraUSBController/RGBController_AsusROGAlly.cpp \ Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.cpp \ - Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp \ Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp \ Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp \ + Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.cpp \ + Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.cpp \ Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp \ Controllers/AsusAuraUSBController/ROGStrixLC_Controller.cpp \ Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.cpp \