From e0cffcfb3afbdee13f1fc66ad317e246515721bd Mon Sep 17 00:00:00 2001 From: Chris M Date: Wed, 4 Sep 2024 22:43:44 +1000 Subject: [PATCH] Migrated Asus Aura Core Laptop controller to the KLM * Added AsusAuraCoreLaptopDevices to record device metadata. * Adjusted AsusAuraCoreLaptopDevices to allow KLM layouts per zone * Modified RGBController_AsusAuraCoreLaptop to use KLM layouts. * Adjust AsusAuraCoreLaptopController to align with new data model * Other code changes to accomodate --- .../AsusAuraCoreControllerDetect.cpp | 2 - .../AsusAuraCoreLaptopController.cpp | 195 ++++++---- .../AsusAuraCoreLaptopController.h | 56 +-- .../AsusAuraCoreLaptopDevices.cpp | 307 ++++++++++++++++ .../AsusAuraCoreLaptopDevices.h | 50 +++ .../RGBController_AsusAuraCoreLaptop.cpp | 333 +++++++----------- .../RGBController_AsusAuraCoreLaptop.h | 6 +- 7 files changed, 666 insertions(+), 283 deletions(-) create mode 100644 Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.cpp create mode 100644 Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.h diff --git a/Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp b/Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp index 034ca01d..a3b877b7 100644 --- a/Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp +++ b/Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp @@ -19,8 +19,6 @@ #define AURA_CORE_VID 0x0B05 -#define AURA_STRIX_SCAR_15_PID 0x19B6 - /******************************************************************************************\ * * * DetectAuraCoreControllers * diff --git a/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.cpp b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.cpp index 602c0123..aeed424a 100644 --- a/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.cpp +++ b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.cpp @@ -10,45 +10,10 @@ \*---------------------------------------------------------*/ #include "AsusAuraCoreLaptopController.h" +#include "dmiinfo.h" #include "SettingsManager.h" #include "StringUtils.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", @@ -67,20 +32,40 @@ static std::string power_states[ASUSAURACORELAPTOP_POWER_STATES] = AsusAuraCoreLaptopController::AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path) { - dev = dev_handle; - location = path; + dev = dev_handle; + location = path; /*---------------------------------------------------------*\ - | Get device name from HID manufacturer and product strings | + | The motherboard name will uniquely ID the laptop to | + | determine the metadata of the device. | \*---------------------------------------------------------*/ - wchar_t name_string[HID_MAX_STR]; + DMIInfo dmi_info; + std::string dmi_name = dmi_info.getMainboard(); + bool not_found = true; - hid_get_manufacturer_string(dev, name_string, HID_MAX_STR); - device_name = StringUtils::wstring_to_string(name_string); + for(uint16_t i = 0; i < AURA_CORE_LAPTOP_DEVICE_COUNT; i++) + { + if(aura_core_laptop_device_list[i]->dmi_name == dmi_name) + { + /*---------------------------------------------------------*\ + | Set device ID | + \*---------------------------------------------------------*/ + not_found = false; + device_index = i; + break; + } + } - hid_get_product_string(dev, name_string, HID_MAX_STR); - device_name.append(" ").append(StringUtils::wstring_to_string(name_string)); + if(not_found) + { + LOG_ERROR("[%s] device capabilities not found. Please creata a new device request.", + dmi_name.c_str()); + return; + } + /*---------------------------------------------------------*\ + | Only set power config for known devices | + \*---------------------------------------------------------*/ SetPowerConfigFromJSON(); } @@ -89,9 +74,66 @@ AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController() hid_close(dev); } -std::string AsusAuraCoreLaptopController::GetDeviceName() +const aura_core_laptop_device* AsusAuraCoreLaptopController::GetDeviceData() { - return device_name; + return aura_core_laptop_device_list[device_index]; +} + +std::string AsusAuraCoreLaptopController::GetDeviceDescription() +{ + /*---------------------------------------------------------*\ + | Get device name from HID manufacturer and product strings | + \*---------------------------------------------------------*/ + wchar_t name_string[HID_MAX_STR]; + + hid_get_manufacturer_string(dev, name_string, HID_MAX_STR); + std::string name = StringUtils::wstring_to_string(name_string); + + hid_get_product_string(dev, name_string, HID_MAX_STR); + name.append(" ").append(StringUtils::wstring_to_string(name_string)); + return name; +} + +unsigned int AsusAuraCoreLaptopController::GetKeyboardLayout() +{ + const uint8_t index = 6; + uint8_t result = 0; + uint8_t rd_buf[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID }; + uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, + ASUSAURACORELAPTOP_CMD_LAYOUT, + 0x20, + 0x31, + 0x00, + 0x10 }; + + /*---------------------------------------------------------*\ + | Clear the read buffer to ensure we read the right packet | + \*---------------------------------------------------------*/ + do + { + result = hid_read_timeout(dev, rd_buf, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE, 10); + } + while(result > 0); + + memset(&rd_buf[1], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - 1); + memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index); + + hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE); + result = hid_get_feature_report(dev, rd_buf, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE); + + LOG_DEBUG("[%s] GetKeyboardLayout %02X %02X %02X %02X %02X %02X %02X {%02X} %02X %02X %02X %02X", + aura_core_laptop_device_list[device_index]->dmi_name.c_str(), + rd_buf[5], rd_buf[6], rd_buf[7], rd_buf[8], rd_buf[9], rd_buf[10], + rd_buf[11], rd_buf[12], rd_buf[13], rd_buf[14], rd_buf[15], rd_buf[16]); + + if(result > 0) + { + return rd_buf[12]; + } + + LOG_DEBUG("[%s] GetKeyboardLayout: An error occurred! Setting layout to ANSI", + aura_core_laptop_device_list[device_index]->dmi_name.c_str()); + return ASUSAURACORELAPTOP_LAYOUT_ANSI; } std::string AsusAuraCoreLaptopController::GetSerial() @@ -101,6 +143,8 @@ std::string AsusAuraCoreLaptopController::GetSerial() if(ret != 0) { + LOG_DEBUG("[%s] Get HID Serial string failed", + aura_core_laptop_device_list[device_index]->dmi_name.c_str()); return(""); } @@ -137,30 +181,30 @@ void AsusAuraCoreLaptopController::SetMode(uint8_t mode, uint8_t speed, uint8_t } } -void AsusAuraCoreLaptopController::SetLedsDirect(std::vector colors) +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; + const uint8_t key_set = 167; + const uint8_t led_count = colors.size(); + const uint16_t map_size = 3 * led_count; + const uint8_t leds_per_packet = 16; uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT, 0x00, 0x01, 0x01, 0x01, 0x00, leds_per_packet, 0x00 }; - uint8_t key_buf[map_size]; + uint8_t* key_buf = new uint8_t[map_size]; memset(key_buf, 0, map_size); - for(size_t led_index = 0; led_index < colors.size(); led_index++) + for(size_t led_index = 0; led_index < led_count; led_index++) { - uint16_t offset = 3 * packet_map[led_index]; + std::size_t buf_idx = (led_index * 3); - key_buf[offset] = RGBGetRValue(colors[led_index]); - key_buf[offset + 1] = RGBGetGValue(colors[led_index]); - key_buf[offset + 2] = RGBGetBValue(colors[led_index]); + key_buf[buf_idx] = RGBGetRValue(*colors[led_index]); + key_buf[buf_idx + 1] = RGBGetGValue(*colors[led_index]); + key_buf[buf_idx + 2] = RGBGetBValue(*colors[led_index]); } for(size_t i = 0; i < key_set; i+=leds_per_packet) @@ -170,11 +214,20 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector colors) if(leds_remaining < leds_per_packet) { buffer[07] = leds_remaining; + + memset(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], + 0, + ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - ASUSAURACORELAPTOP_DATA_BYTE); } buffer[06] = (uint8_t)i; memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * i], (3 * buffer[07])); + LOG_DEBUG("[%s] Sending buffer @ index %d thru index %d", + aura_core_laptop_device_list[device_index]->dmi_name.c_str(), + i, + i + buffer[07]); + hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE); } @@ -182,9 +235,25 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector colors) buffer[5] = 0x00; buffer[6] = 0x00; buffer[7] = 0x00; - memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * key_set], (3 * (led_count - key_set))); + + memset(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], + 0, + ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - ASUSAURACORELAPTOP_DATA_BYTE); + + if(led_count > key_set) + { + memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], + &key_buf[3 * key_set], + (3 * (led_count - key_set))); + } + + LOG_DEBUG("[%s] Sending buffer @ index %d thru index %d", + aura_core_laptop_device_list[device_index]->dmi_name.c_str(), + key_set, + led_count); hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE); + delete[] key_buf; } void AsusAuraCoreLaptopController::SendBrightness() @@ -283,6 +352,8 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON() device_settings[section_power] = pcfg; settings_manager->SetSettings(detector_name, device_settings); settings_manager->SaveSettings(); + LOG_DEBUG("[%s] default power config saved to openrgb.json", + aura_core_laptop_device_list[device_index]->dmi_name.c_str()); } else { @@ -293,7 +364,9 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON() if(device_settings[section_power].contains(key_name)) { power_config[i].state = device_settings[section_power][key_name]; - LOG_DEBUG("[%s] Reading power config for %s: %s", device_name.c_str(), key_name.c_str(), ((power_config[i].state) ? "On" : "Off")); + LOG_DEBUG("[%s] Reading power config for %s: %s", + aura_core_laptop_device_list[device_index]->dmi_name.c_str(), + key_name.c_str(), ((power_config[i].state) ? "On" : "Off")); } } } @@ -320,7 +393,9 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON() }; uint32_t flags = PackPowerFlags(flag_array); - LOG_DEBUG("[%s] Sending power config Logo+KB: %02X Lightbar: %02X Lid Edges: %02X Raw: %08X", device_name.c_str(), (flags & 0xFF), ((flags >> 8) & 0xFF), ((flags >> 16) & 0xFF), flags); + LOG_DEBUG("[%s] Sending power config Logo+KB: %02X Lightbar: %02X Lid Edges: %02X Raw: %08X", + aura_core_laptop_device_list[device_index]->dmi_name.c_str(), + (flags & 0xFF), ((flags >> 8) & 0xFF), ((flags >> 16) & 0xFF), flags); SendPowerConfig(flags); } diff --git a/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.h b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.h index e3cc0d92..daab5dae 100644 --- a/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.h +++ b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.h @@ -18,6 +18,7 @@ #include "RGBController.h" #include "ResourceManager.h" #include "RGBControllerKeyNames.h" +#include "AsusAuraCoreLaptopDevices.h" #define NA 0xFFFFFFFF #define HID_MAX_STR 255 @@ -83,6 +84,7 @@ enum ASUSAURACORELAPTOP_CMD_UPDATE = 0xB3, ASUSAURACORELAPTOP_CMD_APPLY = 0xB4, ASUSAURACORELAPTOP_CMD_SET = 0xB5, + ASUSAURACORELAPTOP_CMD_LAYOUT = 0x05, }; enum @@ -92,6 +94,12 @@ enum ASUSAURACORELAPTOP_SPEED_FASTEST = 0xF5, // Fastest speed }; +enum aura_core_laptop_layout +{ + ASUSAURACORELAPTOP_LAYOUT_ANSI = 0x01, /* US ANSI Layout */ + ASUSAURACORELAPTOP_LAYOUT_ISO = 0x02, /* EURO ISO Layout */ +}; + struct p_state { std::string zone; @@ -104,33 +112,35 @@ public: AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path); ~AsusAuraCoreLaptopController(); - std::string GetDeviceName(); - std::string GetSerial(); - std::string GetLocation(); + const aura_core_laptop_device* GetDeviceData(); + std::string GetDeviceDescription(); + std::string GetSerial(); + unsigned int GetKeyboardLayout(); + std::string GetLocation(); - void SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction); - void SetLedsDirect(std::vector colors); + void SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction); + void SetLedsDirect(std::vectorcolors); private: - std::string device_name; - std::string location; - hid_device* dev; + hid_device* dev; + uint16_t device_index; + std::string location; - uint8_t current_mode; - uint8_t current_speed; - uint8_t current_direction; + uint8_t current_mode; + uint8_t current_speed; + uint8_t current_direction; - RGBColor current_c1; - RGBColor current_c2; - uint8_t current_brightness; - uint8_t current_random; + RGBColor current_c1; + RGBColor current_c2; + uint8_t current_brightness; + uint8_t current_random; - void SendApply(); - void SendBrightness(); - void SendSet(); - void SendUpdate(); + void SendApply(); + void SendBrightness(); + void SendSet(); + void SendUpdate(); - void SetPowerConfigFromJSON(); - void SendPowerConfig(uint32_t flags); - uint32_t PackPowerFlags(bool flags[]); - std::vector PowerConfigArray(); + void SetPowerConfigFromJSON(); + void SendPowerConfig(uint32_t flags); + uint32_t PackPowerFlags(bool flags[]); + std::vector PowerConfigArray(); }; diff --git a/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.cpp b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.cpp new file mode 100644 index 00000000..c574d79a --- /dev/null +++ b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.cpp @@ -0,0 +1,307 @@ +#include "AsusAuraCoreLaptopDevices.h" + +/*-------------------------------------------------------------------------*\ +| Aura Core Key Values | +| NULL values are keys that are handed to the KLM but are removed as | +| a part of customisation. They are included to maintain expected key | +| count is aligned to the value count. | +\*-------------------------------------------------------------------------*/ + +std::vector aura_core_laptop_15_values = +{ + /* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 DEL */ + 21, 23, 24, 25, 26, 28, 29, 30, 31, 33, 34, 35, 36, + /* BKTK 1 2 3 4 5 6 7 8 9 0 - = BSPC PLAY */ + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + /* TAB Q W E R T Y U I O P [ ] \ STOP */ + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + /* CPLK A S D F G H J K L ; " # ENTR PREV */ + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 98, + /* LSFT ISO\ Z X C V B N M , . / RSFT ARWU NEXT */ + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 119, + /* LCTL LWIN LALT SPC RALT RFNC RMNU RCTL ARWL ARWD ARWR */ + 126, 128, 129, 131, 135, 136, 136, 137, +}; + +std::vector aura_core_laptop_17_values = +{ + /* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 NULL NULL PAUS */ + 21, 23, 24, 25, 26, 28, 29, 30, 31, 33, 34, 35, 36, 0, 0, 39, + /* BKTK 1 2 3 4 5 6 7 8 9 0 - = BSPC NULL NULL NULL NMLK NMDV NMTM NMMI */ + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 56, 0, 0, 0, 59, 60, 61, 62, + /* TAB Q W E R T Y U I O P [ ] \ NULL NULL NULL NM7 NM8 NM9 NMPL */ + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 0, 0, 0, 80, 81, 82, 83, + /* CPLK A S D F G H J K L ; " # ENTR NM4 NM5 NM6 */ + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 98, 101, 102, 103, + /* LSFT ISO\ Z X C V B N M , . / RSFT ARWU NM1 NM2 NM3 NMER */ + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 119, 139, 122, 123, 124, 125, + /* LCTL LWIN LALT SPC RALT RFNC RMNU RCTL ARWL ARWD ARWR NM0 NMPD */ + 126, 128, 129, 131, 135, 136, 136, 137, 159, 160, 161, 144, 145, +}; + +/*-------------------------------------------------------------------------*\ +| KEYMAPS | +\*-------------------------------------------------------------------------*/ +keyboard_keymap_overlay_values g533zm_layout +{ + KEYBOARD_SIZE_SEVENTY_FIVE, + { + aura_core_laptop_15_values, + { + /* Add more regional layout fixes here */ + } + }, + { + /*---------------------------------------------------------------------------------------------------------*\ + | Edit Keys | + | Zone, Row, Column, Value, Key, OpCode, | + \*---------------------------------------------------------------------------------------------------------*/ + { 0, 0, 15, 37, KEY_EN_DELETE, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Delete + { 0, 1, 15, 58, KEY_EN_MEDIA_PLAY_PAUSE, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Play / Pause + { 0, 2, 15, 79, KEY_EN_MEDIA_STOP, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Play / Pause + { 0, 3, 15, 100, KEY_EN_MEDIA_PREVIOUS, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Play / Pause + { 0, 4, 13, 139, KEY_EN_UP_ARROW, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Up Arrow + { 0, 4, 15, 121, KEY_EN_MEDIA_NEXT, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Play / Pause + { 0, 5, 12, 159, KEY_EN_LEFT_ARROW, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Left Arrow + { 0, 5, 13, 160, KEY_EN_DOWN_ARROW, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Down Arrow + { 0, 5, 14, 161, KEY_EN_RIGHT_ARROW, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Right Arrow + } +}; + +keyboard_keymap_overlay_values g713rw_keyboard_layout +{ + KEYBOARD_SIZE_FULL, + { + aura_core_laptop_17_values, + { + /* Add more regional layout fixes here */ + } + }, + { + /*---------------------------------------------------------------------------------------------------------*\ + | Edit Keys | + | Zone, Row, Column, Value, Key, OpCode, | + \*---------------------------------------------------------------------------------------------------------*/ + { 0, 0, 2, 2, KEY_EN_MEDIA_VOLUME_DOWN, KEYBOARD_OPCODE_INSERT_ROW, }, // Insert Row and add Volume Down + { 0, 0, 3, 3, KEY_EN_MEDIA_VOLUME_UP, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Volume Up + { 0, 0, 4, 4, KEY_EN_MEDIA_MUTE, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Mute + { 0, 0, 5, 5, "Key: Sun", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert "Sun" key + { 0, 0, 6, 6, "Key: ROG", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert "ROG" key + { 0, 6, 1, 127, KEY_EN_LEFT_FUNCTION, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Left Fuction + { 0, 6, 12, 136, KEY_EN_RIGHT_FUNCTION, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, }, // Remove Right Fuction + { 0, 6, 12, 136, KEY_EN_RIGHT_WINDOWS, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, }, // Remove Right Win Key + { 0, 1, 14, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_SWAP_ONLY, }, + { 0, 1, 15, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_SWAP_ONLY, }, + { 0, 1, 16, 38, KEY_EN_DELETE, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert a Delete key + { 0, 1, 18, 40, KEY_EN_PRINT_SCREEN, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert a Print Screen key + { 0, 1, 19, 41, KEY_EN_HOME, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert a Home key + { 0, 2, 14, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, }, + { 0, 2, 14, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_SWAP_ONLY, }, + { 0, 2, 15, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_SWAP_ONLY, }, + { 0, 3, 14, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, }, + { 0, 3, 14, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_SWAP_ONLY, }, + { 0, 3, 15, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_SWAP_ONLY, }, + { 0, 4, 16, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, }, + { 0, 5, 14, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, }, + { 0, 6, 16, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, }, + } +}; + +keyboard_keymap_overlay_values g713rw_lightbar_layout +{ + KEYBOARD_SIZE_EMPTY, + { + { /* Values not set in empty keyboard */ }, + { + /* Add more regional layout fixes here */ + } + }, + { + /*---------------------------------------------------------------------------------------------------------*\ + | Edit Keys | + | Zone, Row, Column, Value, Key, OpCode, | + \*---------------------------------------------------------------------------------------------------------*/ + { 0, 0, 0, 126, "Lightbar L1", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Lightbar L1 + { 0, 0, 1, 127, "Lightbar L2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Lightbar L2 + { 0, 0, 2, 128, "Lightbar L3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Lightbar L3 + { 0, 0, 3, 144, "Lightbar R3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Lightbar R3 + { 0, 0, 4, 145, "Lightbar R2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Lightbar R2 + { 0, 0, 5, 125, "Lightbar R1", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Lightbar R1 + } +}; + +keyboard_keymap_overlay_values g713rw_test_layout +{ + KEYBOARD_SIZE_EMPTY, + { + { /* Values not set in empty keyboard */ }, + { + /* Add more regional layout fixes here */ + } + }, + { + /*---------------------------------------------------------------------------------------------------------*\ + | Edit Keys | + | Zone, Row, Column, Value, Key, OpCode, | + \*---------------------------------------------------------------------------------------------------------*/ + { 0, 0, 0, 7, "Test01", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 1, 8, "Test02", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 2, 9, "Test03", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 3, 10, "Test04", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 4, 11, "Test05", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 5, 12, "Test06", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 6, 13, "Test07", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 7, 14, "Test08", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 8, 15, "Test09", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 9, 16, "Test10", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 10, 17, "Test11", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 11, 18, "Test12", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 12, 19, "Test13", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 13, 20, "Test14", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 14, 22, "Test15", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 15, 27, "Test16", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 16, 55, "Test17", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 17, 57, "Test18", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 18, 58, "Test19", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 19, 77, "Test20", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 20, 78, "Test21", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 21, 79, "Test22", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 22, 96, "Test23", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 23, 97, "Test24", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 24, 99, "Test25", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 25, 100, "Test26", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 26, 104, "Test27", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 27, 117, "Test28", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 28, 118, "Test29", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 29, 120, "Test30", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 30, 121, "Test31", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 31, 130, "Test32", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 32, 132, "Test33", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 33, 133, "Test34", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 34, 134, "Test35", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 35, 138, "Test36", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 36, 140, "Test37", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 37, 141, "Test38", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 38, 142, "Test39", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 39, 143, "Test40", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 40, 146, "Test41", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 41, 147, "Test42", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 42, 148, "Test43", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 43, 149, "Test44", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 44, 150, "Test45", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 45, 151, "Test46", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 46, 152, "Test47", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 47, 153, "Test48", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 48, 154, "Test49", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 49, 155, "Test50", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 50, 156, "Test51", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 51, 157, "Test52", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 52, 158, "Test53", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 53, 162, "Test54", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 54, 163, "Test55", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 55, 164, "Test56", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 56, 165, "Test57", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 57, 166, "Test58", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + { 0, 0, 58, 167, "Test59", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, + } +}; + +keyboard_keymap_overlay_values g733zm_layout +{ + KEYBOARD_SIZE_FULL, + { + aura_core_laptop_17_values, + { + /* Add more regional layout fixes here */ + } + }, + { + /*---------------------------------------------------------------------------------------------------------*\ + | Edit Keys | + | Zone, Row, Column, Value, Key, OpCode, | + \*---------------------------------------------------------------------------------------------------------*/ + } +}; + +/*-------------------------------------------------------------------------*\ +| AURA CORE LAPTOP DEVICES | +\*-------------------------------------------------------------------------*/ + +/*-------------------------------------------------------------*\ +| ASUS ROG Strix SCAR 15 | +| | +| Zone "Keyboard" | +| Matrix | +| 7 Rows, 16 Columns | +\*-------------------------------------------------------------*/ +static const aura_core_laptop_zone g533zm_zone = +{ + ZONE_EN_KEYBOARD, + &g533zm_layout +}; + +static const aura_core_laptop_device g533zm_device = +{ + "G533ZM", + { + &g533zm_zone, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr + } +}; + +/*-------------------------------------------------------------*\ +| ASUS ROG Strix SCAR G713RW | +| | +| Zone "Keyboard" | +| Matrix | +| 7 Rows, 20 Columns | +\*-------------------------------------------------------------*/ +static const aura_core_laptop_zone g713rw_keyboard_zone = +{ + ZONE_EN_KEYBOARD, + &g713rw_keyboard_layout +}; + +static const aura_core_laptop_zone g713rw_lightbar_zone = +{ + "Lightbar", + &g713rw_lightbar_layout +}; + +static const aura_core_laptop_zone g713rw_test_zone = +{ + "TEST", + &g713rw_test_layout +}; + +static const aura_core_laptop_device g713rw_device = +{ + "G713RW", + { + &g713rw_keyboard_zone, + &g713rw_lightbar_zone, + &g713rw_test_zone, + nullptr, + nullptr, + nullptr + } +}; + +/*-------------------------------------------------------------------------*\ +| DEVICE MASTER LIST | +\*-------------------------------------------------------------------------*/ +const aura_core_laptop_device* aura_core_laptop_device_list_data[] = +{ +/*-----------------------------------------------------------------*\ +| KEYBOARDS | +\*-----------------------------------------------------------------*/ + &g533zm_device, + &g713rw_device, +}; + +const unsigned int AURA_CORE_LAPTOP_DEVICE_COUNT = (sizeof(aura_core_laptop_device_list_data) / sizeof(aura_core_laptop_device_list_data[ 0 ])); +const aura_core_laptop_device** aura_core_laptop_device_list = aura_core_laptop_device_list_data; diff --git a/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.h b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.h new file mode 100644 index 00000000..d030db6d --- /dev/null +++ b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.h @@ -0,0 +1,50 @@ +#pragma once + +#include +#include +#include "RGBController.h" +#include "RGBControllerKeyNames.h" +#include "KeyboardLayoutManager.h" + +#define AURA_CORE_LAPTOP_ZONES_MAX 6 + +enum aura_core_kb_layout +{ + AURA_CORE_LAPTOP_KB_LAYOUT_ANSI = 0x01, /* US ANSI Layout */ + AURA_CORE_LAPTOP_KB_LAYOUT_ISO = 0x02, /* EURO ISO Layout */ + AURA_CORE_LAPTOP_KB_LAYOUT_ABNT = 0x03, /* Brazilian Layout */ + AURA_CORE_LAPTOP_KB_LAYOUT_JIS = 0x04, /* Japanese Layout */ +}; + +typedef struct +{ + std::string name; + keyboard_keymap_overlay_values* layout_new; +} aura_core_laptop_zone; + +typedef struct +{ + uint8_t zone; + uint8_t row; + uint8_t col; + uint8_t index; + const char* name; +} aura_core_laptop_led; + +typedef struct +{ + std::string dmi_name; + const aura_core_laptop_zone* zones[AURA_CORE_LAPTOP_ZONES_MAX]; +} aura_core_laptop_device; + +/*-----------------------------------------------------*\ +| Aura Core Laptop Protocol Keyboards | +\*-----------------------------------------------------*/ +#define AURA_STRIX_SCAR_15_PID 0x19B6 + +/*-----------------------------------------------------*\ +| These constant values are defined in | +| AsusAuraCoreLaptopDevices.cpp | +\*-----------------------------------------------------*/ +extern const unsigned int AURA_CORE_LAPTOP_DEVICE_COUNT; +extern const aura_core_laptop_device** aura_core_laptop_device_list; diff --git a/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp index dd049338..0ad2d67b 100644 --- a/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp +++ b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp @@ -11,129 +11,6 @@ #include "RGBController_AsusAuraCoreLaptop.h" -static unsigned int matrix_map[ASUSAURACORELAPTOP_KEY_HEIGHT][ASUSAURACORELAPTOP_KEY_WIDTH] = -{ - { NA, NA, 86, 87, 88, 89, 90, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA }, - { 0, NA, 1, 2, 3, 4, NA, 5, 6, 7, 8, NA, 9, 10, 11, 12, 13, NA }, - { 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, NA }, - { 31, NA, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, NA, 45, NA }, - { 46, NA, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, NA, 58, NA, 59, NA }, - { 60, NA, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, NA, 72, NA, 73, NA }, - { 74, 75, 76, 77, NA, NA, NA, 78, NA, NA, NA, 79, 80, 81, 82, 83, 84, 85 } -}; - -static const char *led_names[] = -{ - KEY_EN_ESCAPE, //00 - KEY_EN_F1, - KEY_EN_F2, - KEY_EN_F3, - KEY_EN_F4, - KEY_EN_F5, - KEY_EN_F6, - KEY_EN_F7, - KEY_EN_F8, - KEY_EN_F9, - KEY_EN_F10, //10 - KEY_EN_F11, - KEY_EN_F12, - KEY_EN_DELETE, - - KEY_EN_BACK_TICK, - KEY_EN_1, - KEY_EN_2, - KEY_EN_3, - KEY_EN_4, - KEY_EN_5, - KEY_EN_6, //20 - KEY_EN_7, - KEY_EN_8, - KEY_EN_9, - KEY_EN_0, - KEY_EN_MINUS, - KEY_EN_EQUALS, - KEY_EN_BACKSPACE, - KEY_EN_BACKSPACE, - KEY_EN_BACKSPACE, - KEY_EN_MEDIA_PLAY_PAUSE, //30 - - KEY_EN_TAB, - KEY_EN_Q, - KEY_EN_W, - KEY_EN_E, - KEY_EN_R, - KEY_EN_T, - KEY_EN_Y, - KEY_EN_U, - KEY_EN_I, - KEY_EN_O, //40 - KEY_EN_P, - KEY_EN_LEFT_BRACKET, - KEY_EN_RIGHT_BRACKET, - KEY_EN_ANSI_BACK_SLASH, - KEY_EN_MEDIA_STOP, - - KEY_EN_CAPS_LOCK, - KEY_EN_A, - KEY_EN_S, - KEY_EN_D, - KEY_EN_F, //50 - KEY_EN_G, - KEY_EN_H, - KEY_EN_J, - KEY_EN_K, - KEY_EN_L, - KEY_EN_SEMICOLON, - KEY_EN_QUOTE, - KEY_EN_ANSI_ENTER, - KEY_EN_MEDIA_PREVIOUS, - - KEY_EN_LEFT_SHIFT, //60 - KEY_EN_Z, - KEY_EN_X, - KEY_EN_C, - KEY_EN_V, - KEY_EN_B, - KEY_EN_N, - KEY_EN_M, - KEY_EN_COMMA, - KEY_EN_PERIOD, - KEY_EN_FORWARD_SLASH, //70 - KEY_EN_RIGHT_SHIFT, - KEY_EN_UP_ARROW, - KEY_EN_MEDIA_NEXT, - - KEY_EN_LEFT_CONTROL, - KEY_EN_LEFT_FUNCTION, - KEY_EN_LEFT_WINDOWS, - KEY_EN_LEFT_ALT, - KEY_EN_SPACE, - KEY_EN_RIGHT_ALT, - KEY_EN_RIGHT_CONTROL, //80 - KEY_EN_LEFT_ARROW, - KEY_EN_DOWN_ARROW, - KEY_EN_RIGHT_ARROW, - KEY_EN_PRINT_SCREEN, - "Asus Keystone", - - KEY_EN_MEDIA_VOLUME_DOWN, - KEY_EN_MEDIA_VOLUME_UP, - "Key: Mic On/Off", - "Key: HyperFan", - "Key: Armoury Crate", //90 - - "Lightbar LED 1", - "Lightbar LED 2", - "Lightbar LED 3", - "Lightbar LED 4", - "Lightbar LED 5", - "Lightbar LED 6", - - "Logo", - "Lid Left", - "Lid Right", //99 -}; - /**------------------------------------------------------------------*\ @name AsusAuraCoreLaptop @category DEVICE_TYPE_KEYBOARD @@ -154,14 +31,15 @@ static const char *led_names[] = RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController *controller_ptr) { - controller = controller_ptr; + controller = controller_ptr; + const aura_core_laptop_device* aura_dev = controller->GetDeviceData(); - name = "Asus Aura Core Laptop"; - vendor = "Asus"; - type = DEVICE_TYPE_KEYBOARD; - description = controller->GetDeviceName(); - serial = controller->GetSerial(); - location = controller->GetLocation(); + name = aura_dev->dmi_name; + vendor = "Asus"; + type = DEVICE_TYPE_KEYBOARD; + description = controller->GetDeviceDescription(); + serial = controller->GetSerial(); + location = controller->GetLocation(); mode Direct; Direct.name = "Direct"; @@ -375,7 +253,6 @@ RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreL Off.color_mode = MODE_COLORS_NONE; modes.push_back(Off); - Init_Controller(); SetupZones(); } @@ -384,70 +261,131 @@ RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop() delete controller; } -void RGBController_AsusAuraCoreLaptop::Init_Controller() -{ - /*-------------------------------------------------*\ - | Create the keyboard zone and add the matix map | - \*-------------------------------------------------*/ - zone KB_zone; - KB_zone.name = "Keyboard Zone"; - KB_zone.type = ZONE_TYPE_MATRIX; - KB_zone.leds_min = ASUSAURACORELAPTOP_KEYCOUNT; - KB_zone.leds_max = ASUSAURACORELAPTOP_KEYCOUNT; - KB_zone.leds_count = ASUSAURACORELAPTOP_KEYCOUNT; - - KB_zone.matrix_map = new matrix_map_type; - KB_zone.matrix_map->height = ASUSAURACORELAPTOP_KEY_HEIGHT; - KB_zone.matrix_map->width = ASUSAURACORELAPTOP_KEY_WIDTH; - KB_zone.matrix_map->map = (unsigned int *)&matrix_map; - zones.push_back(KB_zone); - - zone lightbar; - lightbar.name = "Lightbar Zone"; - lightbar.type = ZONE_TYPE_LINEAR; - lightbar.leds_min = ASUSAURACORELAPTOP_LIGHTBARCOUNT; - lightbar.leds_max = ASUSAURACORELAPTOP_LIGHTBARCOUNT; - lightbar.leds_count = ASUSAURACORELAPTOP_LIGHTBARCOUNT; - lightbar.matrix_map = NULL; - - zones.push_back(lightbar); - - zone lid; - lid.name = "Lid Zone"; - lid.type = ZONE_TYPE_LINEAR; - lid.leds_min = ASUSAURACORELAPTOP_LIDCOUNT; - lid.leds_max = ASUSAURACORELAPTOP_LIDCOUNT; - lid.leds_count = ASUSAURACORELAPTOP_LIDCOUNT; - lid.matrix_map = NULL; - - zones.push_back(lid); -} - void RGBController_AsusAuraCoreLaptop::SetupZones() { - /*-------------------------------------------------*\ - | Clear any existing color/LED configuration | - \*-------------------------------------------------*/ - leds.clear(); - colors.clear(); + std::string physical_size; + KEYBOARD_LAYOUT new_layout; + unsigned int max_led_value = 0; + + const aura_core_laptop_device* aura_dev = controller->GetDeviceData(); + unsigned int layout = controller->GetKeyboardLayout(); + + switch(layout) + { + case ASUSAURACORELAPTOP_LAYOUT_ISO: + new_layout = KEYBOARD_LAYOUT_ISO_QWERTY; + break; + + case ASUSAURACORELAPTOP_LAYOUT_ANSI: + default: + new_layout = KEYBOARD_LAYOUT_ANSI_QWERTY; + break; + } + LOG_DEBUG("[%s] layout set as %d", description.c_str(), new_layout); /*---------------------------------------------------------*\ - | Set up zones | + | Fill in zones from the device data | \*---------------------------------------------------------*/ - for(std::size_t zone_index = 0; zone_index < zones.size(); zone_index++) + for(size_t i = 0; i < AURA_CORE_LAPTOP_ZONES_MAX; i++) { - int zone_offset = (int)leds.size(); + LOG_DEBUG("[%s] setting up zone %d", description.c_str(), i); - for(unsigned int led_index = 0; led_index < zones[zone_index].leds_count; led_index++) + if(aura_dev->zones[i] == NULL) { - led new_led; - new_led.value = led_index + zone_offset; - new_led.name = led_names[new_led.value]; - leds.push_back(new_led); + break; + } + else + { + zone new_zone; + + new_zone.name = aura_dev->zones[i]->name; + + if(aura_dev->zones[i]->layout_new != NULL) + { + KeyboardLayoutManager new_kb(new_layout, + aura_dev->zones[i]->layout_new->base_size, + aura_dev->zones[i]->layout_new->key_values); + + if(aura_dev->zones[i]->layout_new->base_size != KEYBOARD_SIZE_EMPTY || + aura_dev->zones[i]->layout_new->edit_keys.size() > 0) + { + /*---------------------------------------------------------*\ + | Minor adjustments to keyboard layout | + \*---------------------------------------------------------*/ + keyboard_keymap_overlay_values* temp = aura_dev->zones[i]->layout_new; + new_kb.ChangeKeys(*temp); + + if(new_kb.GetRowCount() == 1 || new_kb.GetColumnCount() == 1) + { + if(new_kb.GetKeyCount() == 1) + { + new_zone.type = ZONE_TYPE_SINGLE; + } + else + { + new_zone.type = ZONE_TYPE_LINEAR; + } + } + else + { + new_zone.type = ZONE_TYPE_MATRIX; + matrix_map_type * new_map = new matrix_map_type; + new_zone.matrix_map = new_map; + + /*---------------------------------------------------------*\ + | Trusting the layout handed to the KLM is correct use the | + | row & column counts to set the matrix height & width | + \*---------------------------------------------------------*/ + new_map->height = new_kb.GetRowCount(); + new_map->width = new_kb.GetColumnCount(); + new_map->map = new unsigned int[new_map->height * new_map->width]; + + new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT); + } + + /*---------------------------------------------------------*\ + | Create LEDs for the Matrix zone | + | Place keys in the layout to populate the matrix | + \*---------------------------------------------------------*/ + new_zone.leds_count = new_kb.GetKeyCount(); + for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++) + { + led new_led; + + new_led.name = new_kb.GetKeyNameAt(led_idx); + new_led.value = new_kb.GetKeyValueAt(led_idx); + max_led_value = std::max(max_led_value, new_led.value); + leds.push_back(new_led); + } + } + + /*---------------------------------------------------------*\ + | Add 1 the max_led_value to account for the 0th index | + \*---------------------------------------------------------*/ + max_led_value++; + } + + LOG_DEBUG("[%s] Creating a %s zone: %s with %d LEDs", name.c_str(), + ((new_zone.type == ZONE_TYPE_MATRIX) ? "matrix": "linear"), + new_zone.name.c_str(), new_zone.leds_count); + new_zone.leds_min = new_zone.leds_count; + new_zone.leds_max = new_zone.leds_count; + zones.push_back(new_zone); } } SetupColors(); + + /*---------------------------------------------------------*\ + | Create a buffer map of pointers which contains the | + | layout order of colors the device expects. | + \*---------------------------------------------------------*/ + buffer_map.resize(max_led_value, &null_color); + + for(size_t led_idx = 0; led_idx < leds.size(); led_idx++) + { + buffer_map[leds[led_idx].value] = &colors[led_idx]; + } } void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/) @@ -459,26 +397,29 @@ void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/ 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++) + for(size_t i = 85; i < leds.size(); i++) { - colour.push_back(zones[zone].colors[i]); + LOG_DEBUG("[%s] Setting %s @ LED index %d and buffer index %d to R: %02X G: %02X B: %02X", + name.c_str(), + leds[i].name.c_str(), + i, + leds[i].value, + RGBGetRValue(colors[i]), + RGBGetGValue(colors[i]), + RGBGetBValue(colors[i])); } - controller->SetLedsDirect(colour); + controller->SetLedsDirect(buffer_map); } -void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int led) +void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int /*zone*/) { - std::vector colour; - colour.push_back(colors[led]); + controller->SetLedsDirect(buffer_map); +} - controller->SetLedsDirect(colour); +void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int /*led*/) +{ + controller->SetLedsDirect(buffer_map); } void RGBController_AsusAuraCoreLaptop::DeviceUpdateMode() diff --git a/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.h b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.h index 3ff29bd7..16e40a65 100644 --- a/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.h +++ b/Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.h @@ -11,6 +11,7 @@ #pragma once +#include #include #include "RGBController.h" #include "AsusAuraCoreLaptopController.h" @@ -31,7 +32,8 @@ public: void DeviceUpdateMode(); private: - void Init_Controller(); + RGBColor null_color = 0; + std::vector buffer_map; - AsusAuraCoreLaptopController* controller; + AsusAuraCoreLaptopController* controller; };