From 756ceb247105771b9331a4fa5b5afdbcf520d499 Mon Sep 17 00:00:00 2001 From: Mola19 Date: Sun, 20 Aug 2023 22:06:50 +0200 Subject: [PATCH] Add support for Asus ROG Sagaris GK1100 (only for non-modifier keys) --- .../AsusLegacyUSBControllerDetect.cpp | 18 ++ .../AsusSagarisKeyboardController.cpp | 197 ++++++++++++++ .../AsusSagarisKeyboardController.h | 76 ++++++ .../RGBController_AsusSagarisKeyboard.cpp | 246 ++++++++++++++++++ .../RGBController_AsusSagarisKeyboard.h | 34 +++ OpenRGB.pro | 4 + 6 files changed, 575 insertions(+) create mode 100644 Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.cpp create mode 100644 Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.h create mode 100644 Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.cpp create mode 100644 Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.h diff --git a/Controllers/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp b/Controllers/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp index 17a36489..74be9171 100644 --- a/Controllers/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp +++ b/Controllers/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp @@ -1,16 +1,20 @@ #include "Detector.h" #include "AsusCerberusKeyboardController.h" +#include "AsusSagarisKeyboardController.h" #include "AsusStrixClawController.h" #include "RGBController.h" #include "RGBController_AsusCerberusKeyboard.h" +#include "RGBController_AsusSagarisKeyboard.h" #include "RGBController_AsusStrixClaw.h" #include #include #include "dependencies/dmiinfo.h" #define ASUS_LEGACY_USB_VID 0x195D +#define ASUS_USB_VID 0x0B05 #define ASUS_CERBERUS_MECH_PID 0x2047 +#define ASUS_SAGARIS_GK1100_PID 0x1835 #define ASUS_ROG_STRIX_CLAW_PID 0x1016 void DetectAsusCerberusMech(hid_device_info* info, const std::string& name) @@ -26,6 +30,19 @@ void DetectAsusCerberusMech(hid_device_info* info, const std::string& name) } } +void DetectAsusSagarisKeyboard(hid_device_info* info, const std::string& name) +{ + hid_device* dev = hid_open_path(info->path); + + if(dev) + { + AsusSagarisKeyboardController* controller = new AsusSagarisKeyboardController(dev, info->path, info->release_number); + RGBController_AsusSagarisKeyboard* rgb_controller = new RGBController_AsusSagarisKeyboard(controller); + rgb_controller->name = name; + ResourceManager::get()->RegisterRGBController(rgb_controller); + } +} + void DetectAsusStrixClaw(hid_device_info* info, const std::string& name) { hid_device* dev = hid_open_path(info->path); @@ -40,5 +57,6 @@ void DetectAsusStrixClaw(hid_device_info* info, const std::string& name) } REGISTER_HID_DETECTOR_IPU("ASUS Cerberus Mech", DetectAsusCerberusMech, ASUS_LEGACY_USB_VID, ASUS_CERBERUS_MECH_PID, 1, 0xFF01, 1); +REGISTER_HID_DETECTOR_IPU("ASUS Sagaris GK1100", DetectAsusSagarisKeyboard, ASUS_USB_VID, ASUS_SAGARIS_GK1100_PID, 1, 0xFF02, 2); REGISTER_HID_DETECTOR_IPU("ASUS ROG Strix Claw", DetectAsusStrixClaw, ASUS_LEGACY_USB_VID, ASUS_ROG_STRIX_CLAW_PID, 0, 0xFF01, 1); \ No newline at end of file diff --git a/Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.cpp b/Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.cpp new file mode 100644 index 00000000..bbb41f67 --- /dev/null +++ b/Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.cpp @@ -0,0 +1,197 @@ +/*-----------------------------------------*\ +| AsusSagarisKeyboardController.cpp | +| | +| Driver for ASUS Sagaris USB lighting | +| controller | +| | +| Mola19 08/20/2023 | +\*-----------------------------------------*/ + +#include "AsusSagarisKeyboardController.h" + +#include +#include +#include +#include +#include + +#include "LogManager.h" + +#define ASUS_SAGARIS_KB_PACKET_SIZE 65 + +AsusSagarisKeyboardController::AsusSagarisKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version) +{ + dev = dev_handle; + location = path; + version = rev_version; +} + +AsusSagarisKeyboardController::~AsusSagarisKeyboardController() +{ + hid_close(dev); +} + +std::string AsusSagarisKeyboardController::GetVersion() +{ + return std::to_string((int) floor(version / 0x100)) + "." + std::to_string(version % 0x100); +} + +std::string AsusSagarisKeyboardController::GetDeviceLocation() +{ + return("HID: " + location); +} + +std::string AsusSagarisKeyboardController::GetSerialString() +{ + wchar_t serial_string[128]; + int ret = hid_get_serial_number_string(dev, serial_string, 128); + + if(ret != 0) + { + return(""); + } + + std::wstring return_wstring = serial_string; + std::string return_string(return_wstring.begin(), return_wstring.end()); + + return(return_string); +} + +sagaris_mode AsusSagarisKeyboardController::GetMode() +{ + ClearResponses(); + + uint8_t usb_buf_out[ASUS_SAGARIS_KB_PACKET_SIZE]; + memset(usb_buf_out, 0x00, sizeof(usb_buf_out)); + + usb_buf_out[0x00] = 0x06; + usb_buf_out[0x01] = 0x0B; + usb_buf_out[0x02] = 0x03; + + hid_write(dev, usb_buf_out, ASUS_SAGARIS_KB_PACKET_SIZE); + + unsigned char usb_buf_in[ASUS_SAGARIS_KB_PACKET_SIZE]; + memset(usb_buf_in, 0x00, sizeof(usb_buf_in)); + int return_length = hid_read_timeout(dev, usb_buf_in, ASUS_SAGARIS_KB_PACKET_SIZE, 100); + + if(return_length == -1) + { + LOG_DEBUG("[Asus Sagaris GK1100]: Could not fetch mode"); + sagaris_mode default_mode; + default_mode.mode = SAGARIS_KEYBOARD_MODE_STATIC; + default_mode.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT; + default_mode.speed = 0; + default_mode.colorIndex = 0; + + return default_mode; + } + + sagaris_mode current_mode; + current_mode.mode = usb_buf_in[3]; + current_mode.brightness = usb_buf_in[4]; + current_mode.speed = usb_buf_in[5]; + current_mode.colorIndex = usb_buf_in[6]; + + return current_mode; +} + +std::vector AsusSagarisKeyboardController::GetColors() +{ + ClearResponses(); + + uint8_t usb_buf_out[ASUS_SAGARIS_KB_PACKET_SIZE]; + memset(usb_buf_out, 0x00, sizeof(usb_buf_out)); + + usb_buf_out[0x00] = 0x06; + usb_buf_out[0x01] = 0x0B; + usb_buf_out[0x02] = 0x05; + + hid_write(dev, usb_buf_out, ASUS_SAGARIS_KB_PACKET_SIZE); + + std::vector colors; + colors.resize(7); + + for(int i = 0; i < 7; i++) + { + unsigned char usb_buf_in[ASUS_SAGARIS_KB_PACKET_SIZE]; + memset(usb_buf_in, 0x00, sizeof(usb_buf_in)); + int return_length = hid_read_timeout(dev, usb_buf_in, ASUS_SAGARIS_KB_PACKET_SIZE, 100); + + if(return_length == -1) + { + LOG_DEBUG("[Asus Sagaris GK1100]: Could not fetch color %i", i); + colors[i] = ToRGBColor(0, 0, 0); + continue; + } + + colors[i] = ToRGBColor(usb_buf_in[4] * 16, usb_buf_in[5] * 16, usb_buf_in[6] * 16); + } + + return colors; +} + +void AsusSagarisKeyboardController::SetColor + ( + uint8_t index, + uint8_t red, + uint8_t green, + uint8_t blue + ) +{ + uint8_t usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE]; + + memset(usb_buf, 0x00, sizeof(usb_buf)); + + usb_buf[0x00] = 0x06; + usb_buf[0x01] = 0x0B; + usb_buf[0x02] = 0x04; + usb_buf[0x03] = 0x00; + usb_buf[0x04] = index; + usb_buf[0x05] = red; + usb_buf[0x06] = green; + usb_buf[0x07] = blue; + + hid_write(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE); +} + +void AsusSagarisKeyboardController::SetMode + ( + uint8_t mode, + uint8_t brightness, + uint8_t speed, + uint8_t colorIndex + ) +{ + ClearResponses(); + + uint8_t usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE]; + memset(usb_buf, 0x00, sizeof(usb_buf)); + + usb_buf[0x00] = 0x06; + usb_buf[0x01] = 0x0B; + usb_buf[0x02] = 0x01; + usb_buf[0x03] = mode; + usb_buf[0x04] = brightness; + usb_buf[0x05] = speed; + usb_buf[0x06] = colorIndex; + + hid_write(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE); + + AwaitResponse(20); +} + +void AsusSagarisKeyboardController::AwaitResponse(int ms) +{ + unsigned char usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE]; + hid_read_timeout(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE, ms); +} + +void AsusSagarisKeyboardController::ClearResponses() +{ + int result = 1; + unsigned char usb_buf_flush[65]; + while(result > 0) + { + result = hid_read_timeout(dev, usb_buf_flush, 65, 0); + } +} \ No newline at end of file diff --git a/Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.h b/Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.h new file mode 100644 index 00000000..ad86bfd9 --- /dev/null +++ b/Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.h @@ -0,0 +1,76 @@ +/*-----------------------------------------*\ +| AsusSagarisKeyboardController.h | +| | +| Definitions and types for ASUS Sagaris | +| USB RGB lighting controller | +| | +| Mola19 08/20/2023 | +\*-----------------------------------------*/ + +#include "RGBController.h" + +#include +#include +#include + +#pragma once + +enum +{ + SAGARIS_KEYBOARD_MODE_OFF = 0, + SAGARIS_KEYBOARD_MODE_STATIC = 1, + SAGARIS_KEYBOARD_MODE_SPRIAL = 2, + SAGARIS_KEYBOARD_MODE_CUSTOM = 3, + SAGARIS_KEYBOARD_MODE_BREATHING = 4, + SAGARIS_KEYBOARD_MODE_REACTIVE = 5, + SAGARIS_KEYBOARD_MODE_STARRY_NIGHT = 6, + SAGARIS_KEYBOARD_MODE_LASER = 7, +}; + +enum +{ + SAGARIS_KEYBOARD_BRIGHTNESS_MIN = 0, + SAGARIS_KEYBOARD_BRIGHTNESS_MAX = 3, + SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT = 3 +}; + +enum +{ + SAGARIS_KEYBOARD_SPEED_MIN = 0, + SAGARIS_KEYBOARD_SPEED_MAX = 3, + SAGARIS_KEYBOARD_SPEED_DEFAULT = 2 +}; + +typedef struct +{ + uint8_t mode; + uint8_t brightness; + uint8_t speed; + uint8_t colorIndex; +} sagaris_mode; + + +class AsusSagarisKeyboardController +{ +public: + AsusSagarisKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version); + ~AsusSagarisKeyboardController(); + + std::string GetVersion(); + std::string GetDeviceLocation(); + std::string GetSerialString(); + + sagaris_mode GetMode(); + std::vector GetColors(); + + void SetMode(uint8_t mode, uint8_t brightness, uint8_t speed, uint8_t colorIndex); + void SetColor(uint8_t index, uint8_t red, uint8_t green, uint8_t blue); + + void AwaitResponse(int ms); + void ClearResponses(); + +private: + hid_device* dev; + std::string location; + unsigned short version; +}; diff --git a/Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.cpp b/Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.cpp new file mode 100644 index 00000000..8551b2f9 --- /dev/null +++ b/Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.cpp @@ -0,0 +1,246 @@ +/*-----------------------------------------*\ +| RGBController_AsusSagarisKeyboard.cpp | +| | +| Generic RGB Interface for Asus Sagaris | +| USB controller driver | +| | +| Mola19 08/20/2023 | +\*-----------------------------------------*/ + +#include "RGBController_AsusSagarisKeyboard.h" +#include + +/**------------------------------------------------------------------*\ + @name Asus Sagaris Keyboard + @category Keyboard + @type USB + @save :robot: + @direct :x: + @effects :white_check_mark: + @detectors DetectAsusSagarisKeyboard + @comment Missing controls for modifier keys, as they have independent lighting +\*-------------------------------------------------------------------*/ + +#include + +RGBController_AsusSagarisKeyboard::RGBController_AsusSagarisKeyboard(AsusSagarisKeyboardController* controller_ptr) +{ + controller = controller_ptr; + + name = "ASUS Sagaris Keyboard"; + vendor = "ASUS"; + type = DEVICE_TYPE_KEYBOARD; + description = "ASUS Sagaris Keyboard Device"; + version = controller->GetVersion(); + location = controller->GetDeviceLocation(); + serial = controller->GetSerialString(); + + mode Off; + Off.name = "Off"; + Off.value = SAGARIS_KEYBOARD_MODE_OFF; + Off.flags = MODE_FLAG_AUTOMATIC_SAVE; + Off.color_mode = MODE_COLORS_NONE; + modes.push_back(Off); + + mode Static; + Static.name = "Static"; + Static.value = SAGARIS_KEYBOARD_MODE_STATIC; + Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS; + Static.brightness_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN; + Static.brightness_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX; + Static.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT; + Static.color_mode = MODE_COLORS_MODE_SPECIFIC; + Static.colors_min = 1; + Static.colors_max = 1; + Static.colors.resize(1); + modes.push_back(Static); + + mode Spiral; + Spiral.name = "Spiral"; + Spiral.value = SAGARIS_KEYBOARD_MODE_SPRIAL; + Spiral.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Spiral.brightness_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN; + Spiral.brightness_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX; + Spiral.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT; + Spiral.speed_min = SAGARIS_KEYBOARD_SPEED_MIN; + Spiral.speed_max = SAGARIS_KEYBOARD_SPEED_MAX; + Spiral.speed = SAGARIS_KEYBOARD_SPEED_DEFAULT; + Spiral.color_mode = MODE_COLORS_MODE_SPECIFIC; + Spiral.colors_min = 7; + Spiral.colors_max = 7; + Spiral.colors.resize(7); + modes.push_back(Spiral); + + mode Custom; + Custom.name = "Custom"; + Custom.value = SAGARIS_KEYBOARD_MODE_CUSTOM; + Custom.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS; + Custom.brightness_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN; + Custom.brightness_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX; + Custom.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT; + Custom.color_mode = MODE_COLORS_MODE_SPECIFIC; + Custom.colors_min = 7; + Custom.colors_max = 7; + Custom.colors.resize(7); + modes.push_back(Custom); + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = SAGARIS_KEYBOARD_MODE_BREATHING; + Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED; + Breathing.speed_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN; + Breathing.speed_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX; + Breathing.speed = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT; + Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; + Breathing.colors_min = 7; + Breathing.colors_max = 7; + Breathing.colors.resize(7); + modes.push_back(Breathing); + + mode Reactive; + Reactive.name = "Reactive"; + Reactive.value = SAGARIS_KEYBOARD_MODE_REACTIVE; + Reactive.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Reactive.brightness_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN; + Reactive.brightness_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX; + Reactive.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT; + Reactive.speed_min = SAGARIS_KEYBOARD_SPEED_MIN; + Reactive.speed_max = SAGARIS_KEYBOARD_SPEED_MAX; + Reactive.speed = SAGARIS_KEYBOARD_SPEED_DEFAULT; + Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC; + Reactive.colors_min = 1; + Reactive.colors_max = 1; + Reactive.colors.resize(1); + modes.push_back(Reactive); + + mode Starry_Night; + Starry_Night.name = "Starry Night"; + Starry_Night.value = SAGARIS_KEYBOARD_MODE_STARRY_NIGHT; + Starry_Night.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Starry_Night.brightness_min = SAGARIS_KEYBOARD_SPEED_MIN; + Starry_Night.brightness_max = SAGARIS_KEYBOARD_SPEED_MAX; + Starry_Night.brightness = SAGARIS_KEYBOARD_SPEED_DEFAULT; + Starry_Night.speed_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN; + Starry_Night.speed_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX; + Starry_Night.speed = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT; + Starry_Night.color_mode = MODE_COLORS_MODE_SPECIFIC; + Starry_Night.colors_min = 7; + Starry_Night.colors_max = 7; + Starry_Night.colors.resize(7); + modes.push_back(Starry_Night); + + mode Laser; + Laser.name = "Laser"; + Laser.value = SAGARIS_KEYBOARD_MODE_LASER; + Laser.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Laser.brightness_min = SAGARIS_KEYBOARD_SPEED_MIN; + Laser.brightness_max = SAGARIS_KEYBOARD_SPEED_MAX; + Laser.brightness = SAGARIS_KEYBOARD_SPEED_DEFAULT; + Laser.speed_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN; + Laser.speed_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX; + Laser.speed = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT; + Laser.color_mode = MODE_COLORS_MODE_SPECIFIC; + Laser.colors_min = 7; + Laser.colors_max = 7; + Laser.colors.resize(7); + modes.push_back(Laser); + + SetupZones(); + + sagaris_mode current_mode = controller->GetMode(); + + active_mode = current_mode.mode; + last_mode = current_mode.mode; + modes[active_mode].brightness = current_mode.brightness; + modes[active_mode].speed = current_mode.speed; + + current_colors = controller->GetColors(); + + for(int i = 0; i < modes[active_mode].colors.size(); i++) + { + modes[active_mode].colors[i] = current_colors[i]; + } +} + +RGBController_AsusSagarisKeyboard::~RGBController_AsusSagarisKeyboard() +{ + delete controller; +} + +void RGBController_AsusSagarisKeyboard::SetupZones() +{ + zone keyboard; + keyboard.name = "Keyboard"; + keyboard.type = ZONE_TYPE_SINGLE; + keyboard.leds_min = 1; + keyboard.leds_max = 1; + keyboard.leds_count = 1; + keyboard.matrix_map = nullptr; + + SetupColors(); +} + +void RGBController_AsusSagarisKeyboard::ResizeZone(int /*zone*/, int /*new_size*/) +{ + +} + +void RGBController_AsusSagarisKeyboard::DeviceUpdateLEDs() +{ + +} + +void RGBController_AsusSagarisKeyboard::UpdateZoneLEDs(int /*zone*/) +{ + +} + +void RGBController_AsusSagarisKeyboard::UpdateSingleLED(int led) +{ + +} + +void RGBController_AsusSagarisKeyboard::DeviceUpdateMode() +{ + if(last_mode != active_mode) + { + last_mode = active_mode; + for(int i = 0; i < modes[active_mode].colors.size(); i++) + { + modes[active_mode].colors[i] = current_colors[i]; + } + } + else + { + for(int i = 0; i < modes[active_mode].colors.size(); i++) + { + current_colors[i] = modes[active_mode].colors[i]; + } + + for(int i = 0; i < modes[active_mode].colors.size(); i++) + { + /*-----------------------------------------*\ + | This device uses 4bit colorValues (0-16) | + \*-----------------------------------------*/ + uint8_t red = RGBGetRValue(modes[active_mode].colors[i]) / 16; + uint8_t green = RGBGetGValue(modes[active_mode].colors[i]) / 16; + uint8_t blue = RGBGetBValue(modes[active_mode].colors[i]) / 16; + + controller->SetColor(i, red, green, blue); + } + } + + /*------------------------------------------------------------------------------------------------------*\ + | This device uses a global color storage for 7 colors, | + | each time a mode is selected, it is specified which color is chosen (some use all). | + | As OpenRGB doesn't support selecting the color index, color 1 is used for single color modes. | + \*------------------------------------------------------------------------------------------------------*/ + + uint8_t colorIndex = 0; + + uint8_t mode = modes[active_mode].value; + + if(mode == SAGARIS_KEYBOARD_MODE_STARRY_NIGHT) colorIndex = 7; + + controller->SetMode(mode, modes[active_mode].brightness, modes[active_mode].speed, colorIndex); +} diff --git a/Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.h b/Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.h new file mode 100644 index 00000000..01d6b4fb --- /dev/null +++ b/Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.h @@ -0,0 +1,34 @@ +/*-----------------------------------------*\ +| RGBController_AsusSagarisKeyboard.h | +| | +| Generic RGB Interface for Asus Sagaris | +| USB controller driver | +| | +| Mola19 08/20/2023 | +\*-----------------------------------------*/ + +#pragma once +#include "RGBController.h" +#include "AsusSagarisKeyboardController.h" + +class RGBController_AsusSagarisKeyboard : public RGBController +{ +public: + RGBController_AsusSagarisKeyboard(AsusSagarisKeyboardController* controller_ptr); + ~RGBController_AsusSagarisKeyboard(); + + void SetupZones(); + + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void DeviceUpdateMode(); + +private: + AsusSagarisKeyboardController* controller; + std::vector current_colors; + uint8_t last_mode; +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index 4b698195..f870345d 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -365,8 +365,10 @@ HEADERS += Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.h \ Controllers/AsusAuraUSBController/ROGStrixLC_Controller.h \ Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.h \ + Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.h \ Controllers/AsusLegacyUSBController/AsusStrixClawController.h \ Controllers/AsusLegacyUSBController/RGBController_AsusCerberusKeyboard.h \ + Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.h \ Controllers/AsusLegacyUSBController/RGBController_AsusStrixClaw.h \ Controllers/BlinkyTapeController/BlinkyTapeController.h \ Controllers/BlinkyTapeController/RGBController_BlinkyTape.h \ @@ -960,9 +962,11 @@ SOURCES += Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp \ Controllers/AsusAuraUSBController/ROGStrixLC_Controller.cpp \ Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.cpp \ + Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.cpp \ Controllers/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp \ Controllers/AsusLegacyUSBController/AsusStrixClawController.cpp \ Controllers/AsusLegacyUSBController/RGBController_AsusCerberusKeyboard.cpp \ + Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.cpp \ Controllers/AsusLegacyUSBController/RGBController_AsusStrixClaw.cpp \ Controllers/BlinkyTapeController/BlinkyTapeController.cpp \ Controllers/BlinkyTapeController/BlinkyTapeControllerDetect.cpp \