jalr/OpenRGB
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

support for asus rog claymore to resolve #923

Browse source
This commit is contained in:
Mola19 2022-05-18 00:23:07 +02:00 • committed by Adam Honse
parent 3146d8def4
commit 5c0660091f
6 changed files with 1751 additions and 644 deletions
Download patch file Download diff file Expand all files Collapse all files

395
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp
View file

@ -17,11 +17,12 @@
#include <string.h>
#include <cmath>
AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid)
AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short rev_version)
{
dev = dev_handle;
location = path;
device_pid = pid;
version = rev_version;
}
AuraTUFKeyboardController::~AuraTUFKeyboardController()
@ -52,44 +53,131 @@ std::string AuraTUFKeyboardController::GetSerialString()
std::string AuraTUFKeyboardController::GetVersion()
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x12;
usb_buf[0x02] = 0x00;
hid_write(dev, usb_buf, 65);
unsigned char usb_buf_out[65];
hid_read(dev, usb_buf_out, 65);
char version[9];
if (device_pid == AURA_TUF_K3_GAMING_PID)
if(device_pid != AURA_ROG_CLAYMORE_PID)
{
snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x12;
usb_buf[0x02] = 0x00;
ClearResponses();
hid_write(dev, usb_buf, 65);
unsigned char usb_buf_out[65];
hid_read(dev, usb_buf_out, 65);
char version[9];
if(device_pid == AURA_TUF_K3_GAMING_PID)
{
snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
}
else
{
snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
}
return std::string(version);
}
else
{
snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x10;
usb_buf[0x02] = 0x01;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = 0x00; // set to 1 to get firmware version of numpad
ClearResponses();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
unsigned char usb_buf1[65];
memset(usb_buf1, 0x00, sizeof(usb_buf1));
usb_buf1[0x00] = 0x00;
usb_buf1[0x01] = 0x12;
usb_buf1[0x02] = 0x22;
ClearResponses();
hid_write(dev, usb_buf1, 65);
unsigned char usb_buf_out[65];
hid_read(dev, usb_buf_out, 65);
char version[9];
snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[8], usb_buf_out[9], usb_buf_out[10]);
return std::string(version);
}
return std::string(version);
}
int AuraTUFKeyboardController::GetLayout()
{
if(device_pid != AURA_ROG_CLAYMORE_PID)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x12;
usb_buf[0x02] = 0x12;
ClearResponses();
hid_write(dev, usb_buf, 65);
unsigned char usb_buf_out[65];
hid_read(dev, usb_buf_out, 65);
return(usb_buf_out[4] * 100 + usb_buf_out[5]);
}
else
{
char layout[] = "";
sprintf(layout, "%X", version);
int layoutnum = std::stoi(std::string(layout, 1));
switch(layoutnum)
{
case 1:
return 117;
case 2:
return 204;
case 3:
return 221;
case 4:
return 117;
default:
return 117;
}
}
}
/*---------------------------------------------------------*\
| only needed for Claymore |
\*---------------------------------------------------------*/
int AuraTUFKeyboardController::GetNumpadLocation()
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x12;
usb_buf[0x02] = 0x12;
usb_buf[0x01] = 0x40;
usb_buf[0x02] = 0x60;
ClearResponses();
hid_write(dev, usb_buf, 65);
unsigned char usb_buf_out[65];
hid_read(dev, usb_buf_out, 65);
return(usb_buf_out[4] * 100 + usb_buf_out[5]);
return(usb_buf_out[5] * 2 + usb_buf_out[4]);
}
void AuraTUFKeyboardController::SaveMode()
@ -102,7 +190,31 @@ void AuraTUFKeyboardController::SaveMode()
usb_save_buf[0x01] = 0x50;
usb_save_buf[0x02] = 0x55;
ClearResponses();
hid_write(dev, usb_save_buf, 65);
AwaitResponse(60);
}
/*---------------------------------------------------------*\
| only needed for Claymore |
\*---------------------------------------------------------*/
void AuraTUFKeyboardController::AllowRemoteControl(unsigned char type)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x41;
usb_buf[0x02] = type;
ClearResponses();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
}
void AuraTUFKeyboardController::UpdateSingleLed
@ -121,7 +233,7 @@ void AuraTUFKeyboardController::UpdateSingleLed
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0] = 0x00;
usb_buf[1] = 0xc0;
usb_buf[1] = 0xC0;
usb_buf[2] = 0x81;
usb_buf[3] = 0x01;
usb_buf[4] = 0x00;
@ -129,70 +241,54 @@ void AuraTUFKeyboardController::UpdateSingleLed
/*-----------------------------------------------------*\
| Convert LED index |
\*-----------------------------------------------------*/
usb_buf[5] = floor(led/6)*8 + led%6;
usb_buf[5] = led;
usb_buf[6] = red;
usb_buf[7] = green;
usb_buf[8] = blue;
ClearResponses();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
}
void AuraTUFKeyboardController::UpdateLeds
(
std::vector<RGBColor> colors
std::vector<led_color> colors
)
{
/*-----------------------------------------------------*\
| Loop over every column (optimisation needed) |
\*-----------------------------------------------------*/
for(unsigned int i = 0; i < 192; i += 16)
int packets = ceil((float) colors.size() / 15);
for(int i = 0; i < packets; i++)
{
unsigned char usb_buf[69];
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
int remaining = colors.size() - i * 15;
int leds = (remaining > 0x0F) ? 0x0F : remaining;
usb_buf[0] = 0x00;
usb_buf[1] = 0xc0;
usb_buf[1] = 0xC0;
usb_buf[2] = 0x81;
usb_buf[3] = (138 - i / 16 * 12);
usb_buf[3] = leds;
usb_buf[4] = 0x00;
for(unsigned int n = 0; n < 6; n++)
for(unsigned int j = 0; j < leds; j++)
{
usb_buf[n * 4 + 5] = i + n;
usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n]);
usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n]);
usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n]);
usb_buf[j * 4 + 5] = colors[i * 15 + j].value;
usb_buf[j * 4 + 6] = RGBGetRValue(colors[i * 15 + j].color);
usb_buf[j * 4 + 7] = RGBGetGValue(colors[i * 15 + j].color);
usb_buf[j * 4 + 8] = RGBGetBValue(colors[i * 15 + j].color);
}
ClearResponses();
for(unsigned int n = 6; n < 8; n++)
{
usb_buf[n * 4 + 5] = i + n;
usb_buf[n * 4 + 6] = 0;
usb_buf[n * 4 + 7] = 0;
usb_buf[n * 4 + 8] = 0;
}
hid_write(dev, usb_buf, 65);
if(i != 176)
{
for(unsigned int n = 8; n < 14; n++)
{
usb_buf[n * 4 + 5] = i + n;
usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n-2]);
usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n-2]);
usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n-2]);
}
for(unsigned int n = 14; n < 16; n++)
{
usb_buf[n * 4 + 5] = i + n;
usb_buf[n * 4 + 6] = 0;
usb_buf[n * 4 + 7] = 0;
usb_buf[n * 4 + 8] = 0;
}
}
hid_write(dev, usb_buf, 69);
AwaitResponse(20);
}
}
@ -200,7 +296,7 @@ void AuraTUFKeyboardController::UpdateDevice
(
unsigned char mode,
std::vector<RGBColor> colors,
unsigned char dir,
unsigned char direction,
unsigned char color_mode,
unsigned char speed,
unsigned char brightness
@ -213,62 +309,167 @@ void AuraTUFKeyboardController::UpdateDevice
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x2C;
usb_buf[0x03] = mode;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = speed;
usb_buf[0x06] = brightness;
usb_buf[0x07] = color_mode;
usb_buf[0x08] = dir;
usb_buf[0x09] = 0x02;
if(mode == 4 || mode == 5)
if(device_pid != AURA_ROG_CLAYMORE_PID)
{
/*-----------------------------------------------------*\
| If mode is Rainbow or Ripple |
\*-----------------------------------------------------*/
usb_buf[0x0A] = colors.size();
usb_buf[0x03] = mode;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = speed;
usb_buf[0x06] = brightness;
usb_buf[0x07] = color_mode;
usb_buf[0x08] = direction;
usb_buf[0x09] = 0x02;
/*-----------------------------------------------------*\
| Loop over every color given |
\*-----------------------------------------------------*/
for(unsigned int i = 0; i / 4 < colors.size(); i += 4)
if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
{
if(colors[i / 4])
usb_buf[0x0A] = colors.size();
/*-----------------------------------------------------*\
| Loop over every color given |
\*-----------------------------------------------------*/
for(unsigned int i = 0; i < colors.size(); i ++)
{
usb_buf[11 + i] = 100/(double)colors.size()*(i/4+1);
usb_buf[12 + i] = RGBGetRValue(colors[i/4]);
usb_buf[13 + i] = RGBGetGValue(colors[i/4]);
usb_buf[14 + i] = RGBGetBValue(colors[i/4]);
if(colors[i])
{
usb_buf[11 + i * 4] = 100/(double)colors.size()*(i+1);
usb_buf[12 + i * 4] = RGBGetRValue(colors[i]);
usb_buf[13 + i * 4] = RGBGetGValue(colors[i]);
usb_buf[14 + i * 4] = RGBGetBValue(colors[i]);
}
}
}
else
{
/*-----------------------------------------------------*\
| Loop over Color1, Color2 and Background if there |
\*-----------------------------------------------------*/
for(unsigned int i = 0; i != colors.size(); i++)
{
if(colors[i])
{
usb_buf[10 + i * 3] = RGBGetRValue(colors[i]);
usb_buf[11 + i * 3] = RGBGetGValue(colors[i]);
usb_buf[12 + i * 3] = RGBGetBValue(colors[i]);
}
}
}
}
else
{
/*-----------------------------------------------------*\
| Loop over Color1, Color2 and Background if there |
\*-----------------------------------------------------*/
for(unsigned int i = 0; i / 3 != colors.size(); i += 3)
usb_buf[0x03] = 0x00;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = mode;
usb_buf[0x06] = speed;
bool random = (color_mode == 1);
bool pattern = (color_mode == 2);
usb_buf[0x07] = random * 128 + pattern * 32 + direction;
usb_buf[0x08] = 0xFF; // "byteExt1" unknown usage
usb_buf[0x09] = 0xFF; // "byteExt2" unknown usage
usb_buf[0x0A] = (mode == 2) ? 0x80 : 0xFF; // "Lightness" (not Brightness)
if(mode == 7)
{
if(colors[i / 3])
UpdateQuicksandColors(colors);
}
else
{
if(mode == 4 && color_mode == 0)
{
usb_buf[10 + i] = RGBGetRValue(colors[i/3]);
usb_buf[11 + i] = RGBGetGValue(colors[i/3]);
usb_buf[12 + i] = RGBGetBValue(colors[i/3]);
usb_buf[11] = 0xFF;
usb_buf[12] = 0xFF;
usb_buf[13] = 0xFF;
}
for(unsigned int i = 0; i < colors.size(); i ++)
{
if(colors[i])
{
usb_buf[11 + i * 3] = RGBGetRValue(colors[i]);
usb_buf[12 + i * 3] = RGBGetGValue(colors[i]);
usb_buf[13 + i * 3] = RGBGetBValue(colors[i]);
}
}
}
for(int i = 1; i < 5; i++)
{
usb_buf[5 + i * 12] = 0xFF;
}
}
ClearResponses();
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
}
void AuraTUFKeyboardController::AwaitResponse()
/*---------------------------------------------------------*\
| only needed for Claymore |
\*---------------------------------------------------------*/
void AuraTUFKeyboardController::UpdateQuicksandColors
(
std::vector<RGBColor> colors
)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x91;
for(unsigned int i = 0; i < 6; i++)
{
if(colors[i])
{
usb_buf[5 + i * 3] = RGBGetRValue(colors[i]);
usb_buf[6 + i * 3] = RGBGetGValue(colors[i]);
usb_buf[7 + i * 3] = RGBGetBValue(colors[i]);
}
}
ClearResponses();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
}
/*---------------------------------------------------------*\
| only needed for Claymore |
\*---------------------------------------------------------*/
void AuraTUFKeyboardController::UpdateMode(unsigned char mode)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x28;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = mode;
ClearResponses();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
}
void AuraTUFKeyboardController::AwaitResponse(int ms)
{
unsigned char usb_buf_out[65];
hid_read(dev, usb_buf_out, 65);
hid_read_timeout(dev, usb_buf_out, 65, ms);
}
void AuraTUFKeyboardController::ClearResponses()
@ -277,7 +478,7 @@ void AuraTUFKeyboardController::ClearResponses()
unsigned char usb_buf_flush[65];
while(result > 0)
{
result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
}
}

25
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h
View file

@ -16,14 +16,6 @@
#pragma once
enum
{
AURA_KEYBOARD_ZONE_LOGO = 0,
AURA_KEYBOARD_ZONE_SCROLL = 1,
AURA_KEYBOARD_ZONE_UNDERGLOW = 2,
AURA_KEYBOARD_ZONE_ALL = 3,
};
enum
{
AURA_KEYBOARD_MODE_STATIC = 0,
@ -43,20 +35,28 @@ enum
{
AURA_TUF_K7_GAMING_PID = 0x18AA,
AURA_TUF_K3_GAMING_PID = 0x194B,
AURA_ROG_CLAYMORE_PID = 0x184D,
};
struct led_color
{
unsigned int value;
RGBColor color;
};
class AuraTUFKeyboardController
{
public:
AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid);
AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short rev_version);
~AuraTUFKeyboardController();
std::string GetDeviceLocation();
std::string GetSerialString();
std::string GetVersion();
int GetLayout();
int GetNumpadLocation();
void SaveMode();
void AllowRemoteControl(unsigned char type);
void UpdateSingleLed
(
@ -68,7 +68,7 @@ public:
void UpdateLeds
(
std::vector<RGBColor> colors
std::vector<led_color> colors
);
void UpdateDevice
@ -80,7 +80,9 @@ public:
unsigned char speed,
unsigned char brightness
);
void AwaitResponse();
void UpdateQuicksandColors(std::vector<RGBColor> colors);
void UpdateMode(unsigned char mode);
void AwaitResponse(int ms);
void ClearResponses();
uint16_t device_pid;
@ -88,5 +90,6 @@ public:
private:
hid_device* dev;
std::string location;
unsigned short version;
};

1286
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardLayouts.h
View file

File diff suppressed because it is too large Load diff

4
Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
View file

@ -48,6 +48,7 @@
#define AURA_ROG_STRIX_SCOPE_RX_PID 0x1951
#define AURA_ROG_STRIX_SCOPE_TKL_PID 0x190C
#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID 0x1954
#define AURA_ROG_CLAYMORE_PID 0x184D
#define AURA_TUF_K7_GAMING_PID 0x18AA
#define AURA_TUF_K3_GAMING_PID 0x194B
@ -260,7 +261,7 @@ void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name
if(dev)
{
AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path, info->product_id);
AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number);
RGBController_AuraTUFKeyboard* rgb_controller = new RGBController_AuraTUFKeyboard(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
@ -302,6 +303,7 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope", DetectAs
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL PNK LTD", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Claymore", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_CLAYMORE_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K7_GAMING_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K3_GAMING_PID, 1, 0xFF00);

663
Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp
View file

@ -24,178 +24,312 @@
RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr)
{
controller = controller_ptr;
controller = controller_ptr;
name = "ASUS Aura Keyboard";
vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Aura Keyboard Device";
version = controller->GetVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
pid = controller->device_pid;
mode Direct;
Direct.name = "Direct";
Direct.value = AURA_KEYBOARD_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
if(pid != AURA_ROG_CLAYMORE_PID)
{
name = "ASUS Aura Keyboard";
vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Aura Keyboard Device";
version = controller->GetVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Static;
Static.name = "Static";
Static.value = AURA_KEYBOARD_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Static.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Static.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Static.brightness = AURA_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 Direct;
Direct.name = "Direct";
Direct.value = AURA_KEYBOARD_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = AURA_KEYBOARD_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Breathing.speed_min = AURA_KEYBOARD_SPEED_MIN;
Breathing.speed_max = AURA_KEYBOARD_SPEED_MAX;
Breathing.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Breathing.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Breathing.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Breathing.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors_min = 1;
Breathing.colors_max = 2;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode Static;
Static.name = "Static";
Static.value = AURA_KEYBOARD_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Static.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Static.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Static.brightness = AURA_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 Color_Cycle;
Color_Cycle.name = "Spectrum Cycle";
Color_Cycle.value = AURA_KEYBOARD_MODE_COLOR_CYCLE;
Color_Cycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Color_Cycle.speed_min = AURA_KEYBOARD_SPEED_MIN;
Color_Cycle.speed_max = AURA_KEYBOARD_SPEED_MAX;
Color_Cycle.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Color_Cycle.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Color_Cycle.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Color_Cycle.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Color_Cycle.color_mode = MODE_COLORS_NONE;
modes.push_back(Color_Cycle);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = AURA_KEYBOARD_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Breathing.speed_min = AURA_KEYBOARD_SPEED_MIN;
Breathing.speed_max = AURA_KEYBOARD_SPEED_MAX;
Breathing.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Breathing.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Breathing.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Breathing.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors_min = 1;
Breathing.colors_max = 2;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode Wave;
Wave.name = "Rainbow Wave";
Wave.value = AURA_KEYBOARD_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Wave.speed_min = AURA_KEYBOARD_SPEED_MIN;
Wave.speed_max = AURA_KEYBOARD_SPEED_MAX;
Wave.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Wave.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Wave.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Wave.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Wave.direction = MODE_DIRECTION_LEFT;
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
Wave.colors_min = 1;
Wave.colors_max = 7;
Wave.colors.resize(7);
modes.push_back(Wave);
mode Color_Cycle;
Color_Cycle.name = "Spectrum Cycle";
Color_Cycle.value = AURA_KEYBOARD_MODE_COLOR_CYCLE;
Color_Cycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Color_Cycle.speed_min = AURA_KEYBOARD_SPEED_MIN;
Color_Cycle.speed_max = AURA_KEYBOARD_SPEED_MAX;
Color_Cycle.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Color_Cycle.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Color_Cycle.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Color_Cycle.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Color_Cycle.color_mode = MODE_COLORS_NONE;
modes.push_back(Color_Cycle);
mode Ripple;
Ripple.name = "Ripple";
Ripple.value = AURA_KEYBOARD_MODE_RIPPLE;
Ripple.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Ripple.speed_min = AURA_KEYBOARD_SPEED_MIN;
Ripple.speed_max = AURA_KEYBOARD_SPEED_MAX;
Ripple.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Ripple.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Ripple.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Ripple.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC;
Ripple.colors_min = 1;
Ripple.colors_max = 8;
Ripple.colors.resize(7);
modes.push_back(Ripple);
mode Wave;
Wave.name = "Rainbow Wave";
Wave.value = AURA_KEYBOARD_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Wave.speed_min = AURA_KEYBOARD_SPEED_MIN;
Wave.speed_max = AURA_KEYBOARD_SPEED_MAX;
Wave.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Wave.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Wave.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Wave.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Wave.direction = MODE_DIRECTION_LEFT;
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
Wave.colors_min = 1;
Wave.colors_max = 7;
Wave.colors.resize(7);
modes.push_back(Wave);
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = AURA_KEYBOARD_MODE_REACTIVE;
Reactive.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Reactive.speed_min = AURA_KEYBOARD_SPEED_MIN;
Reactive.speed_max = AURA_KEYBOARD_SPEED_MAX;
Reactive.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Reactive.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Reactive.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Reactive.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
Reactive.colors_min = 1;
Reactive.colors_max = 2;
Reactive.colors.resize(1);
modes.push_back(Reactive);
mode Ripple;
Ripple.name = "Ripple";
Ripple.value = AURA_KEYBOARD_MODE_RIPPLE;
Ripple.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Ripple.speed_min = AURA_KEYBOARD_SPEED_MIN;
Ripple.speed_max = AURA_KEYBOARD_SPEED_MAX;
Ripple.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Ripple.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Ripple.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Ripple.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC;
Ripple.colors_min = 1;
Ripple.colors_max = 8;
Ripple.colors.resize(7);
modes.push_back(Ripple);
mode Starry_Night;
Starry_Night.name = "Starry Night";
Starry_Night.value = AURA_KEYBOARD_MODE_STARRY_NIGHT;
Starry_Night.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Starry_Night.speed_min = AURA_KEYBOARD_SPEED_MIN;
Starry_Night.speed_max = AURA_KEYBOARD_SPEED_MAX;
Starry_Night.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Starry_Night.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Starry_Night.color_mode = MODE_COLORS_MODE_SPECIFIC;
Starry_Night.colors_min = 1;
Starry_Night.colors_max = 3;
Starry_Night.colors.resize(1);
modes.push_back(Starry_Night);
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = AURA_KEYBOARD_MODE_REACTIVE;
Reactive.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Reactive.speed_min = AURA_KEYBOARD_SPEED_MIN;
Reactive.speed_max = AURA_KEYBOARD_SPEED_MAX;
Reactive.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Reactive.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Reactive.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Reactive.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
Reactive.colors_min = 1;
Reactive.colors_max = 2;
Reactive.colors.resize(1);
modes.push_back(Reactive);
mode Quicksand;
Quicksand.name = "Quicksand";
Quicksand.value = AURA_KEYBOARD_MODE_QUICKSAND;
Quicksand.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Quicksand.direction = MODE_DIRECTION_DOWN;
Quicksand.speed_min = AURA_KEYBOARD_SPEED_MIN;
Quicksand.speed_max = AURA_KEYBOARD_SPEED_MAX;
Quicksand.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Quicksand.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Quicksand.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Quicksand.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Quicksand.color_mode = MODE_COLORS_MODE_SPECIFIC;
Quicksand.colors_min = 6;
Quicksand.colors_max = 6;
Quicksand.colors.resize(6);
modes.push_back(Quicksand);
mode Starry_Night;
Starry_Night.name = "Starry Night";
Starry_Night.value = AURA_KEYBOARD_MODE_STARRY_NIGHT;
Starry_Night.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Starry_Night.speed_min = AURA_KEYBOARD_SPEED_MIN;
Starry_Night.speed_max = AURA_KEYBOARD_SPEED_MAX;
Starry_Night.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Starry_Night.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Starry_Night.color_mode = MODE_COLORS_MODE_SPECIFIC;
Starry_Night.colors_min = 1;
Starry_Night.colors_max = 3;
Starry_Night.colors.resize(1);
modes.push_back(Starry_Night);
mode Current;
Current.name = "Current";
Current.value = AURA_KEYBOARD_MODE_CURRENT;
Current.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Current.speed_min = AURA_KEYBOARD_SPEED_MIN;
Current.speed_max = AURA_KEYBOARD_SPEED_MAX;
Current.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Current.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Current.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Current.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Current.color_mode = MODE_COLORS_MODE_SPECIFIC;
Current.colors_min = 1;
Current.colors_max = 3;
Current.colors.resize(1);
modes.push_back(Current);
mode Quicksand;
Quicksand.name = "Quicksand";
Quicksand.value = AURA_KEYBOARD_MODE_QUICKSAND;
Quicksand.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Quicksand.direction = MODE_DIRECTION_DOWN;
Quicksand.speed_min = AURA_KEYBOARD_SPEED_MIN;
Quicksand.speed_max = AURA_KEYBOARD_SPEED_MAX;
Quicksand.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Quicksand.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Quicksand.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Quicksand.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Quicksand.color_mode = MODE_COLORS_MODE_SPECIFIC;
Quicksand.colors_min = 6;
Quicksand.colors_max = 6;
Quicksand.colors.resize(6);
modes.push_back(Quicksand);
mode Rain_Drop;
Rain_Drop.name = "Rain Drop";
Rain_Drop.value = AURA_KEYBOARD_MODE_RAIN_DROP;
Rain_Drop.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Rain_Drop.speed_min = AURA_KEYBOARD_SPEED_MIN;
Rain_Drop.speed_max = AURA_KEYBOARD_SPEED_MAX;
Rain_Drop.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Rain_Drop.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Rain_Drop.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Rain_Drop.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Rain_Drop.color_mode = MODE_COLORS_MODE_SPECIFIC;
Rain_Drop.colors_min = 1;
Rain_Drop.colors_max = 3;
Rain_Drop.colors.resize(1);
modes.push_back(Rain_Drop);
mode Current;
Current.name = "Current";
Current.value = AURA_KEYBOARD_MODE_CURRENT;
Current.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Current.speed_min = AURA_KEYBOARD_SPEED_MIN;
Current.speed_max = AURA_KEYBOARD_SPEED_MAX;
Current.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Current.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Current.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Current.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Current.color_mode = MODE_COLORS_MODE_SPECIFIC;
Current.colors_min = 1;
Current.colors_max = 3;
Current.colors.resize(1);
modes.push_back(Current);
mode Rain_Drop;
Rain_Drop.name = "Rain Drop";
Rain_Drop.value = AURA_KEYBOARD_MODE_RAIN_DROP;
Rain_Drop.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Rain_Drop.speed_min = AURA_KEYBOARD_SPEED_MIN;
Rain_Drop.speed_max = AURA_KEYBOARD_SPEED_MAX;
Rain_Drop.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Rain_Drop.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Rain_Drop.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Rain_Drop.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Rain_Drop.color_mode = MODE_COLORS_MODE_SPECIFIC;
Rain_Drop.colors_min = 1;
Rain_Drop.colors_max = 3;
Rain_Drop.colors.resize(1);
modes.push_back(Rain_Drop);
}
else
{
name = "ASUS ROG Claymore";
vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Aura Keyboard Device";
version = controller->GetVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = AURA_KEYBOARD_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 = AURA_KEYBOARD_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(1);
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = AURA_KEYBOARD_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Breathing.speed_min = AURA_CLAYMORE_SPEED_MIN;
Breathing.speed_max = AURA_CLAYMORE_SPEED_MAX;
Breathing.speed = AURA_CLAYMORE_SPEED_DEFAULT_BREATHING;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors_min = 1;
Breathing.colors_max = 2;
Breathing.colors.resize(2);
modes.push_back(Breathing);
mode Color_Cycle;
Color_Cycle.name = "Spectrum Cycle";
Color_Cycle.value = AURA_KEYBOARD_MODE_COLOR_CYCLE;
Color_Cycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Color_Cycle.speed_min = AURA_CLAYMORE_SPEED_MIN;
Color_Cycle.speed_max = AURA_CLAYMORE_SPEED_MAX;
Color_Cycle.speed = AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE;
Color_Cycle.color_mode = MODE_COLORS_NONE;
modes.push_back(Color_Cycle);
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = AURA_KEYBOARD_MODE_REACTIVE;
Reactive.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Reactive.speed_min = AURA_CLAYMORE_SPEED_MIN;
Reactive.speed_max = AURA_CLAYMORE_SPEED_MAX;
Reactive.speed = AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE;
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
Reactive.colors_min = 1;
Reactive.colors_max = 2;
Reactive.colors.resize(2);
modes.push_back(Reactive);
mode Wave;
Wave.name = "Rainbow Wave";
Wave.value = AURA_KEYBOARD_MODE_WAVE;
Wave.flags = MODE_COLORS_NONE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
Wave.speed_min = AURA_CLAYMORE_SPEED_MIN;
Wave.speed_max = AURA_CLAYMORE_SPEED_MAX;
Wave.speed = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
Wave.direction = MODE_DIRECTION_LEFT;
Wave.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave);
mode Color_Wave;
Color_Wave.name = "Color Wave";
Color_Wave.value = AURA_KEYBOARD_MODE_WAVE;
Color_Wave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
Color_Wave.speed_min = AURA_CLAYMORE_SPEED_MIN;
Color_Wave.speed_max = AURA_CLAYMORE_SPEED_MAX;
Color_Wave.speed = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
Color_Wave.direction = MODE_DIRECTION_LEFT;
Color_Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
Color_Wave.colors_min = 1;
Color_Wave.colors_max = 2;
Color_Wave.colors.resize(2);
modes.push_back(Color_Wave);
mode Ripple;
Ripple.name = "Ripple";
Ripple.value = AURA_KEYBOARD_MODE_RIPPLE;
Ripple.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Ripple.speed_min = AURA_CLAYMORE_SPEED_MIN;
Ripple.speed_max = AURA_CLAYMORE_SPEED_MAX;
Ripple.speed = AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE;
Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC;
Ripple.colors_min = 1;
Ripple.colors_max = 2;
Ripple.colors.resize(2);
modes.push_back(Ripple);
mode Starry_Night;
Starry_Night.name = "Starry Night";
Starry_Night.value = AURA_KEYBOARD_MODE_STARRY_NIGHT;
Starry_Night.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Starry_Night.speed_min = AURA_CLAYMORE_SPEED_MIN;
Starry_Night.speed_max = AURA_CLAYMORE_SPEED_MAX;
Starry_Night.speed = AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT;
Starry_Night.color_mode = MODE_COLORS_MODE_SPECIFIC;
Starry_Night.colors_min = 1;
Starry_Night.colors_max = 2;
Starry_Night.colors.resize(2);
modes.push_back(Starry_Night);
mode Quicksand;
Quicksand.name = "Quicksand";
Quicksand.value = AURA_KEYBOARD_MODE_QUICKSAND;
Quicksand.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Quicksand.direction = MODE_DIRECTION_DOWN;
Quicksand.speed_min = AURA_CLAYMORE_SPEED_MIN;
Quicksand.speed_max = AURA_CLAYMORE_SPEED_MAX;
Quicksand.speed = AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND;
Quicksand.color_mode = MODE_COLORS_MODE_SPECIFIC;
Quicksand.colors_min = 6;
Quicksand.colors_max = 6;
Quicksand.colors.resize(6);
modes.push_back(Quicksand);
}
SetupZones();
}
@ -207,10 +341,44 @@ RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
void RGBController_AuraTUFKeyboard::SetupZones()
{
int layout = controller->GetLayout();
unsigned char layout = controller->GetLayout();
if(AsusTUFK7Layouts.find(layout % 100) == AsusTUFK7Layouts.end())
std::map<int,layout_info> * keyboard_ptr;
switch(pid)
{
case AURA_ROG_CLAYMORE_PID:
unsigned char numpad;
numpad = controller->GetNumpadLocation();
switch(numpad)
{
case 0:
keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
break;
case 2:
keyboard_ptr = &AsusClaymoreNumpadRightLayouts;
break;
case 3:
keyboard_ptr = &AsusClaymoreNumpadLeftLayouts;
break;
default:
keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
}
break;
case AURA_TUF_K7_GAMING_PID:
keyboard_ptr = &AsusTUFK7Layouts;
break;
default:
keyboard_ptr = &AsusTUFK7Layouts;
}
std::map<int,layout_info> & keyboard = *keyboard_ptr;
if(keyboard.find(layout % 100) == keyboard.end())
{
/*---------------------------------------------------------*\
| If Layout not found, take uk or us |
\*---------------------------------------------------------*/
layout = std::floor(layout/100) == 2 ? ASUS_TUF_K7_LAYOUT_UK : ASUS_TUF_K7_LAYOUT_US;
}
else
@ -218,33 +386,32 @@ void RGBController_AuraTUFKeyboard::SetupZones()
layout = layout % 100;
}
unsigned int total_led_count = 0;
zone keyboard_zone;
keyboard_zone.name = "Keyboard";
keyboard_zone.type = ZONE_TYPE_MATRIX;
keyboard_zone.leds_min = keyboard[layout].size;
keyboard_zone.leds_max = keyboard[layout].size;
keyboard_zone.leds_count = keyboard[layout].size;
keyboard_zone.matrix_map = new matrix_map_type;
keyboard_zone.matrix_map->height = keyboard[layout].rows;
keyboard_zone.matrix_map->width = keyboard[layout].cols;
keyboard_zone.matrix_map->map = keyboard[layout].matrix_map;
zones.push_back(keyboard_zone);
int zone_size = 138;
zone keyboard;
keyboard.name = ZONE_EN_KEYBOARD;
keyboard.type = ZONE_TYPE_MATRIX;
keyboard.leds_min = zone_size;
keyboard.leds_max = zone_size;
keyboard.leds_count = zone_size;
keyboard.matrix_map = new matrix_map_type;
keyboard.matrix_map->height = 6;
keyboard.matrix_map->width = 23;
keyboard.matrix_map->map = AsusTUFK7Layouts[layout].matrix_map;
zones.push_back(keyboard);
total_led_count += zone_size;
for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
for(unsigned int led_id = 0; led_id < keyboard[layout].size; led_id++)
{
led new_led;
new_led.name = AsusTUFK7Layouts[layout].led_names[led_idx];
new_led.name = keyboard[layout].led_names[led_id].name;
new_led.value = keyboard[layout].led_names[led_id].id;
leds.push_back(new_led);
}
SetupColors();
/*---------------------------------------------------------*\
| sends the init packet for the default mode (direct) |
\*---------------------------------------------------------*/
DeviceUpdateMode();
}
void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
@ -254,12 +421,20 @@ void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
{
DeviceUpdateMode();
std::vector<led_color> led_color_list = {};
for(int i = 0; i < colors.size(); i++)
{
led_color_list.push_back({ leds[i].value, colors[i] });
}
controller->UpdateLeds(led_color_list);
}
void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
{
controller->UpdateLeds(colors);
DeviceUpdateLEDs();
}
void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
@ -268,72 +443,100 @@ void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
unsigned char green = RGBGetGValue(colors[led]);
unsigned char blue = RGBGetBValue(colors[led]);
controller->UpdateSingleLed(led, red, green, blue);
controller->UpdateSingleLed(leds[led].value, red, green, blue);
}
static const uint8_t direction_map[2][6] =
{
{ 4, 0, 6, 2, 8, 1 }, // Default directions Left, Right, Up, Down, Horizontal, Vertical
{ 0, 4, 6, 2, 0xFF, 0xFF }, // AURA_ROG_CLAYMORE directions Left, Right, Up, Down
};
void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
{
unsigned char color_mode;
std::vector<RGBColor> mode_colors;
if(pid == AURA_ROG_CLAYMORE_PID)
{
controller->AllowRemoteControl(1);
}
unsigned char color_mode = 0;
unsigned char direction = 0;
unsigned char brightness = 0;
if(modes[active_mode].value == AURA_KEYBOARD_MODE_DIRECT)
{
controller->UpdateLeds(colors);
if(pid == AURA_ROG_CLAYMORE_PID) controller->AllowRemoteControl(3);
return;
};
if(pid != AURA_ROG_CLAYMORE_PID)
{
brightness = modes[active_mode].brightness * 25;
switch(modes[active_mode].value)
{
case AURA_KEYBOARD_MODE_BREATHING:
case AURA_KEYBOARD_MODE_REACTIVE:
case AURA_KEYBOARD_MODE_STARRY_NIGHT:
case AURA_KEYBOARD_MODE_CURRENT:
case AURA_KEYBOARD_MODE_RAIN_DROP:
bool color_is_black = (modes[active_mode].colors.size() > 1 && modes[active_mode].colors[1] == 000);
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && !color_is_black)
{
color_mode = 16;
}
break;
}
if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
{
color_mode = 1;
}
if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE)
{
/*----------------------------------------------------------*\
| converting openrgb direction value to keyboard directions |
\*----------------------------------------------------------*/
direction = direction_map[0][modes[active_mode].direction];
}
}
else
{
bool mode_with_double = (modes[active_mode].value == 1 || modes[active_mode].value == 3 || modes[active_mode].value == 6 || modes[active_mode].value == 8 || modes[active_mode].value == 9);
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && mode_with_double && modes[active_mode].colors.size() > 1)
if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
{
if(modes[active_mode].colors[1] == 000)
{
color_mode = 0;
}
else
{
color_mode = 16;
}
}
else
{
color_mode = modes[active_mode].color_mode == MODE_COLORS_RANDOM ? 1 : 0;
color_mode = 1;
}
int direction = 0;
if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE) {
if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) color_mode = 2;
switch (modes[active_mode].direction)
{
case MODE_DIRECTION_LEFT:
direction = 0;
break;
case MODE_DIRECTION_RIGHT:
direction = 4;
break;
case MODE_DIRECTION_UP:
direction = 6;
break;
case MODE_DIRECTION_DOWN:
direction = 2;
break;
case MODE_DIRECTION_HORIZONTAL:
direction = 8;
break;
case MODE_DIRECTION_VERTICAL:
direction = 1;
break;
/*----------------------------------------------------------*\
| converting openrgb direction value to keyboard directions |
\*----------------------------------------------------------*/
direction = direction_map[1][modes[active_mode].direction];
}
}
mode_colors = modes[active_mode].color_mode == MODE_COLORS_PER_LED ? std::vector<RGBColor>(colors) : std::vector<RGBColor>(modes[active_mode].colors);
controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), direction, color_mode, modes[active_mode].speed, brightness);
controller->UpdateDevice(modes[active_mode].value, mode_colors, direction, color_mode, (15 - modes[active_mode].speed), modes[active_mode].brightness * 25);
if(pid == AURA_ROG_CLAYMORE_PID)
{
controller->UpdateMode(modes[active_mode].value);
controller->SaveMode();
controller->AllowRemoteControl(0);
}
}
void RGBController_AuraTUFKeyboard::DeviceSaveMode()
{
controller->ClearResponses();
DeviceUpdateMode();
controller->AwaitResponse();
controller->SaveMode();
/*----------------------------------------------------------*\
| not available for Claymore |
\*----------------------------------------------------------*/
if(pid != AURA_ROG_CLAYMORE_PID)
{
DeviceUpdateMode();
controller->SaveMode();
}
}

22
Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h
View file

@ -13,12 +13,27 @@
enum
{
AURA_KEYBOARD_SPEED_MIN = 0,
AURA_KEYBOARD_SPEED_MAX = 15,
AURA_KEYBOARD_SPEED_MIN = 15,
AURA_KEYBOARD_SPEED_MAX = 0,
AURA_KEYBOARD_SPEED_DEFAULT = 8,
AURA_KEYBOARD_BRIGHTNESS_MIN = 0,
AURA_KEYBOARD_BRIGHTNESS_MAX = 4,
AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4
AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4,
};
enum
{
AURA_CLAYMORE_SPEED_MIN = 254,
AURA_CLAYMORE_SPEED_MAX = 0,
AURA_CLAYMORE_SPEED_DEFAULT_STATIC = 0,
AURA_CLAYMORE_SPEED_DEFAULT_BREATHING = 107,
AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE = 121,
AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE = 56,
AURA_CLAYMORE_SPEED_DEFAULT_WAVE = 50,
AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE = 108,
AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT = 54,
AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND = 103,
};
class RGBController_AuraTUFKeyboard : public RGBController
@ -40,4 +55,5 @@ public:
private:
AuraTUFKeyboardController* controller;
uint16_t pid;
};