Jens/LumaOps-Public
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Publish LumaOps source

Browse Source
This commit is contained in:
LumaOps release export
2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/AsusAuraTUFKeyboardController.cpp
+733
View File
@@ -0,0 +1,733 @@
/*---------------------------------------------------------*\
| AsusAuraTUFKeyboardController.cpp |
| |
| Driver for ASUS Aura TUF keyboard |
| |
| Mola19 03 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cmath>
#include <cstring>
#include <math.h>
#include <string>
#include <stdio.h>
#include <string.h>
#include <vector>
#include "AsusAuraTUFKeyboardController.h"
#include "StringUtils.h"
#define HID_MAX_STR 128
AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
device_pid = pid;
rev_version = version;
is_per_led_keyboard = (pid != AURA_TUF_K1_GAMING_PID && pid != AURA_TUF_K5_GAMING_PID);
}
AuraTUFKeyboardController::~AuraTUFKeyboardController()
{
hid_close(dev);
}
std::string AuraTUFKeyboardController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string AuraTUFKeyboardController::GetName()
{
return(name);
}
std::string AuraTUFKeyboardController::GetSerialString()
{
wchar_t serial_string[HID_MAX_STR];
memset(serial_string, 0, sizeof(serial_string));
int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
if(ret != 0)
{
return("");
}
/*-------------------------------------------------------------------------*\
| Skip non-ASCII, trailing garbage in serial numbers. Required by the |
| Scope II 96, whose original firmware outputs garbage, which even differs |
| after computer reboots and therefore breaks OpenRGB profile matching. |
\*-------------------------------------------------------------------------*/
switch(device_pid)
{
case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
serial_string[12] = L'\0';
break;
default:
break;
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string AuraTUFKeyboardController::GetVersion()
{
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] = 0x00;
ClearResponses();
hid_write(dev, usb_buf, 65);
unsigned char usb_buf_out[65];
hid_read(dev, usb_buf_out, 65);
char version[9];
switch(device_pid)
{
case AURA_ROG_AZOTH_USB_PID:
case AURA_ROG_AZOTH_2_4_PID:
case AURA_TUF_K3_GAMING_PID:
case AURA_TUF_K3_GAMING_GEN_II_PID:
case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
case AURA_ROG_STRIX_SCOPE_II_PID:
case AURA_ROG_STRIX_SCOPE_II_RX_PID:
case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
case AURA_ROG_STRIX_SCOPE_II_96_RX_WIRELESS_USB_PID:
snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
break;
case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[13], usb_buf_out[12], usb_buf_out[11]);
break;
default:
snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
}
return std::string(version);
}
else
{
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);
}
}
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
{
switch(rev_version >> 0b1100)
{
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] = 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[5] * 2 + usb_buf_out[4]);
}
void AuraTUFKeyboardController::SaveMode()
{
unsigned char usb_save_buf[65];
memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
usb_save_buf[0x00] = 0x00;
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
(
int led,
unsigned char red,
unsigned char green,
unsigned char blue
)
{
/*-----------------------------------------------------*\
| Set up message packet for single LED |
\*-----------------------------------------------------*/
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0] = 0x00;
usb_buf[1] = 0xC0;
usb_buf[2] = 0x81;
usb_buf[3] = 0x01;
usb_buf[4] = 0x00;
/*-----------------------------------------------------*\
| Convert LED index |
\*-----------------------------------------------------*/
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<led_color> colors
)
{
int packets = (int)ceil((float)colors.size() / 15.0f);
for(int i = 0; i < packets; i++)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
int remaining = (int)colors.size() - i * 15;
int leds = (remaining > 0x0F) ? 0x0F : remaining;
usb_buf[0] = 0x00;
usb_buf[1] = 0xC0;
usb_buf[2] = 0x81;
usb_buf[3] = leds;
usb_buf[4] = 0x00;
for(int j = 0; j < leds; j++)
{
usb_buf[j * 4 + 5] = (is_per_led_keyboard) ? colors[i * 15 + j].value : 0x00;
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();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
}
}
void AuraTUFKeyboardController::UpdateK1Wave
(
std::vector<RGBColor> colors,
unsigned char direction,
unsigned char speed,
unsigned char brightness
)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x2C;
usb_buf[0x03] = 0x03;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = speed;
usb_buf[0x06] = brightness;
usb_buf[0x07] = 0x00;
usb_buf[0x08] = direction;
usb_buf[0x09] = 0x00;
usb_buf[10] = 5;
usb_buf[11] = RGBGetRValue(colors[4]);
usb_buf[12] = RGBGetGValue(colors[4]);
usb_buf[13] = RGBGetBValue(colors[4]);
ClearResponses();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
for(unsigned int i = 0; i < 4; i ++)
{
usb_buf[10 + i * 4] = i + 1;
usb_buf[11 + i * 4] = RGBGetRValue(colors[i]);
usb_buf[12 + i * 4] = RGBGetGValue(colors[i]);
usb_buf[13 + i * 4] = RGBGetBValue(colors[i]);
}
ClearResponses();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
}
void AuraTUFKeyboardController::UpdateScopeIIRainbowRipple
(
unsigned char mode,
std::vector<RGBColor> colors,
unsigned char direction,
unsigned char color_mode,
unsigned char speed,
unsigned char brightness
)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x2C;
usb_buf[0x03] = mode;
usb_buf[0x04] = 0x02;
usb_buf[0x05] = speed;
usb_buf[0x06] = brightness;
usb_buf[0x07] = color_mode;
usb_buf[0x08] = direction;
usb_buf[0x09] = 0x02;
usb_buf[0x0A] = (unsigned char)colors.size();
for(unsigned int i = 0; i < 2; i++)
{
if(i >= colors.size())
{
continue;
}
usb_buf[11 + i * 4] = (unsigned char)(100.0f / (float)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]);
}
ClearResponses();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
memset(usb_buf + 4, 0x00, sizeof(usb_buf) - 4);
usb_buf[0x04] = 0x01;
for(unsigned int i = 0; i < 4; i++)
{
if((i + 2) >= colors.size())
{
continue;
}
usb_buf[5 + i * 4] = (unsigned char)(100.0f / (float)colors.size() * (i + 1 + 2));
usb_buf[6 + i * 4] = RGBGetRValue(colors[i + 2]);
usb_buf[7 + i * 4] = RGBGetGValue(colors[i + 2]);
usb_buf[8 + i * 4] = RGBGetBValue(colors[i + 2]);
}
ClearResponses();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
memset(usb_buf + 4, 0x00, sizeof(usb_buf) - 4);
usb_buf[0x04] = 0x00;
for(unsigned int i = 0; i < 1; i ++)
{
if((i + 6) >= colors.size())
{
continue;
}
usb_buf[5 + i * 4] = (unsigned char)(100.0f / (float)colors.size() * (i + 1 + 6));
usb_buf[6 + i * 4] = RGBGetRValue(colors[i + 6]);
usb_buf[7 + i * 4] = RGBGetGValue(colors[i + 6]);
usb_buf[8 + i * 4] = RGBGetBValue(colors[i + 6]);
}
ClearResponses();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
}
void AuraTUFKeyboardController::UpdateScopeIIQuicksand
(
std::vector<RGBColor> colors,
unsigned char direction,
unsigned char color_mode,
unsigned char speed,
unsigned char brightness
)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x2C;
usb_buf[0x03] = 0x07;
usb_buf[0x04] = 0x01;
usb_buf[0x05] = speed;
usb_buf[0x06] = brightness;
usb_buf[0x07] = color_mode;
usb_buf[0x08] = direction;
usb_buf[0x09] = 0x02;
for(unsigned int i = 0; i < 3; 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]);
}
ClearResponses();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
memset(usb_buf + 4, 0x00, sizeof(usb_buf) - 4);
usb_buf[0x04] = 0x00;
for(unsigned int i = 0; i < 3; i ++)
{
usb_buf[5 + i * 3] = RGBGetRValue(colors[i+3]);
usb_buf[6 + i * 3] = RGBGetGValue(colors[i+3]);
usb_buf[7 + i * 3] = RGBGetBValue(colors[i+3]);
}
ClearResponses();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
}
void AuraTUFKeyboardController::UpdateDevice
(
unsigned char mode,
std::vector<RGBColor> colors,
unsigned char direction,
unsigned char color_mode,
unsigned char speed,
unsigned char brightness
)
{
if(device_pid == AURA_TUF_K1_GAMING_PID && mode == AURA_KEYBOARD_MODE_WAVE)
{
return UpdateK1Wave(colors, direction, speed, brightness);
}
if(device_pid == AURA_ROG_AZOTH_USB_PID
|| device_pid == AURA_ROG_AZOTH_2_4_PID
|| device_pid == AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID
|| device_pid == AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID
|| device_pid == AURA_ROG_STRIX_SCOPE_II_PID
|| device_pid == AURA_ROG_STRIX_SCOPE_II_RX_PID
|| device_pid == AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID
|| device_pid == AURA_ROG_STRIX_SCOPE_II_96_RX_WIRELESS_USB_PID)
{
if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
{
return UpdateScopeIIRainbowRipple(mode, colors, direction, color_mode, speed, brightness);
}
else if (mode == AURA_KEYBOARD_MODE_QUICKSAND)
{
return UpdateScopeIIQuicksand(colors, direction, color_mode, speed, brightness);
}
}
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x2C;
if(device_pid != AURA_ROG_CLAYMORE_PID)
{
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;
if(is_per_led_keyboard)
{
usb_buf[0x09] = 0x02;
if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
{
usb_buf[0x0A] = (unsigned char)colors.size();
/*-----------------------------------------------------*\
| Loop over every color given |
\*-----------------------------------------------------*/
for(unsigned int i = 0; i < colors.size(); i ++)
{
if(colors[i])
{
usb_buf[11 + i * 4] = (unsigned char)(100.0f / (float)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
{
/*-----------------------------------------------------------------*\
| Only handles K5 Rainbow. |
| K1 is filtered out earlier and is executed in `UpdateK1Wave()` |
\*-----------------------------------------------------------------*/
if(mode == AURA_KEYBOARD_MODE_WAVE)
{
usb_buf[0x09] = 0x05;
for(unsigned int i = 0; i < 5; i ++)
{
usb_buf[10 + i * 4] = i + 1;
usb_buf[11 + i * 4] = RGBGetRValue(colors[i]);
usb_buf[12 + i * 4] = RGBGetGValue(colors[i]);
usb_buf[13 + 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[ 9 + i * 3] = RGBGetRValue(colors[i]);
usb_buf[10 + i * 3] = RGBGetGValue(colors[i]);
usb_buf[11 + i * 3] = RGBGetBValue(colors[i]);
}
}
}
}
}
else
{
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)
{
UpdateQuicksandColors(colors);
}
else
{
if(mode == 4 && color_mode == 0)
{
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();
hid_write(dev, usb_buf, 65);
AwaitResponse(20);
}
/*---------------------------------------------------------*\
| 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_timeout(dev, usb_buf_out, 65, ms);
}
void AuraTUFKeyboardController::ClearResponses()
{
int result = 1;
unsigned char usb_buf_flush[65];
while(result > 0)
{
result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
}
}
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/AsusAuraTUFKeyboardController.h
+150
View File
@@ -0,0 +1,150 @@
/*---------------------------------------------------------*\
| AsusAuraTUFKeyboardController.h |
| |
| Driver for ASUS Aura TUF keyboard |
| |
| Mola19 03 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <vector>
#include <hidapi.h>
#include "RGBController.h"
#include "AsusAuraTUFKeyboardLayouts.h"
enum
{
AURA_KEYBOARD_MODE_STATIC = 0,
AURA_KEYBOARD_MODE_BREATHING = 1,
AURA_KEYBOARD_MODE_COLOR_CYCLE = 2,
AURA_KEYBOARD_MODE_REACTIVE = 3,
AURA_KEYBOARD_MODE_WAVE = 4,
AURA_KEYBOARD_MODE_RIPPLE = 5,
AURA_KEYBOARD_MODE_STARRY_NIGHT = 6,
AURA_KEYBOARD_MODE_QUICKSAND = 7,
AURA_KEYBOARD_MODE_CURRENT = 8,
AURA_KEYBOARD_MODE_RAIN_DROP = 9,
AURA_KEYBOARD_MODE_DIRECT = 15,
};
enum
{
AURA_ROG_AZOTH_USB_PID = 0x1A83,
AURA_ROG_AZOTH_2_4_PID = 0x1A85,
AURA_ROG_CLAYMORE_PID = 0x184D,
AURA_ROG_FALCHION_WIRED_PID = 0x193C,
AURA_ROG_FALCHION_WIRELESS_PID = 0x193E,
AURA_ROG_STRIX_FLARE_PID = 0x1875,
AURA_ROG_STRIX_FLARE_PNK_LTD_PID = 0x18CF,
AURA_ROG_STRIX_FLARE_COD_BO4_PID = 0x18AF,
AURA_ROG_STRIX_FLARE_II_PID = 0x19FE,
AURA_ROG_STRIX_FLARE_II_ANIMATE_PID = 0x19FC,
AURA_ROG_STRIX_SCOPE_PID = 0x18F8,
AURA_ROG_STRIX_SCOPE_RX_PID = 0x1951,
AURA_ROG_STRIX_SCOPE_RX_EVA_02_PID = 0x1B12,
AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID = 0x19F6,
AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID = 0x19F8,
AURA_ROG_STRIX_SCOPE_II_PID = 0x1AB3,
AURA_ROG_STRIX_SCOPE_II_RX_PID = 0x1AB5,
AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID = 0x1AAE,
AURA_ROG_STRIX_SCOPE_II_96_RX_WIRELESS_USB_PID = 0x1B78,
AURA_TUF_K1_GAMING_PID = 0x1945,
AURA_TUF_K3_GAMING_PID = 0x194B,
AURA_TUF_K3_GAMING_GEN_II_PID = 0x1B30,
AURA_TUF_K5_GAMING_PID = 0x1899,
AURA_TUF_K7_GAMING_PID = 0x18AA,
AURA_TUF_K3_GENII_MIKU_EDITION_PID = 0x1C5E,
};
struct led_color
{
unsigned int value;
RGBColor color;
};
class AuraTUFKeyboardController
{
public:
AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version, std::string dev_name);
~AuraTUFKeyboardController();
std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString();
std::string GetVersion();
int GetLayout();
int GetNumpadLocation();
void SaveMode();
void AllowRemoteControl(unsigned char type);
void UpdateSingleLed
(
int led,
unsigned char red,
unsigned char green,
unsigned char blue
);
void UpdateLeds
(
std::vector<led_color> colors
);
void UpdateK1Wave
(
std::vector<RGBColor> colors,
unsigned char direction,
unsigned char speed,
unsigned char brightness
);
void UpdateScopeIIRainbowRipple
(
unsigned char mode,
std::vector<RGBColor> colors,
unsigned char direction,
unsigned char color_mode,
unsigned char speed,
unsigned char brightness
);
void UpdateScopeIIQuicksand
(
std::vector<RGBColor> colors,
unsigned char direction,
unsigned char color_mode,
unsigned char speed,
unsigned char brightness
);
void UpdateDevice
(
unsigned char mode,
std::vector<RGBColor> colors,
unsigned char direction,
unsigned char color_mode,
unsigned char speed,
unsigned char brightness
);
void UpdateQuicksandColors(std::vector<RGBColor> colors);
void UpdateMode(unsigned char mode);
void AwaitResponse(int ms);
void ClearResponses();
uint16_t device_pid;
bool is_per_led_keyboard;
private:
hid_device* dev;
std::string location;
std::string name;
unsigned short rev_version;
};
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/AsusAuraTUFKeyboardLayouts.h
+3877
View File
File diff suppressed because it is too large Load Diff
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.cpp
+672
View File
@@ -0,0 +1,672 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraTUFKeyboard.cpp |
| |
| RGBController for ASUS Aura TUF keyboard |
| |
| Mola19 03 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cmath>
#include <vector>
#include "RGBController_AsusAuraTUFKeyboard.h"
/**------------------------------------------------------------------*\
@name Asus Aura TUF Keyboard
@category Keyboard
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraTUFUSBKeyboard
@comment
\*-------------------------------------------------------------------*/
RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr)
{
controller = controller_ptr;
pid = controller->device_pid;
if(pid != AURA_ROG_CLAYMORE_PID)
{
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Aura Keyboard Device";
version = controller->GetVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
unsigned char AURA_KEYBOARD_SPEED_MIN = 0;
unsigned char AURA_KEYBOARD_SPEED_MAX = 0;
unsigned char AURA_KEYBOARD_SPEED_DEFAULT = 0;
switch(pid)
{
case AURA_TUF_K1_GAMING_PID:
AURA_KEYBOARD_SPEED_MIN = 0;
AURA_KEYBOARD_SPEED_MAX = 2;
AURA_KEYBOARD_SPEED_DEFAULT = 1;
break;
case AURA_ROG_STRIX_FLARE_PID:
case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
case AURA_TUF_K3_GAMING_PID:
case AURA_TUF_K7_GAMING_PID:
case AURA_TUF_K3_GENII_MIKU_EDITION_PID:
AURA_KEYBOARD_SPEED_MIN = 15;
AURA_KEYBOARD_SPEED_MAX = 0;
AURA_KEYBOARD_SPEED_DEFAULT = 8;
break;
case AURA_ROG_AZOTH_USB_PID:
case AURA_ROG_AZOTH_2_4_PID:
case AURA_ROG_FALCHION_WIRED_PID:
case AURA_ROG_FALCHION_WIRELESS_PID:
case AURA_ROG_STRIX_FLARE_II_PID:
case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
case AURA_ROG_STRIX_SCOPE_RX_PID:
case AURA_ROG_STRIX_SCOPE_RX_EVA_02_PID:
case AURA_ROG_STRIX_SCOPE_PID:
case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
case AURA_ROG_STRIX_SCOPE_II_PID:
case AURA_ROG_STRIX_SCOPE_II_RX_PID:
case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
case AURA_ROG_STRIX_SCOPE_II_96_RX_WIRELESS_USB_PID:
case AURA_TUF_K5_GAMING_PID:
AURA_KEYBOARD_SPEED_MIN = 255;
AURA_KEYBOARD_SPEED_MAX = 0;
AURA_KEYBOARD_SPEED_DEFAULT = 30;
break;
default:
AURA_KEYBOARD_SPEED_MIN = 15;
AURA_KEYBOARD_SPEED_MAX = 0;
AURA_KEYBOARD_SPEED_DEFAULT = 8;
break;
}
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_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 Breathing;
Breathing.name = "Breathing";
Breathing.value = AURA_KEYBOARD_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
if(controller->is_per_led_keyboard)
{
Breathing.flags |= MODE_FLAG_HAS_RANDOM_COLOR;
}
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 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 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_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
if(controller->is_per_led_keyboard)
{
Wave.flags |= MODE_FLAG_HAS_DIRECTION_UD;
}
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;
if(!controller->is_per_led_keyboard)
{
Wave.colors_min = 5;
Wave.colors_max = 5;
}
else
{
Wave.colors_min = 1;
Wave.colors_max = 7;
}
Wave.colors.resize(Wave.colors_max);
modes.push_back(Wave);
if(controller->is_per_led_keyboard)
{
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 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 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 = controller->GetName();
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();
}
RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
{
delete controller;
}
void RGBController_AuraTUFKeyboard::SetupZones()
{
std::map<int,layout_info> * keyboard_ptr;
switch(pid)
{
case AURA_ROG_STRIX_FLARE_PID:
case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
keyboard_ptr = &AsusROGStrixFlareLayouts;
break;
case AURA_TUF_K3_GAMING_PID:
case AURA_TUF_K7_GAMING_PID:
case AURA_TUF_K3_GENII_MIKU_EDITION_PID:
keyboard_ptr = &AsusTUFK7Layouts;
break;
case AURA_ROG_STRIX_SCOPE_PID:
case AURA_ROG_STRIX_SCOPE_RX_PID:
case AURA_ROG_STRIX_SCOPE_RX_EVA_02_PID:
case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
keyboard_ptr = &AsusROGStrixScopeLayouts;
break;
case AURA_ROG_STRIX_SCOPE_II_PID:
case AURA_ROG_STRIX_SCOPE_II_RX_PID:
keyboard_ptr = &AsusROGStrixScopeIILayouts;
break;
case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
keyboard_ptr = &AsusROGStrixScopeII96WirelessLayouts;
break;
case AURA_ROG_STRIX_SCOPE_II_96_RX_WIRELESS_USB_PID:
keyboard_ptr = &AsusROGStrixScopeII96RxWirelessLayouts;
break;
case AURA_ROG_STRIX_FLARE_II_PID:
keyboard_ptr = &AsusROGStrixFlareIILayouts;
break;
case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
keyboard_ptr = &AsusROGStrixFlareIIAnimateLayouts;
break;
case AURA_ROG_AZOTH_USB_PID:
case AURA_ROG_AZOTH_2_4_PID:
keyboard_ptr = &AsusROGAzothLayouts;
break;
case AURA_ROG_FALCHION_WIRED_PID:
case AURA_ROG_FALCHION_WIRELESS_PID:
keyboard_ptr = &AsusFalchionLayouts;
break;
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_K1_GAMING_PID:
case AURA_TUF_K5_GAMING_PID:
keyboard_ptr = &AsusTufK1Layouts;
break;
case AURA_TUF_K3_GAMING_GEN_II_PID:
keyboard_ptr = &AsusTUFK3GamingGen2Layouts;
break;
default:
keyboard_ptr = &AsusTUFK7Layouts;
}
std::map<int,layout_info> & keyboard = *keyboard_ptr;
unsigned char layout = controller->GetLayout();
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
{
layout = layout % 100;
}
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);
for(int led_id = 0; led_id < keyboard[layout].size; led_id++)
{
led new_led;
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*/)
{
}
void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
{
std::vector<led_color> led_color_list = {};
for(size_t 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*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
{
if(!controller->is_per_led_keyboard)
{
return DeviceUpdateLEDs();
}
unsigned char red = RGBGetRValue(colors[led]);
unsigned char green = RGBGetGValue(colors[led]);
unsigned char blue = RGBGetBValue(colors[led]);
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()
{
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)
{
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:
if(!controller->is_per_led_keyboard && modes[active_mode].colors.size() > 1)
{
color_mode = 1;
break;
}
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 || modes[active_mode].value == AURA_KEYBOARD_MODE_QUICKSAND)
{
/*----------------------------------------------------------*\
| converting openrgb direction value to keyboard directions |
\*----------------------------------------------------------*/
direction = direction_map[0][modes[active_mode].direction];
}
}
else
{
if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
{
color_mode = 1;
}
if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE) {
if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) color_mode = 2;
/*----------------------------------------------------------*\
| converting openrgb direction value to keyboard directions |
\*----------------------------------------------------------*/
direction = direction_map[1][modes[active_mode].direction];
}
}
controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), direction, color_mode, modes[active_mode].speed, brightness);
if(pid == AURA_ROG_CLAYMORE_PID)
{
controller->UpdateMode(modes[active_mode].value);
controller->SaveMode();
controller->AllowRemoteControl(0);
}
}
void RGBController_AuraTUFKeyboard::DeviceSaveMode()
{
/*----------------------------------------------------------*\
| not available for Claymore |
\*----------------------------------------------------------*/
if(pid != AURA_ROG_CLAYMORE_PID)
{
DeviceUpdateMode();
controller->SaveMode();
}
}
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.h
+58
View File
@@ -0,0 +1,58 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraTUFKeyboard.h |
| |
| RGBController for ASUS Aura TUF keyboard |
| |
| Mola19 03 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusAuraTUFKeyboardController.h"
enum
{
AURA_KEYBOARD_BRIGHTNESS_MIN = 0,
AURA_KEYBOARD_BRIGHTNESS_MAX = 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
{
public:
RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr);
~RGBController_AuraTUFKeyboard();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
AuraTUFKeyboardController* controller;
uint16_t pid;
};