diff --git a/Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp b/Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp index a4bf284e..38877ab4 100644 --- a/Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp +++ b/Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp @@ -2,9 +2,12 @@ #include "AsusAuraCoreController.h" #include "RGBController.h" #include "RGBController_AsusAuraCore.h" +#include "RGBController_AsusAuraCoreLaptop.h" #include -#define AURA_CORE_VID 0x0B05 +#define AURA_CORE_VID 0x0B05 + +#define AURA_STRIX_SCAR_15_PID 0x19B6 /******************************************************************************************\ * * @@ -17,10 +20,11 @@ void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string&) { hid_device* dev = hid_open_path(info->path); - if( dev ) + + if(dev) { - AuraCoreController* controller = new AuraCoreController(dev, info->path); - RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller); + AuraCoreController* controller = new AuraCoreController(dev, info->path); + RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller); // Constructor sets the name if(rgb_controller->type != DEVICE_TYPE_UNKNOWN) { @@ -33,6 +37,21 @@ void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string&) } } -REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1854); -REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1866); -REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1869); +void DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::string& name) +{ + hid_device* dev = hid_open_path(info->path); + + if(dev) + { + AsusAuraCoreLaptopController* controller = new AsusAuraCoreLaptopController(dev, info->path); + RGBController_AsusAuraCoreLaptop* rgb_controller = new RGBController_AsusAuraCoreLaptop(controller); + // Constructor sets the name + ResourceManager::get()->RegisterRGBController(rgb_controller); + } +} + + +REGISTER_HID_DETECTOR ("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1854); +REGISTER_HID_DETECTOR ("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1866); +REGISTER_HID_DETECTOR ("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1869); +REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 15", DetectAsusAuraCoreLaptopControllers, AURA_CORE_VID, AURA_STRIX_SCAR_15_PID, 0xFF31, 0x79); diff --git a/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.cpp b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.cpp new file mode 100644 index 00000000..5a2ee62b --- /dev/null +++ b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.cpp @@ -0,0 +1,356 @@ +/*---------------------------------------------------------------------*\ +| AsusAuraCoreLaptopController.cpp | +| | +| Driver for Asus Aura Core Laptop USB Controller | +| | +| Chris M (Dr_No) 28 Jul 2022 | +| | +\*---------------------------------------------------------------------*/ + +#include "AsusAuraCoreLaptopController.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, + +}; + +static std::string power_zones[ASUSAURACORELAPTOP_POWER_ZONES] = +{ + "Logo", + ZONE_EN_KEYBOARD, + "Lightbar", + "Lid Edges" +}; + +static std::string power_states[ASUSAURACORELAPTOP_POWER_STATES] = +{ + " when booting", + " when awake", + " when sleeping", + " when off", +}; + +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; + + hid_get_manufacturer_string(dev, tmp, sz); + std::wstring wName = std::wstring(tmp); + device_name = std::string(wName.begin(), wName.end()); + + hid_get_product_string(dev, tmp, sz); + wName = std::wstring(tmp); + device_name.append(" ").append(std::string(wName.begin(), wName.end())); + + SetPowerConfigFromJSON(); +} + +AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController() +{ + hid_close(dev); +} + +std::string AsusAuraCoreLaptopController::GetDeviceName() +{ + return device_name; +} + +std::string AsusAuraCoreLaptopController::GetSerial() +{ + const uint8_t sz = HID_MAX_STR; + wchar_t tmp[sz]; + + int ret = hid_get_serial_number_string(dev, tmp, sz); + + if (ret != 0) + { + LOG_DEBUG("[%s] Get HID Serial string failed", device_name.c_str()); + return(""); + } + + std::wstring w_tmp = std::wstring(tmp); + std::string serial = std::string(w_tmp.begin(), w_tmp.end()); + + return serial; +} + +std::string AsusAuraCoreLaptopController::GetLocation() +{ + return("HID: " + location); +} + +void AsusAuraCoreLaptopController::SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction) +{ + bool needs_update = !( (current_mode == mode ) && + (current_speed == speed ) && + (current_brightness == brightness ) && + (current_c1 == color1 ) && + (current_c2 == color2 ) && + (current_random == random ) && + (current_direction == direction ) ); + + if(needs_update) + { + current_mode = mode; + current_speed = speed; + current_brightness = brightness; + current_c1 = color1; + current_c2 = color2; + current_random = random; + current_direction = direction; + + SendUpdate(); + SendBrightness(); + } +} + +void AsusAuraCoreLaptopController::SetLedsDirect(std::vector 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; + 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]; + + memset(key_buf, 0, map_size); + + for(size_t led_index = 0; led_index < colors.size(); led_index++) + { + uint16_t offset = 3 * packet_map[led_index]; + + key_buf[offset] = RGBGetRValue(colors[led_index]); + key_buf[offset + 1] = RGBGetGValue(colors[led_index]); + key_buf[offset + 2] = RGBGetBValue(colors[led_index]); + } + + for(size_t i = 0; i < key_set; i+=leds_per_packet) + { + uint8_t leds_remaining = key_set - i; + + if(leds_remaining < leds_per_packet) + { + buffer[07] = leds_remaining; + } + + buffer[06] = i; + memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * i], (3 * buffer[07])); + + hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE); + } + + buffer[4] = 0x04; + buffer[5] = 0x00; + buffer[6] = 0x00; + buffer[7] = 0x00; + memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * key_set], (3 * (led_count - key_set))); + + hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE); +} + +void AsusAuraCoreLaptopController::SendBrightness() +{ + const uint8_t index = 2; + uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS }; + + memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index); + buffer[4] = current_brightness; + + hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE); +} + +void AsusAuraCoreLaptopController::SendUpdate() +{ + uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_UPDATE }; + + buffer[ASUSAURACORELAPTOP_ZONE_BYTE] = 0; + buffer[ASUSAURACORELAPTOP_MODE_BYTE] = current_mode; + buffer[ASUSAURACORELAPTOP_R1_BYTE] = RGBGetRValue(current_c1); + buffer[ASUSAURACORELAPTOP_G1_BYTE] = RGBGetGValue(current_c1); + buffer[ASUSAURACORELAPTOP_B1_BYTE] = RGBGetBValue(current_c1); + buffer[ASUSAURACORELAPTOP_SPEED_BYTE] = current_speed; + buffer[ASUSAURACORELAPTOP_DIRECTION_BYTE] = current_direction; + buffer[ASUSAURACORELAPTOP_DATA_BYTE] = current_random; + buffer[ASUSAURACORELAPTOP_R2_BYTE] = RGBGetRValue(current_c2); + buffer[ASUSAURACORELAPTOP_G2_BYTE] = RGBGetGValue(current_c2); + buffer[ASUSAURACORELAPTOP_B2_BYTE] = RGBGetBValue(current_c2); + + hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE); + + SendApply(); +} + +void AsusAuraCoreLaptopController::SendApply() +{ + const uint8_t index = 2; + uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_APPLY }; + + memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index); + + hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE); +} + +void AsusAuraCoreLaptopController::SendSet() +{ + const uint8_t index = 2; + uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_SET }; + + memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index); + + hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE); +} + +std::vector AsusAuraCoreLaptopController::PowerConfigArray() +{ + std::vector temp; + + for(uint8_t zone_index = 0; zone_index < ASUSAURACORELAPTOP_POWER_ZONES; zone_index++) + { + for(uint8_t state_index = 0; state_index < ASUSAURACORELAPTOP_POWER_STATES; state_index++) + { + p_state new_state; + + new_state.zone = power_zones[zone_index] + power_states[state_index]; + new_state.state = true; + + temp.push_back(new_state); + } + } + + return temp; +} + +void AsusAuraCoreLaptopController::SetPowerConfigFromJSON() +{ + std::vector power_config = PowerConfigArray(); + const std::string section_power = "PowerConfig"; + const std::string detector_name = "Asus Aura Core Laptop"; + SettingsManager* settings_manager = ResourceManager::get()->GetSettingsManager(); + json device_settings = settings_manager->GetSettings(detector_name); + + /*---------------------------------------------------------*\ + | Get Power state config from the settings manager | + | If PowerConfig is not found then write it to settings | + \*---------------------------------------------------------*/ + if(!device_settings.contains(section_power)) + { + json pcfg; + + for(size_t i = 0; i < power_config.size(); i++) + { + pcfg[power_config[i].zone] = power_config[i].state; + } + + device_settings[section_power] = pcfg; + settings_manager->SetSettings(detector_name, device_settings); + settings_manager->SaveSettings(); + } + else + { + for(size_t i = 0; i < power_config.size(); i++) + { + std::string key_name = power_config[i].zone; + + 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")); + } + } + } + + /*-----------------------------------------------------------------------------*\ + | Power state flags are packed in zones but the order is inconsistent. | + | 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[] = + { + power_config[0].state, power_config[4].state, + power_config[1].state, power_config[5].state, + !power_config[2].state, !power_config[6].state, + !power_config[3].state, !power_config[7].state, + + false, power_config[8].state, + power_config[9].state, !power_config[10].state, + !power_config[11].state, false, + false, false, + + power_config[12].state, power_config[13].state, + !power_config[14].state, !power_config[15].state + }; + + 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); + SendPowerConfig(flags); +} + +void AsusAuraCoreLaptopController::SendPowerConfig(uint32_t flags) +{ + const uint8_t index = 6; + uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_POWER, 0x01, 0x00, 0x00, 0x0F }; + + memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index); + + buffer[3] = flags & 0xFF; + buffer[4] = (flags >> 8) & 0xFF; + buffer[5] = (flags >> 16) & 0xFF; + + hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE); +} + +uint32_t AsusAuraCoreLaptopController::PackPowerFlags(bool flags[]) +{ + uint32_t temp = {}; + const uint8_t length = 32; + + for (size_t i = 0; i < length; ++i) + { + uint32_t flag = {flags[i]}; + flag <<= i; + temp |= flag; + } + + return temp; +} diff --git a/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.h b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.h new file mode 100644 index 00000000..c8bdfad5 --- /dev/null +++ b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.h @@ -0,0 +1,135 @@ +/*---------------------------------------------------------------------*\ +| AsusAuraCoreLaptopController.h | +| | +| Driver for AsusAuraCoreLaptop USB Controller | +| | +| Chris M (Dr_No) 28 Jul 2022 | +| | +\*---------------------------------------------------------------------*/ + +#include +#include +#include +#include "LogManager.h" +#include "RGBController.h" +#include "ResourceManager.h" +#include "SettingsManager.h" +#include "RGBControllerKeyNames.h" + +#pragma once + +#define NA 0xFFFFFFFF +#define HID_MAX_STR 255 +#define ASUSAURACORELAPTOP_TIMEOUT 250 +#define ASUSAURACORELAPTOP_READ_PACKET_SIZE 64 +#define ASUSAURACORELAPTOP_WRITE_PACKET_SIZE 64 //Buffer requires a prepended ReportID hence + 1 + +#define ASUSAURACORELAPTOP_KEYCOUNT 91 +#define ASUSAURACORELAPTOP_KEY_WIDTH 18 +#define ASUSAURACORELAPTOP_KEY_HEIGHT 7 +#define ASUSAURACORELAPTOP_LIGHTBARCOUNT 6 +#define ASUSAURACORELAPTOP_LIDCOUNT 3 +#define ASUSAURACORELAPTOP_POWER_ZONES 4 +#define ASUSAURACORELAPTOP_POWER_STATES 4 +#define ASUSAURACORELAPTOP_BRIGHTNESS_MIN 0 +#define ASUSAURACORELAPTOP_BRIGHTNESS_MAX 255 + +enum +{ + ASUSAURACORELAPTOP_MODE_OFF = 0x00, //Turn off - All leds off + ASUSAURACORELAPTOP_MODE_DIRECT = 0xFF, //Direct Led Control - Independently set LEDs in zone + ASUSAURACORELAPTOP_MODE_STATIC = 0x00, //Static Mode - Set entire zone to a single color. + ASUSAURACORELAPTOP_MODE_BREATHING = 0x01, //Breathing Mode - Fades between fully off and fully on. + ASUSAURACORELAPTOP_MODE_SPECTRUM = 0x02, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device + ASUSAURACORELAPTOP_MODE_RAINBOW = 0x03, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs + ASUSAURACORELAPTOP_MODE_FLASHING = 0x0A, //Flashing Mode - Abruptly changing between fully off and fully on. + + /*-------------------------------------------------*\ + | Modes not implemented in the Armoury Crate | + | OEM software that were discovered. | + \*-------------------------------------------------*/ + ASUSAURACORELAPTOP_MODE_STARRY_NIGHT = 0x04, //Starry Night Mode + ASUSAURACORELAPTOP_MODE_RAIN = 0x05, //Rain Mode + ASUSAURACORELAPTOP_MODE_REACT_FADE = 0x06, //Reactive Fade Mode + ASUSAURACORELAPTOP_MODE_REACT_LASER = 0x07, //Reactive Laser Mode + ASUSAURACORELAPTOP_MODE_REACT_RIPPLE = 0x08, //Reactive Ripple Mode + ASUSAURACORELAPTOP_MODE_COMET = 0x0B, //Comet Mode + ASUSAURACORELAPTOP_MODE_FLASHNDASH = 0x0C, //Flash n Dash Mode + ASUSAURACORELAPTOP_MODE_KEYSTONE = 0x0D, //Keystone Mode +}; + +enum +{ + ASUSAURACORELAPTOP_ZONE_BYTE = 2, + ASUSAURACORELAPTOP_MODE_BYTE = 3, + ASUSAURACORELAPTOP_R1_BYTE = 4, + ASUSAURACORELAPTOP_G1_BYTE = 5, + ASUSAURACORELAPTOP_B1_BYTE = 6, + ASUSAURACORELAPTOP_SPEED_BYTE = 7, + ASUSAURACORELAPTOP_DIRECTION_BYTE = 8, + ASUSAURACORELAPTOP_DATA_BYTE = 9, + ASUSAURACORELAPTOP_R2_BYTE = 10, + ASUSAURACORELAPTOP_G2_BYTE = 11, + ASUSAURACORELAPTOP_B2_BYTE = 12, +}; + +enum +{ + ASUSAURACORELAPTOP_REPORT_ID = 0x5D, + ASUSAURACORELAPTOP_CMD_BRIGHTNESS = 0xBA, + ASUSAURACORELAPTOP_CMD_DIRECT = 0xBC, + ASUSAURACORELAPTOP_CMD_POWER = 0xBD, + ASUSAURACORELAPTOP_CMD_UPDATE = 0xB3, + ASUSAURACORELAPTOP_CMD_APPLY = 0xB4, + ASUSAURACORELAPTOP_CMD_SET = 0xB5, +}; + +enum +{ + ASUSAURACORELAPTOP_SPEED_SLOWEST = 0xE1, // Slowest speed + ASUSAURACORELAPTOP_SPEED_NORMAL = 0xEB, // Normal speed + ASUSAURACORELAPTOP_SPEED_FASTEST = 0xF5, // Fastest speed +}; + +struct p_state +{ + std::string zone; + bool state; +}; + +class AsusAuraCoreLaptopController +{ +public: + AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path); + ~AsusAuraCoreLaptopController(); + + std::string GetDeviceName(); + std::string GetSerial(); + 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 colors); +private: + std::string device_name; + std::string location; + hid_device* dev; + + 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; + + void SendApply(); + void SendBrightness(); + void SendSet(); + void SendUpdate(); + + void SetPowerConfigFromJSON(); + void SendPowerConfig(uint32_t flags); + uint32_t PackPowerFlags(bool flags[]); + std::vector PowerConfigArray(); +}; diff --git a/Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.cpp b/Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.cpp new file mode 100644 index 00000000..bd78f0f2 --- /dev/null +++ b/Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.cpp @@ -0,0 +1,496 @@ +/*---------------------------------------------------------------------*\ +| RGBController_AsusAuraCoreLaptop.cpp | +| | +| Driver for AsusAuraCoreLaptop USB Controller | +| | +| Chris M (Dr_No) 28 Jul 2022 | +| | +\*---------------------------------------------------------------------*/ + +#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 + @type USB + @save :x: + @direct :white_check_mark: + @effects :white_check_mark: + @detectors DetectAsusAuraCoreLaptopControllers + @comment Power profiles for this controller are set to `On` for all power + state and scan be adjusted in the JSON config file. + + For each zone available LEDs can be set as `On = true` or `Off = false` when + * Booting + * Awake (Normal Usage) + * Sleeping + * Shutdown / Power Off +\*-------------------------------------------------------------------*/ + +RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController *controller_ptr) +{ + controller = controller_ptr; + + name = "Asus Aura Core Laptop"; + vendor = "Asus"; + type = DEVICE_TYPE_KEYBOARD; + description = controller->GetDeviceName(); + serial = controller->GetSerial(); + location = controller->GetLocation(); + + mode Direct; + Direct.name = "Direct"; + Direct.value = ASUSAURACORELAPTOP_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 = ASUSAURACORELAPTOP_MODE_STATIC; + Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS; + Static.colors_min = 1; + Static.colors_max = 1; + Static.colors.resize(Static.colors_max); + Static.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN; + Static.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Static.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Static.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST; + Static.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST; + Static.color_mode = MODE_COLORS_MODE_SPECIFIC; + Static.speed = ASUSAURACORELAPTOP_SPEED_NORMAL; + modes.push_back(Static); + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = ASUSAURACORELAPTOP_MODE_BREATHING; + Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; + Breathing.colors_min = 1; + Breathing.colors_max = 2; + Breathing.colors.resize(Breathing.colors_min); + Breathing.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN; + Breathing.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Breathing.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Breathing.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST; + Breathing.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST; + Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; + Breathing.speed = ASUSAURACORELAPTOP_SPEED_NORMAL; + modes.push_back(Breathing); + + mode Flashing; + Flashing.name = "Flashing"; + Flashing.value = ASUSAURACORELAPTOP_MODE_FLASHING; + Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; + Flashing.colors_min = 1; + Flashing.colors_max = 1; + Flashing.colors.resize(Flashing.colors_max); + Flashing.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN; + Flashing.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Flashing.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Flashing.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST; + Flashing.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST; + Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC; + Flashing.speed = ASUSAURACORELAPTOP_SPEED_NORMAL; + modes.push_back(Flashing); + + mode Spectrum; + Spectrum.name = "Spectrum Cycle"; + Spectrum.value = ASUSAURACORELAPTOP_MODE_SPECTRUM; + Spectrum.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS; + Spectrum.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN; + Spectrum.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Spectrum.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Spectrum.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST; + Spectrum.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST; + Spectrum.color_mode = MODE_COLORS_NONE; + Spectrum.speed = ASUSAURACORELAPTOP_SPEED_NORMAL; + modes.push_back(Spectrum); + + mode Rainbow; + Rainbow.name = "Rainbow Wave"; + Rainbow.value = ASUSAURACORELAPTOP_MODE_RAINBOW; + Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD; + Rainbow.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN; + Rainbow.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Rainbow.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Rainbow.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST; + Rainbow.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST; + Rainbow.color_mode = MODE_COLORS_NONE; + Rainbow.speed = ASUSAURACORELAPTOP_SPEED_NORMAL; + modes.push_back(Rainbow); + + mode Starry; + Starry.name = "Starry Night"; + Starry.value = ASUSAURACORELAPTOP_MODE_STARRY_NIGHT; + Starry.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; + Starry.colors_min = 1; + Starry.colors_max = 2; + Starry.colors.resize(Starry.colors_min); + Starry.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN; + Starry.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Starry.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Starry.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST; + Starry.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST; + Starry.color_mode = MODE_COLORS_MODE_SPECIFIC; + Starry.speed = ASUSAURACORELAPTOP_SPEED_NORMAL; + modes.push_back(Starry); + + mode Rain; + Rain.name = "Rain"; + Rain.value = ASUSAURACORELAPTOP_MODE_RAIN; + Rain.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS; + Rain.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN; + Rain.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Rain.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Rain.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST; + Rain.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST; + Rain.color_mode = MODE_COLORS_NONE; + Rain.speed = ASUSAURACORELAPTOP_SPEED_NORMAL; + modes.push_back(Rain); + + mode ReactFade; + ReactFade.name = "Reactive - Fade"; + ReactFade.value = ASUSAURACORELAPTOP_MODE_REACT_FADE; + ReactFade.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; + ReactFade.colors_min = 1; + ReactFade.colors_max = 1; + ReactFade.colors.resize(ReactFade.colors_max); + ReactFade.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN; + ReactFade.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + ReactFade.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + ReactFade.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST; + ReactFade.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST; + ReactFade.color_mode = MODE_COLORS_MODE_SPECIFIC; + ReactFade.speed = ASUSAURACORELAPTOP_SPEED_NORMAL; + modes.push_back(ReactFade); + + mode ReactLaser; + ReactLaser.name = "Reactive - Laser"; + ReactLaser.value = ASUSAURACORELAPTOP_MODE_REACT_LASER; + ReactLaser.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; + ReactLaser.colors_min = 1; + ReactLaser.colors_max = 1; + ReactLaser.colors.resize(ReactLaser.colors_max); + ReactLaser.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN; + ReactLaser.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + ReactLaser.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + ReactLaser.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST; + ReactLaser.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST; + ReactLaser.color_mode = MODE_COLORS_MODE_SPECIFIC; + ReactLaser.speed = ASUSAURACORELAPTOP_SPEED_NORMAL; + modes.push_back(ReactLaser); + + mode ReactRipple; + ReactRipple.name = "Reactive - Ripple"; + ReactRipple.value = ASUSAURACORELAPTOP_MODE_REACT_RIPPLE; + ReactRipple.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS; + ReactRipple.colors_min = 1; + ReactRipple.colors_max = 1; + ReactRipple.colors.resize(ReactRipple.colors_max); + ReactRipple.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN; + ReactRipple.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + ReactRipple.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + ReactRipple.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST; + ReactRipple.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST; + ReactRipple.color_mode = MODE_COLORS_MODE_SPECIFIC; + ReactRipple.speed = ASUSAURACORELAPTOP_SPEED_NORMAL; + modes.push_back(ReactRipple); + + mode Comet; + Comet.name = "Comet"; + Comet.value = ASUSAURACORELAPTOP_MODE_COMET; + Comet.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR; + Comet.colors_min = 1; + Comet.colors_max = 1; + Comet.colors.resize(Comet.colors_max); + Comet.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN; + Comet.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Comet.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Comet.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST; + Comet.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST; + Comet.color_mode = MODE_COLORS_MODE_SPECIFIC; + Comet.speed = ASUSAURACORELAPTOP_SPEED_NORMAL; + modes.push_back(Comet); + + mode FlashNDash; + FlashNDash.name = "Flash N Dash"; + FlashNDash.value = ASUSAURACORELAPTOP_MODE_FLASHNDASH; + FlashNDash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR; + FlashNDash.colors_min = 1; + FlashNDash.colors_max = 1; + FlashNDash.colors.resize(FlashNDash.colors_max); + FlashNDash.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN; + FlashNDash.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + FlashNDash.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + FlashNDash.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST; + FlashNDash.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST; + FlashNDash.color_mode = MODE_COLORS_MODE_SPECIFIC; + FlashNDash.speed = ASUSAURACORELAPTOP_SPEED_NORMAL; + modes.push_back(FlashNDash); + + mode Keystone; + Keystone.name = "Keystone"; + Keystone.value = ASUSAURACORELAPTOP_MODE_KEYSTONE; + Keystone.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS; + Keystone.colors_min = 1; + Keystone.colors_max = 1; + Keystone.colors.resize(Keystone.colors_max); + Keystone.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN; + Keystone.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Keystone.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX; + Keystone.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST; + Keystone.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST; + Keystone.color_mode = MODE_COLORS_MODE_SPECIFIC; + Keystone.speed = ASUSAURACORELAPTOP_SPEED_NORMAL; + modes.push_back(Keystone); + + mode Off; + Off.name = "Off"; + Off.value = ASUSAURACORELAPTOP_MODE_OFF; + Off.color_mode = MODE_COLORS_NONE; + modes.push_back(Off); + + Init_Controller(); + SetupZones(); +} + +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; + 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; + zones.push_back(lid); +} + +void RGBController_AsusAuraCoreLaptop::SetupZones() +{ + /*-------------------------------------------------*\ + | Clear any existing color/LED configuration | + \*-------------------------------------------------*/ + leds.clear(); + colors.clear(); + + /*---------------------------------------------------------*\ + | Set up zones | + \*---------------------------------------------------------*/ + for(std::size_t zone_index = 0; zone_index < zones.size(); zone_index++) + { + int zone_offset = leds.size(); + + for(unsigned int led_index = 0; led_index < zones[zone_index].leds_count; led_index++) + { + led new_led; + new_led.value = led_index + zone_offset; + new_led.name = led_names[new_led.value]; + leds.push_back(new_led); + } + } + + SetupColors(); +} + +void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/) +{ + /*---------------------------------------------------------*\ + | This device does not support resizing zones | + \*---------------------------------------------------------*/ +} + +void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs() +{ + controller->SetLedsDirect(colors); +} + +void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int zone) +{ + std::vector colour; + for(size_t i = 0; i < zones[zone].leds_count; i++) + { + colour.push_back(zones[zone].colors[i]); + } + + controller->SetLedsDirect(colour); +} + +void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int led) +{ + std::vector colour; + colour.push_back(colors[led]); + + controller->SetLedsDirect(colour); +} + +void RGBController_AsusAuraCoreLaptop::SetCustomMode() +{ + active_mode = 0; +} + +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; + + controller->SetMode(set_mode.value, set_mode.speed, set_mode.brightness, color1, color2, random, set_mode.direction ); +} diff --git a/Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.h b/Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.h new file mode 100644 index 00000000..126cbb56 --- /dev/null +++ b/Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.h @@ -0,0 +1,36 @@ +/*---------------------------------------------------------------------*\ +| RGBController_AsusAuraCoreLaptop.h | +| | +| Driver for AsusAuraCoreLaptop USB Controller | +| | +| Chris M (Dr_No) 28 Jul 2022 | +| | +\*---------------------------------------------------------------------*/ + +#pragma once + +#include +#include "RGBController.h" +#include "AsusAuraCoreLaptopController.h" + +class RGBController_AsusAuraCoreLaptop : public RGBController +{ +public: + RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController* controller_ptr); + ~RGBController_AsusAuraCoreLaptop(); + + void SetupZones(); + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void SetCustomMode(); + void DeviceUpdateMode(); + +private: + void Init_Controller(); + + AsusAuraCoreLaptopController* controller; +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index 1992ae5f..a1e56668 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -255,7 +255,9 @@ HEADERS += Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController.h \ Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV2SMBus.h \ Controllers/AsusAuraCoreController/AsusAuraCoreController.h \ + Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.h \ Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.h \ + Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.h \ Controllers/AsusAuraGPUController/AsusAuraGPUController.h \ Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.h \ Controllers/AsusAuraUSBController/AsusAuraUSBController.h \ @@ -727,7 +729,9 @@ SOURCES += Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV2SMBus.cpp \ Controllers/AsusAuraCoreController/AsusAuraCoreController.cpp \ Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp \ + Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.cpp \ Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.cpp \ + Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.cpp \ Controllers/AsusAuraGPUController/AsusAuraGPUController.cpp \ Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp \ Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp \