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/AsusAuraHeadsetStandController/AsusAuraHeadsetStandController.cpp
+157
View File
@@ -0,0 +1,157 @@
/*---------------------------------------------------------*\
| AsusAuraHeadsetStandController.cpp |
| |
| Driver for ASUS Aura headset stand |
| |
| Mola19 06 Apr 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "AsusAuraHeadsetStandController.h"
#include "StringUtils.h"
AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
}
AuraHeadsetStandController::~AuraHeadsetStandController()
{
hid_close(dev);
}
std::string AuraHeadsetStandController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string AuraHeadsetStandController::GetName()
{
return(name);
}
std::string AuraHeadsetStandController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string AuraHeadsetStandController::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[5];
snprintf(version, 5, "%04X", (usb_buf_out[6] << 8) | usb_buf_out[7]);
return std::string(version);
}
void AuraHeadsetStandController::UpdateLeds
(
std::vector<RGBColor> colors
)
{
unsigned char usb_buf_0[365];
memset(usb_buf_0, 0x00, sizeof(usb_buf_0));
usb_buf_0[0x00] = 0x00;
usb_buf_0[0x01] = 0xC0;
usb_buf_0[0x02] = 0x81;
usb_buf_0[0x03] = 0x00;
usb_buf_0[0x04] = 0x00;
for(unsigned int i = 0; i < 60; i += 4)
{
usb_buf_0[5 + i] = 0x00;
usb_buf_0[6 + i] = RGBGetRValue(colors[i / 4]);
usb_buf_0[7 + i] = RGBGetGValue(colors[i / 4]);
usb_buf_0[8 + i] = RGBGetBValue(colors[i / 4]);
}
hid_write(dev, usb_buf_0, 65);
unsigned char usb_buf_1[65];
memset(usb_buf_1, 0x00, sizeof(usb_buf_1));
usb_buf_1[0x00] = 0x00;
usb_buf_1[0x01] = 0xC0;
usb_buf_1[0x02] = 0x81;
usb_buf_1[0x03] = 0x01;
usb_buf_1[0x04] = 0x00;
for(unsigned int i = 0; i < 12; i += 4)
{
usb_buf_1[5 + i] = 0x00;
usb_buf_1[6 + i] = RGBGetRValue(colors[(i / 4) + 15]);
usb_buf_1[7 + i] = RGBGetGValue(colors[(i / 4) + 15]);
usb_buf_1[8 + i] = RGBGetBValue(colors[(i / 4) + 15]);
}
hid_write(dev, usb_buf_1, 65);
}
void AuraHeadsetStandController::UpdateDevice
(
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu,
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] = 0x28;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = mode;
usb_buf[0x06] = speed;
usb_buf[0x07] = brightness;
usb_buf[0x08] = 0x00;
usb_buf[0x09] = 0x00;
usb_buf[0x0a] = red;
usb_buf[0x0b] = grn;
usb_buf[0x0c] = blu;
hid_write(dev, usb_buf, 65);
}
void AuraHeadsetStandController::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;
hid_write(dev, usb_save_buf, 65);
}
Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/AsusAuraHeadsetStandController.h
+65
View File
@@ -0,0 +1,65 @@
/*---------------------------------------------------------*\
| AsusAuraHeadsetStandController.h |
| |
| Driver for ASUS Aura headset stand |
| |
| Mola19 06 Apr 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <hidapi.h>
#include "RGBController.h"
enum
{
AURA_HEADSET_STAND_ZONE_UNDERGLOW = 0,
AURA_HEADSET_STAND_ZONE_LOGO = 1
};
enum
{
AURA_HEADSET_STAND_MODE_DIRECT = 0,
AURA_HEADSET_STAND_MODE_STATIC = 1,
AURA_HEADSET_STAND_MODE_BREATHING = 2,
AURA_HEADSET_STAND_MODE_STROBING = 3,
AURA_HEADSET_STAND_MODE_COLOR_CYCLE = 4,
AURA_HEADSET_STAND_MODE_RAINBOW = 5
};
class AuraHeadsetStandController
{
public:
AuraHeadsetStandController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~AuraHeadsetStandController();
std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString();
std::string GetVersion();
void UpdateLeds
(
std::vector<RGBColor> colors
);
void UpdateDevice
(
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu,
unsigned char speed,
unsigned char brightness
);
void SaveMode();
private:
hid_device* dev;
std::string location;
std::string name;
};
Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/RGBController_AsusAuraHeadsetStand.cpp
+211
View File
@@ -0,0 +1,211 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraHeadsetStand.cpp |
| |
| RGBController for ASUS Aura headset stand |
| |
| Mola19 06 Apr 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_AsusAuraHeadsetStand.h"
/**------------------------------------------------------------------*\
@name Asus Aura Headset Stand
@category HeadsetStand
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraUSBHeadsetStand
@comment
\*-------------------------------------------------------------------*/
RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_HEADSET_STAND;
description = "ASUS Aura Headset Stand Device";
version = controller->GetVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = AURA_HEADSET_STAND_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_HEADSET_STAND_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Static.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
Static.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
Static.brightness = AURA_HEADSETSTAND_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_HEADSET_STAND_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed_min = AURA_HEADSETSTAND_SPEED_MIN;
Breathing.speed_max = AURA_HEADSETSTAND_SPEED_MAX;
Breathing.speed = AURA_HEADSETSTAND_SPEED_DEFAULT;
Breathing.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
Breathing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
Breathing.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode Strobing;
Strobing.name = "Flashing";
Strobing.value = AURA_HEADSET_STAND_MODE_STROBING;
Strobing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Strobing.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
Strobing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
Strobing.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
Strobing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Strobing.colors_min = 1;
Strobing.colors_max = 1;
Strobing.colors.resize(1);
modes.push_back(Strobing);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = AURA_HEADSET_STAND_MODE_COLOR_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
SpectrumCycle.speed_min = AURA_HEADSETSTAND_SPEED_MIN;
SpectrumCycle.speed_max = AURA_HEADSETSTAND_SPEED_MAX;
SpectrumCycle.speed = AURA_HEADSETSTAND_SPEED_DEFAULT;
SpectrumCycle.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
SpectrumCycle.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
SpectrumCycle.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
mode Rainbow;
Rainbow.name = "Rainbow Wave";
Rainbow.value = AURA_HEADSET_STAND_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Rainbow.speed_min = AURA_HEADSETSTAND_SPEED_MIN;
Rainbow.speed_max = AURA_HEADSETSTAND_SPEED_MAX;
Rainbow.speed = AURA_HEADSETSTAND_SPEED_DEFAULT;
Rainbow.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
Rainbow.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
Rainbow.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
modes.push_back(Rainbow);
SetupZones();
}
RGBController_AuraHeadsetStand::~RGBController_AuraHeadsetStand()
{
delete controller;
}
void RGBController_AuraHeadsetStand::SetupZones()
{
zone underglow_zone;
underglow_zone.name = "Underglow";
underglow_zone.type = ZONE_TYPE_LINEAR;
underglow_zone.leds_min = 17;
underglow_zone.leds_max = 17;
underglow_zone.leds_count = 17;
underglow_zone.matrix_map = NULL;
zones.push_back(underglow_zone);
for(unsigned int i = 0; i < 17; i++)
{
led underglow_led;
underglow_led.name = "Underglow LED " + std::to_string(i);
leds.push_back(underglow_led);
}
zone logo_zone;
logo_zone.name = "Logo";
logo_zone.type = ZONE_TYPE_SINGLE;
logo_zone.leds_min = 1;
logo_zone.leds_max = 1;
logo_zone.leds_count = 1;
logo_zone.matrix_map = NULL;
zones.push_back(logo_zone);
led logo_led;
logo_led.name = "Logo LED";
leds.push_back(logo_led);
SetupColors();
}
void RGBController_AuraHeadsetStand::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AuraHeadsetStand::DeviceUpdateLEDs()
{
controller->UpdateLeds(std::vector<RGBColor>(colors));
}
void RGBController_AuraHeadsetStand::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraHeadsetStand::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraHeadsetStand::DeviceUpdateMode()
{
unsigned char red = 0;
unsigned char grn = 0;
unsigned char blu = 0;
switch(modes[active_mode].value)
{
case 0:
controller->UpdateLeds(std::vector<RGBColor>(colors));
break;
case 1:
case 2:
case 3:
red = RGBGetRValue(modes[active_mode].colors[0]);
grn = RGBGetGValue(modes[active_mode].colors[0]);
blu = RGBGetBValue(modes[active_mode].colors[0]);
controller->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, modes[active_mode].brightness);
break;
case 4:
case 5:
controller->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, modes[active_mode].brightness);
break;
}
}
void RGBController_AuraHeadsetStand::DeviceSaveMode()
{
DeviceUpdateMode();
controller->SaveMode();
}
Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/RGBController_AsusAuraHeadsetStand.h
+46
View File
@@ -0,0 +1,46 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraHeadsetStand.h |
| |
| RGBController for ASUS Aura headset stand |
| |
| Mola19 06 Apr 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusAuraHeadsetStandController.h"
enum
{
AURA_HEADSETSTAND_BRIGHTNESS_MIN = 0,
AURA_HEADSETSTAND_BRIGHTNESS_MAX = 4,
AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT = 4,
AURA_HEADSETSTAND_SPEED_MIN = 0,
AURA_HEADSETSTAND_SPEED_MAX = 255,
AURA_HEADSETSTAND_SPEED_DEFAULT = 127,
};
class RGBController_AuraHeadsetStand : public RGBController
{
public:
RGBController_AuraHeadsetStand(AuraHeadsetStandController* controller_ptr);
~RGBController_AuraHeadsetStand();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
AuraHeadsetStandController* controller;
};
Controllers/AsusAuraUSBController/AsusAuraKeyboardController/AsusAuraKeyboardController.cpp
+120
View File
@@ -0,0 +1,120 @@
/*---------------------------------------------------------*\
| AsusAuraKeyboardController.cpp |
| |
| Driver for ASUS Aura keyboard |
| |
| Adam Honse (CalcProgrammer1) 19 Mar 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "AsusAuraKeyboardController.h"
#include "StringUtils.h"
AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
}
AuraKeyboardController::~AuraKeyboardController()
{
hid_close(dev);
}
std::string AuraKeyboardController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string AuraKeyboardController::GetNameString()
{
return(name);
}
std::string AuraKeyboardController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
void AuraKeyboardController::SendDirect
(
unsigned char frame_count,
unsigned char * frame_data
)
{
unsigned char usb_buf[65];
unsigned int packet_count = frame_count / 15 + (((frame_count % 15) == 0) ? 0 : 1);
unsigned int total_frame_idx = 0;
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xC0;
usb_buf[0x02] = 0x81;
usb_buf[0x03] = packet_count * 15;
usb_buf[0x04] = 0x00;
/*-----------------------------------------------------*\
| Copy in frame data and send packets until all data |
| has been sent |
\*-----------------------------------------------------*/
for(unsigned int packet_idx = 0; packet_idx < packet_count; packet_idx++)
{
unsigned int packet_data_size = 15 * 4;
if((frame_count - total_frame_idx) < 15)
{
packet_data_size = (frame_count - total_frame_idx) * 4;
memset(&usb_buf[0x05 + packet_data_size], 0xFF, (15*4) - packet_data_size);
}
memcpy(&usb_buf[0x05], &frame_data[packet_idx * 15 * 4], packet_data_size);
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
/*-----------------------------------------------------*\
| Decrement remaining frame count |
\*-----------------------------------------------------*/
usb_buf[0x03] -= 0x0F;
total_frame_idx += 0x0F;
}
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xC0;
usb_buf[0x02] = 0x81;
usb_buf[0x03] = 0x90;
/*-----------------------------------------------------*\
| Read to apply |
\*-----------------------------------------------------*/
hid_read(dev,usb_buf, 65);
}
Controllers/AsusAuraUSBController/AsusAuraKeyboardController/AsusAuraKeyboardController.h
+39
View File
@@ -0,0 +1,39 @@
/*---------------------------------------------------------*\
| AsusAuraKeyboardController.h |
| |
| Driver for ASUS Aura keyboard |
| |
| Adam Honse (CalcProgrammer1) 19 Mar 2020 |
| |
| 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"
class AuraKeyboardController
{
public:
AuraKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~AuraKeyboardController();
std::string GetDeviceLocation();
std::string GetNameString();
std::string GetSerialString();
void SendDirect
(
unsigned char frame_count,
unsigned char * frame_data
);
private:
hid_device* dev;
std::string location;
std::string name;
};
Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.cpp
+535
View File
@@ -0,0 +1,535 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraKeyboard.cpp |
| |
| RGBController for ASUS Aura keyboard |
| |
| Adam Honse (CalcProgrammer1) 19 Mar 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBControllerKeyNames.h"
#include "RGBController_AsusAuraKeyboard.h"
//0xFFFFFFFF indicates an unused entry in matrix
#define NA 0xFFFFFFFF
static unsigned int flare_matrix_map[6][22] =
{ { 0, NA, 13, 18, 23, 28, 38, 43, 49, 54, 60, 65, 69, 70, NA, 76, 80, 85, NA, NA, NA, NA },
{ 1, 8, 14, 19, 24, 29, 34, 39, 44, 50, 55, 61, 66, 71, NA, 77, 81, 86, 89, 94, 98, 103 },
{ 2, NA, 9, 15, 20, 25, 30, 35, 40, 45, 51, 56, 62, 67, 72, 78, 82, 87, 90, 95, 99, 104 },
{ 3, NA, 10, 16, 21, 26, 31, 36, 41, 46, 52, 57, 63, 68, 73, NA, NA, NA, 91, 96, 100, NA },
{ 4, 6, 11, 17, 22, 27, 32, 37, 42, 47, 53, 58, 74, NA, NA, NA, 83, NA, 92, 97, 101, 105 },
{ 5, 7, 12, NA, NA, NA, NA, 33, NA, 48, NA, 59, 64, 75, NA, 79, 84, 88, 93, NA, 102, NA } };
static unsigned int scope_matrix_map[6][22] =
{ { 0, NA, 13, 18, 23, 28, 38, 43, 49, 54, 60, 65, 69, 70, NA, 76, 80, 85, NA, NA, NA, NA },
{ 1, 8, 14, 19, 24, 29, 34, 39, 44, 50, 55, 61, 66, 71, NA, 77, 81, 86, 89, 94, 98, 103 },
{ 2, NA, 9, 15, 20, 25, 30, 35, 40, 45, 51, 56, 62, 67, 72, 78, 82, 87, 90, 95, 99, 104 },
{ 3, NA, 10, 16, 21, 26, 31, 36, 41, 46, 52, 57, 63, 68, 73, NA, NA, NA, 91, 96, 100, NA },
{ 4, 6, 11, 17, 22, 27, 32, 37, 42, 47, 53, 58, 74, NA, NA, NA, 83, NA, 92, 97, 101, 105 },
{ 5, NA, 7, 12, NA, NA, NA, 33, NA, 48, NA, 59, 64, 75, NA, 79, 84, 88, 93, NA, 102, NA } };
static unsigned int scope_tkl_matrix_map[6][18] =
{ { 0, NA, 13, 18, 23, 28, 38, 43, 49, 54, 60, 65, 69, 70, NA, NA, NA, NA },
{ 1, 8, 14, 19, 24, 29, 34, 39, 44, 50, 55, 61, 66, 71, NA, 76, 79, 83 },
{ 2, NA, 9, 15, 20, 25, 30, 35, 40, 45, 51, 56, 62, 67, 72, 77, 80, 84 },
{ 3, NA, 10, 16, 21, 26, 31, 36, 41, 46, 52, 57, 63, 68, 73, NA, NA, NA },
{ 4, 6, 11, 17, 22, 27, 32, 37, 42, 47, 53, 58, 74, NA, NA, NA, 81, NA },
{ 5, NA, 7, 12, NA, NA, NA, 33, NA, 48, NA, 59, 64, 75, NA, 78, 82, 85 } };
static unsigned int falchion_matrix_map[5][16] =
{ { 0, 5, 9, 14, 18, 22, 26, 31, 35, 39, 44, 49, 54, 58, NA, 63 },
{ 1, NA, 6, 10, 15, 19, 23, 27, 32, 36, 40, 45, 50, 55, 59, 64 },
{ 2, NA, 7, 11, 16, 20, 24, 28, 33, 37, 41, 46, 51, 60, NA, 65 },
{ 3, NA, 12, 17, 21, 25, 29, 34, 38, 42, 47, 52, 56, NA, 61, 66 },
{ 4, 8, 13, NA, NA, NA, 30, NA, NA, NA, 43, 48, 53, 57, 62, 67 } };
static const std::vector<aura_keyboard_led> default_led_names =
{
/* Key Label Index */
{ KEY_EN_ESCAPE, 0x00 },
{ KEY_EN_BACK_TICK, 0x01 },
{ KEY_EN_TAB, 0x02 },
{ KEY_EN_CAPS_LOCK, 0x03 },
{ KEY_EN_LEFT_SHIFT, 0x04 },
{ KEY_EN_LEFT_CONTROL, 0x05 },
{ KEY_EN_ISO_BACK_SLASH, 0x0C },
{ KEY_EN_1, 0x11 },
{ KEY_EN_Q, 0x12 },
{ KEY_EN_A, 0x13 },
{ KEY_EN_Z, 0x14 },
{ KEY_EN_F1, 0x18 },
{ KEY_EN_2, 0x19 },
{ KEY_EN_W, 0x1A },
{ KEY_EN_S, 0x1B },
{ KEY_EN_X, 0x1C },
{ KEY_EN_F2, 0x20 },
{ KEY_EN_3, 0x21 },
{ KEY_EN_E, 0x22 },
{ KEY_EN_D, 0x23 },
{ KEY_EN_C, 0x24 },
{ KEY_EN_F3, 0x28 },
{ KEY_EN_4, 0x29 },
{ KEY_EN_R, 0x2A },
{ KEY_EN_F, 0x2B },
{ KEY_EN_V, 0x2C },
{ KEY_EN_F4, 0x30 },
{ KEY_EN_5, 0x31 },
{ KEY_EN_T, 0x32 },
{ KEY_EN_G, 0x33 },
{ KEY_EN_B, 0x34 },
{ KEY_EN_SPACE, 0x35 },
{ KEY_EN_6, 0x39 },
{ KEY_EN_Y, 0x3A },
{ KEY_EN_H, 0x3B },
{ KEY_EN_N, 0x3C },
{ KEY_EN_F5, 0x40 },
{ KEY_EN_7, 0x41 },
{ KEY_EN_U, 0x42 },
{ KEY_EN_J, 0x43 },
{ KEY_EN_M, 0x44 },
{ KEY_EN_F6, 0x48 },
{ KEY_EN_8, 0x49 },
{ KEY_EN_I, 0x4A },
{ KEY_EN_K, 0x4B },
{ KEY_EN_COMMA, 0x4C },
{ KEY_EN_RIGHT_ALT, 0x4D },
{ KEY_EN_F7, 0x50 },
{ KEY_EN_9, 0x51 },
{ KEY_EN_O, 0x52 },
{ KEY_EN_L, 0x53 },
{ KEY_EN_PERIOD, 0x54 },
{ KEY_EN_F8, 0x58 },
{ KEY_EN_0, 0x59 },
{ KEY_EN_P, 0x5A },
{ KEY_EN_SEMICOLON, 0x5B },
{ KEY_EN_FORWARD_SLASH, 0x5C },
{ KEY_EN_RIGHT_FUNCTION, 0x5D },
{ KEY_EN_F9, 0x60 },
{ KEY_EN_MINUS, 0x61 },
{ KEY_EN_LEFT_BRACKET, 0x62 },
{ KEY_EN_QUOTE, 0x63 },
{ KEY_EN_MENU, 0x65 },
{ KEY_EN_F10, 0x68 },
{ KEY_EN_EQUALS, 0x69 },
{ KEY_EN_RIGHT_BRACKET, 0x6A },
{ KEY_EN_POUND, 0x6B },
{ KEY_EN_F11, 0x70 },
{ KEY_EN_F12, 0x78 },
{ KEY_EN_BACKSPACE, 0x79 },
{ KEY_EN_ANSI_BACK_SLASH, 0x7A },
{ KEY_EN_ANSI_ENTER, 0x7B },
{ KEY_EN_RIGHT_SHIFT, 0x7C },
{ KEY_EN_RIGHT_CONTROL, 0x7D },
{ KEY_EN_PRINT_SCREEN, 0x80 },
{ KEY_EN_INSERT, 0x81 },
{ KEY_EN_DELETE, 0x82 },
{ KEY_EN_LEFT_ARROW, 0x85 },
{ KEY_EN_SCROLL_LOCK, 0x88 },
{ KEY_EN_HOME, 0x89 },
{ KEY_EN_END, 0x8A },
{ KEY_EN_UP_ARROW, 0x8C },
{ KEY_EN_DOWN_ARROW, 0x8D },
{ KEY_EN_PAUSE_BREAK, 0x90 },
{ KEY_EN_PAGE_UP, 0x91 },
{ KEY_EN_PAGE_DOWN, 0x92 },
{ KEY_EN_RIGHT_ARROW, 0x95 },
{ KEY_EN_NUMPAD_LOCK, 0x99 },
{ KEY_EN_NUMPAD_7, 0x9A },
{ KEY_EN_NUMPAD_4, 0x9B },
{ KEY_EN_NUMPAD_1, 0x9C },
{ KEY_EN_NUMPAD_0, 0x9D },
{ KEY_EN_NUMPAD_DIVIDE, 0xA1 },
{ KEY_EN_NUMPAD_8, 0xA2 },
{ KEY_EN_NUMPAD_5, 0xA3 },
{ KEY_EN_NUMPAD_2, 0xA4 },
{ KEY_EN_NUMPAD_TIMES, 0xA9 },
{ KEY_EN_NUMPAD_9, 0xAA },
{ KEY_EN_NUMPAD_6, 0xAB },
{ KEY_EN_NUMPAD_3, 0xAC },
{ KEY_EN_NUMPAD_PERIOD, 0xAD },
{ KEY_EN_NUMPAD_MINUS, 0xB1 },
{ KEY_EN_NUMPAD_PLUS, 0xB2 },
{ KEY_EN_NUMPAD_ENTER, 0xB4 },
};
static const std::vector<aura_keyboard_led> default_tkl_led_names =
{
/* Key Label Index */
{ KEY_EN_ESCAPE, 0x00 },
{ KEY_EN_BACK_TICK, 0x01 },
{ KEY_EN_TAB, 0x02 },
{ KEY_EN_CAPS_LOCK, 0x03 },
{ KEY_EN_LEFT_SHIFT, 0x04 },
{ KEY_EN_LEFT_CONTROL, 0x05 },
{ KEY_EN_ISO_BACK_SLASH, 0x0C },
{ KEY_EN_1, 0x11 },
{ KEY_EN_Q, 0x12 },
{ KEY_EN_A, 0x13 },
{ KEY_EN_Z, 0x14 },
{ KEY_EN_F1, 0x18 },
{ KEY_EN_2, 0x19 },
{ KEY_EN_W, 0x1A },
{ KEY_EN_S, 0x1B },
{ KEY_EN_X, 0x1C },
{ KEY_EN_F2, 0x20 },
{ KEY_EN_3, 0x21 },
{ KEY_EN_E, 0x22 },
{ KEY_EN_D, 0x23 },
{ KEY_EN_C, 0x24 },
{ KEY_EN_F3, 0x28 },
{ KEY_EN_4, 0x29 },
{ KEY_EN_R, 0x2A },
{ KEY_EN_F, 0x2B },
{ KEY_EN_V, 0x2C },
{ KEY_EN_F4, 0x30 },
{ KEY_EN_5, 0x31 },
{ KEY_EN_T, 0x32 },
{ KEY_EN_G, 0x33 },
{ KEY_EN_B, 0x34 },
{ KEY_EN_SPACE, 0x35 },
{ KEY_EN_6, 0x39 },
{ KEY_EN_Y, 0x3A },
{ KEY_EN_H, 0x3B },
{ KEY_EN_N, 0x3C },
{ KEY_EN_F5, 0x40 },
{ KEY_EN_7, 0x41 },
{ KEY_EN_U, 0x42 },
{ KEY_EN_J, 0x43 },
{ KEY_EN_M, 0x44 },
{ KEY_EN_F6, 0x48 },
{ KEY_EN_8, 0x49 },
{ KEY_EN_I, 0x4A },
{ KEY_EN_K, 0x4B },
{ KEY_EN_COMMA, 0x4C },
{ KEY_EN_RIGHT_ALT, 0x4D },
{ KEY_EN_F7, 0x50 },
{ KEY_EN_9, 0x51 },
{ KEY_EN_O, 0x52 },
{ KEY_EN_L, 0x53 },
{ KEY_EN_PERIOD, 0x54 },
{ KEY_EN_F8, 0x58 },
{ KEY_EN_0, 0x59 },
{ KEY_EN_P, 0x5A },
{ KEY_EN_SEMICOLON, 0x5B },
{ KEY_EN_FORWARD_SLASH, 0x5C },
{ KEY_EN_RIGHT_FUNCTION, 0x5D },
{ KEY_EN_F9, 0x60 },
{ KEY_EN_MINUS, 0x61 },
{ KEY_EN_LEFT_BRACKET, 0x62 },
{ KEY_EN_QUOTE, 0x63 },
{ KEY_EN_MENU, 0x65 },
{ KEY_EN_F10, 0x68 },
{ KEY_EN_EQUALS, 0x69 },
{ KEY_EN_RIGHT_BRACKET, 0x6A },
{ KEY_EN_POUND, 0x6B },
{ KEY_EN_F11, 0x70 },
{ KEY_EN_F12, 0x78 },
{ KEY_EN_BACKSPACE, 0x79 },
{ KEY_EN_ANSI_BACK_SLASH, 0x7A },
{ KEY_EN_ANSI_ENTER, 0x7B },
{ KEY_EN_RIGHT_SHIFT, 0x7C },
{ KEY_EN_RIGHT_CONTROL, 0x7D },
{ KEY_EN_INSERT, 0x81 },
{ KEY_EN_DELETE, 0x82 },
{ KEY_EN_LEFT_ARROW, 0x85 },
{ KEY_EN_HOME, 0x89 },
{ KEY_EN_END, 0x8A },
{ KEY_EN_UP_ARROW, 0x8C },
{ KEY_EN_DOWN_ARROW, 0x8D },
{ KEY_EN_PAGE_UP, 0x91 },
{ KEY_EN_PAGE_DOWN, 0x92 },
{ KEY_EN_RIGHT_ARROW, 0x95 },
{ "Logo 1", 0x80 },
{ "Logo 2", 0x90 },
{ "Underglow 1", 0x06 },
{ "Underglow 2", 0x0E },
{ "Underglow 3", 0x16 },
{ "Underglow 4", 0x1E },
{ "Underglow 5", 0x26 },
{ "Underglow 6", 0x2E },
{ "Underglow 7", 0x36 },
{ "Underglow 8", 0x3E },
{ "Underglow 9", 0x46 },
{ "Underglow 10", 0x4E },
{ "Underglow 11", 0x56 },
{ "Underglow 12", 0x5E },
{ "Underglow 13", 0x66 },
{ "Underglow 14", 0x6E },
{ "Underglow 15", 0x76 },
{ "Underglow 16", 0x7E },
{ "Underglow 17", 0x86 },
{ "Underglow 18", 0x8E },
{ "Underglow 19", 0x96 },
{ "Underglow 20", 0x9E },
{ "Underglow 21", 0xA6 },
{ "Underglow 22", 0xAE },
{ "Underglow 23", 0xB6 },
{ "Underglow 24", 0xBE },
{ "Underglow 25", 0xC6 },
{ "Underglow 26", 0xCE },
};
static const std::vector<aura_keyboard_led> default_65pct_led_names =
{
/* Key Label Index */
{ KEY_EN_ESCAPE, 0x00 },
{ KEY_EN_TAB, 0x01 },
{ KEY_EN_CAPS_LOCK, 0x02 },
{ KEY_EN_LEFT_SHIFT, 0x03 },
{ KEY_EN_LEFT_CONTROL, 0x04 },
{ KEY_EN_1, 0x08 },
{ KEY_EN_Q, 0x09 },
{ KEY_EN_A, 0x0A },
{ KEY_EN_LEFT_WINDOWS, 0x0C },
{ KEY_EN_2, 0x10 },
{ KEY_EN_W, 0x11 },
{ KEY_EN_S, 0x12 },
{ KEY_EN_Z, 0x13 },
{ KEY_EN_LEFT_ALT, 0x14 },
{ KEY_EN_3, 0x18 },
{ KEY_EN_E, 0x19 },
{ KEY_EN_D, 0x1A },
{ KEY_EN_X, 0x1B },
{ KEY_EN_4, 0x20 },
{ KEY_EN_R, 0x21 },
{ KEY_EN_F, 0x22 },
{ KEY_EN_C, 0x23 },
{ KEY_EN_5, 0x28 },
{ KEY_EN_T, 0x29 },
{ KEY_EN_G, 0x2A },
{ KEY_EN_V, 0x2B },
{ KEY_EN_6, 0x30 },
{ KEY_EN_Y, 0x31 },
{ KEY_EN_H, 0x32 },
{ KEY_EN_B, 0x33 },
{ KEY_EN_SPACE, 0x34 },
{ KEY_EN_7, 0x38 },
{ KEY_EN_U, 0x39 },
{ KEY_EN_J, 0x3A },
{ KEY_EN_N, 0x3B },
{ KEY_EN_8, 0x40 },
{ KEY_EN_I, 0x41 },
{ KEY_EN_K, 0x42 },
{ KEY_EN_M, 0x43 },
{ KEY_EN_9, 0x48 },
{ KEY_EN_O, 0x49 },
{ KEY_EN_L, 0x4A },
{ KEY_EN_COMMA, 0x4B },
{ KEY_EN_RIGHT_ALT, 0x4C },
{ KEY_EN_0, 0x50 },
{ KEY_EN_P, 0x51 },
{ KEY_EN_SEMICOLON, 0x52 },
{ KEY_EN_PERIOD, 0x53 },
{ KEY_EN_RIGHT_FUNCTION, 0x54 },
{ KEY_EN_MINUS, 0x58 },
{ KEY_EN_LEFT_BRACKET, 0x59 },
{ KEY_EN_QUOTE, 0x5A },
{ KEY_EN_FORWARD_SLASH, 0x5B },
{ KEY_EN_RIGHT_CONTROL, 0x5C },
{ KEY_EN_EQUALS, 0x60 },
{ KEY_EN_RIGHT_BRACKET, 0x61 },
{ KEY_EN_RIGHT_SHIFT, 0x63 },
{ KEY_EN_LEFT_ARROW, 0x64 },
{ KEY_EN_BACKSPACE, 0x68 },
{ KEY_EN_ANSI_BACK_SLASH, 0x69 },
{ KEY_EN_ANSI_ENTER, 0x6A },
{ KEY_EN_UP_ARROW, 0x6B },
{ KEY_EN_DOWN_ARROW, 0x6C },
{ KEY_EN_INSERT, 0x70 },
{ KEY_EN_DELETE, 0x71 },
{ KEY_EN_PAGE_UP, 0x72 },
{ KEY_EN_PAGE_DOWN, 0x73 },
{ KEY_EN_RIGHT_ARROW, 0x74 },
};
/**------------------------------------------------------------------*\
@name Asus Aura Keyboard
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectAsusAuraUSBKeyboards
@comment
\*-------------------------------------------------------------------*/
RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* controller_ptr, AuraKeyboardMappingLayoutType keyboard_layout)
{
controller = controller_ptr;
layout = keyboard_layout;
name = controller->GetNameString();
vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Aura Keyboard Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = 0;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
}
RGBController_AuraKeyboard::~RGBController_AuraKeyboard()
{
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
if(zones[zone_idx].type == ZONE_TYPE_MATRIX)
{
delete zones[zone_idx].matrix_map;
}
}
delete controller;
}
void RGBController_AuraKeyboard::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
std::vector<led_zone> led_zones;
std::vector<aura_keyboard_led> led_names;
switch(layout)
{
/*-----------------------------------------------------*\
| On the ROG Scope keyboards Ctrl key is double sized, |
| so there is a layout shift |
\*-----------------------------------------------------*/
case SCOPE_LAYOUT:
led_names = default_led_names;
led_zones.push_back({ZONE_EN_KEYBOARD, ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
led_names.insert(led_names.begin() + 7, {KEY_EN_LEFT_WINDOWS, 0x15});
led_names.insert(led_names.begin() + 12, {KEY_EN_LEFT_ALT, 0x1D});
break;
case SCOPE_RX_LAYOUT:
led_names = default_led_names;
led_zones.push_back({ZONE_EN_KEYBOARD, ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
led_zones.push_back({"Logo", ZONE_TYPE_SINGLE, 1, NULL});
led_names.insert(led_names.begin() + 7, {KEY_EN_LEFT_WINDOWS, 0x15});
led_names.insert(led_names.begin() + 12, {KEY_EN_LEFT_ALT, 0x1D});
led_names.push_back({ "Logo", 0xB0});
break;
case SCOPE_TKL_LAYOUT:
led_names = default_tkl_led_names;
led_zones.push_back({ZONE_EN_KEYBOARD, ZONE_TYPE_MATRIX, 86, new matrix_map_type{6, 18, (unsigned int *)&scope_tkl_matrix_map}});
led_zones.push_back({"Logo", ZONE_TYPE_LINEAR, 2, NULL});
led_zones.push_back({"Underglow", ZONE_TYPE_LINEAR, 26, NULL});
led_names.insert(led_names.begin() + 7, {KEY_EN_LEFT_WINDOWS, 0x15});
led_names.insert(led_names.begin() + 12, {KEY_EN_LEFT_ALT, 0x1D});
break;
case FLARE_LAYOUT:
led_names = default_led_names;
led_zones.push_back({ZONE_EN_KEYBOARD, ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&flare_matrix_map}});
led_zones.push_back({"Logo", ZONE_TYPE_SINGLE, 1, NULL});
led_zones.push_back({"Underglow", ZONE_TYPE_SINGLE, 2, NULL});
led_names.insert(led_names.begin() + 7, {KEY_EN_LEFT_WINDOWS, 0x0D});
led_names.insert(led_names.begin() + 12, {KEY_EN_LEFT_ALT, 0x15});
led_names.push_back({ "Logo", 0xB8});
led_names.push_back({ "Left Underglow", 0xB9});
led_names.push_back({ "Right Underglow", 0xBA});
break;
case FALCHION_LAYOUT:
led_names = default_65pct_led_names;
led_zones.push_back({ZONE_EN_KEYBOARD, ZONE_TYPE_MATRIX, 68, new matrix_map_type{5, 16, (unsigned int *)&falchion_matrix_map}});
break;
}
unsigned int total_led_count = 0;
for(unsigned int zone_idx = 0; zone_idx < led_zones.size(); zone_idx++)
{
zone new_zone;
new_zone.name = led_zones[zone_idx].name;
new_zone.type = led_zones[zone_idx].type;
new_zone.leds_min = led_zones[zone_idx].size;
new_zone.leds_max = led_zones[zone_idx].size;
new_zone.leds_count = led_zones[zone_idx].size;
if(led_zones[zone_idx].type == ZONE_TYPE_MATRIX)
{
new_zone.matrix_map = led_zones[zone_idx].matrix;
}
else
{
new_zone.matrix_map = NULL;
}
zones.push_back(new_zone);
total_led_count += led_zones[zone_idx].size;
}
for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
{
led new_led;
new_led.name = led_names[led_idx].name;
new_led.value = led_names[led_idx].idx;
leds.push_back(new_led);
}
SetupColors();
}
void RGBController_AuraKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AuraKeyboard::DeviceUpdateLEDs()
{
std::vector<unsigned char> frame_buf;
/*---------------------------------------------------------*\
| Resize the frame buffer, 4 bytes per LED |
\*---------------------------------------------------------*/
frame_buf.resize(leds.size() * 4);
/*---------------------------------------------------------*\
| TODO: Send packets with multiple LED frames |
\*---------------------------------------------------------*/
for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
{
frame_buf[(led_idx * 4) + 0] = leds[led_idx].value;
frame_buf[(led_idx * 4) + 1] = RGBGetRValue(colors[led_idx]);
frame_buf[(led_idx * 4) + 2] = RGBGetGValue(colors[led_idx]);
frame_buf[(led_idx * 4) + 3] = RGBGetBValue(colors[led_idx]);
}
controller->SendDirect((unsigned char)leds.size(), frame_buf.data());
}
void RGBController_AuraKeyboard::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraKeyboard::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraKeyboard::DeviceUpdateMode()
{
}
Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.h
+59
View File
@@ -0,0 +1,59 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraKeyboard.h |
| |
| RGBController for ASUS Aura keyboard |
| |
| Adam Honse (CalcProgrammer1) 19 Mar 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusAuraKeyboardController.h"
enum AuraKeyboardMappingLayoutType
{
FLARE_LAYOUT,
SCOPE_LAYOUT,
SCOPE_RX_LAYOUT,
SCOPE_TKL_LAYOUT,
FALCHION_LAYOUT,
};
typedef struct
{
const char* name;
unsigned char idx;
} aura_keyboard_led;
typedef struct
{
const char* name;
const zone_type type;
const unsigned int size;
matrix_map_type* matrix;
} led_zone;
class RGBController_AuraKeyboard : public RGBController
{
public:
RGBController_AuraKeyboard(AuraKeyboardController* controller_ptr, AuraKeyboardMappingLayoutType keyboard_layout);
~RGBController_AuraKeyboard();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
AuraKeyboardController* controller;
AuraKeyboardMappingLayoutType layout;
};
Controllers/AsusAuraUSBController/AsusAuraMonitorController/AsusAuraMonitorController.cpp
+123
View File
@@ -0,0 +1,123 @@
/*---------------------------------------------------------*\
| AsusAuraMonitorController.cpp |
| |
| Driver for ASUS Aura monitor |
| |
| Mola19 08 Mar 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "AsusAuraMonitorController.h"
#include "LogManager.h"
#include "StringUtils.h"
AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
{
dev = dev_handle;
location = path;
device_pid = pid;
name = dev_name;
}
AuraMonitorController::~AuraMonitorController()
{
hid_close(dev);
}
std::string AuraMonitorController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string AuraMonitorController::GetNameString()
{
return(name);
}
std::string AuraMonitorController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
void AuraMonitorController::BeginUpdate()
{
unsigned char usb_buf[8];
if (device_pid == AURA_ROG_PG32UQ_PID || device_pid == AURA_ROG_STRIX_XG32VC_PID)
{
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x03;
usb_buf[0x01] = 0x02;
usb_buf[0x02] = 0xA1;
usb_buf[0x03] = 0x80;
usb_buf[0x04] = 0x20;
hid_send_feature_report(dev, usb_buf, 8);
usb_buf[0x04] = 0x30;
hid_send_feature_report(dev, usb_buf, 8);
}
}
void AuraMonitorController::UpdateLed
(
int led,
unsigned char red,
unsigned char green,
unsigned char blue
)
{
unsigned char usb_buf[8];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x03;
usb_buf[0x01] = 0x02;
usb_buf[0x02] = 0xA1;
usb_buf[0x03] = 0x80;
unsigned char offset = (device_pid == AURA_ROG_STRIX_XG279Q_PID) ? 0 : 16;
usb_buf[0x04] = offset + led * 3;
usb_buf[0x05] = red;
hid_send_feature_report(dev, usb_buf, 8);
usb_buf[0x04] = offset + led * 3 + 1;
usb_buf[0x05] = blue;
hid_send_feature_report(dev, usb_buf, 8);
usb_buf[0x04] = offset + led * 3 + 2;
usb_buf[0x05] = green;
hid_send_feature_report(dev, usb_buf, 8);
}
void AuraMonitorController::ApplyChanges()
{
unsigned char usb_buf[8];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x03;
usb_buf[0x01] = 0x02;
usb_buf[0x02] = 0xA1;
usb_buf[0x03] = 0x80;
usb_buf[0x04] = 0xA0;
usb_buf[0x05] = 0x01;
hid_send_feature_report(dev, usb_buf, 8);
}
Controllers/AsusAuraUSBController/AsusAuraMonitorController/AsusAuraMonitorController.h
+47
View File
@@ -0,0 +1,47 @@
/*---------------------------------------------------------*\
| AsusAuraMonitorController.h |
| |
| Driver for ASUS Aura monitor |
| |
| Mola19 08 Mar 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <hidapi.h>
#include "RGBController.h"
enum
{
AURA_ROG_STRIX_XG27AQ_PID = 0x198C,
AURA_ROG_STRIX_XG27AQM_PID = 0x19BB,
AURA_ROG_STRIX_XG279Q_PID = 0x1919,
AURA_ROG_STRIX_XG27W_PID = 0x1933,
AURA_ROG_STRIX_XG32VC_PID = 0x1968,
AURA_ROG_PG32UQ_PID = 0x19B9,
};
class AuraMonitorController
{
public:
AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
virtual ~AuraMonitorController();
std::string GetDeviceLocation();
std::string GetNameString();
std::string GetSerialString();
void BeginUpdate();
void UpdateLed(int led, unsigned char red, unsigned char green, unsigned char blue);
void ApplyChanges();
uint16_t device_pid;
private:
hid_device* dev;
std::string location;
std::string name;
};
Controllers/AsusAuraUSBController/AsusAuraMonitorController/RGBController_AsusAuraMonitor.cpp
+129
View File
@@ -0,0 +1,129 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraMonitor.cpp |
| |
| RGBController for ASUS Aura monitor |
| |
| Mola19 08 Mar 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_AsusAuraMonitor.h"
/**------------------------------------------------------------------*\
@name Asus Aura Monitor
@category Accessory
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectAsusAuraUSBMonitor
@comment
\*-------------------------------------------------------------------*/
RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetNameString();
vendor = "ASUS";
type = DEVICE_TYPE_MONITOR;
description = "ASUS Aura Monitor Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = 0;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
}
RGBController_AuraMonitor::~RGBController_AuraMonitor()
{
delete controller;
}
void RGBController_AuraMonitor::SetupZones()
{
zone underglow_zone;
underglow_zone.name = "Backlight";
underglow_zone.type = ZONE_TYPE_LINEAR;
underglow_zone.leds_min = 3;
underglow_zone.leds_max = 3;
underglow_zone.leds_count = 3;
underglow_zone.matrix_map = NULL;
zones.push_back(underglow_zone);
for(unsigned int i = 0; i < 3; i++)
{
led underglow_led;
underglow_led.name = "Backlight LED " + std::to_string(i + 1);
leds.push_back(underglow_led);
}
SetupColors();
}
void RGBController_AuraMonitor::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AuraMonitor::DeviceUpdateLEDs()
{
controller->BeginUpdate();
for (int i = 0; i < 3; i++)
{
unsigned char red = RGBGetRValue(colors[i]);
unsigned char green = RGBGetGValue(colors[i]);
unsigned char blue = RGBGetBValue(colors[i]);
controller->UpdateLed(i, red, green, blue);
}
controller->ApplyChanges();
}
void RGBController_AuraMonitor::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraMonitor::UpdateSingleLED(int led)
{
controller->BeginUpdate();
unsigned char red = RGBGetRValue(colors[led]);
unsigned char green = RGBGetGValue(colors[led]);
unsigned char blue = RGBGetBValue(colors[led]);
controller->UpdateLed(led, red, green, blue);
controller->ApplyChanges();
}
void RGBController_AuraMonitor::DeviceUpdateMode()
{
/*---------------------------------------------------------*\
| This device does not support Mode changing |
\*---------------------------------------------------------*/
}
void RGBController_AuraMonitor::DeviceSaveMode()
{
/*---------------------------------------------------------*\
| This device does not support Mode saving |
\*---------------------------------------------------------*/
}
Controllers/AsusAuraUSBController/AsusAuraMonitorController/RGBController_AsusAuraMonitor.h
+36
View File
@@ -0,0 +1,36 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraMonitor.h |
| |
| RGBController for ASUS Aura monitor |
| |
| Mola19 08 Mar 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusAuraMonitorController.h"
class RGBController_AuraMonitor : public RGBController
{
public:
RGBController_AuraMonitor(AuraMonitorController* controller_ptr);
~RGBController_AuraMonitor();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
AuraMonitorController* controller;
};
Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseController.cpp
+264
View File
@@ -0,0 +1,264 @@
/*---------------------------------------------------------*\
| AsusAuraMouseController.cpp |
| |
| Driver for ASUS Aura mouse |
| |
| Adam Honse (CalcProgrammer1) 23 Oct 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "AsusAuraMouseController.h"
#include "StringUtils.h"
#define HID_MAX_STR 255
AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
{
dev = dev_handle;
location = path;
device_pid = pid;
name = dev_name;
}
AuraMouseController::~AuraMouseController()
{
hid_close(dev);
}
std::string AuraMouseController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string AuraMouseController::GetName()
{
return(name);
}
std::string AuraMouseController::GetSerialString()
{
wchar_t serial_string[HID_MAX_STR];
int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string AuraMouseController::GetVersion(bool wireless, int protocol)
{
unsigned char usb_buf[ASUS_AURA_MOUSE_PACKET_SIZE];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x12;
hid_write(dev, usb_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
unsigned char usb_buf_out[ASUS_AURA_MOUSE_PACKET_SIZE];
hid_read(dev, usb_buf_out, ASUS_AURA_MOUSE_PACKET_SIZE);
std::string str;
switch(protocol)
{
case 0:
{
unsigned char* offset = usb_buf_out + (wireless ? 13 : 4);
str = std::string(offset, offset + 4);
}
break;
case 1:
case 2:
{
char version[9];
int wireless_offset = (protocol == 2 ? 14 : 13);
int offset = (wireless ? wireless_offset : 4);
snprintf(version, 9, "%2X.%02X.%02X", usb_buf_out[offset + 2], usb_buf_out[offset + 1], usb_buf_out[offset]);
str = std::string(version);
}
break;
case 3:
{
unsigned char* offset = usb_buf_out + (wireless ? 13 : 4);
str = std::string(offset, offset + 4);
str = "0." + str.substr(0, 2) + "." + str.substr(2, 2);
}
break;
case 4:
{
char version[16];
int offset = (wireless ? 13 : 4);
snprintf(version, 16, "%2d.%02d.%02d", usb_buf_out[offset + 1], usb_buf_out[offset + 2], usb_buf_out[offset + 3]);
str = std::string(version);
}
break;
}
return str;
}
std::string AuraMouseController::CleanSerial(const std::wstring& wstr)
{
/*---------------------------------------------------------------*\
| Cleans garbage at the end of serial numbers |
| (apparently 2 characters too much, but maybe variable) |
| Limited to new devices, old ones don't even have serial numbers |
\*---------------------------------------------------------------*/
std::string result;
for(wchar_t c : wstr)
{
/*-----------------------------------------------------*\
| Forbid anything besides digits and upper case letters |
\*-----------------------------------------------------*/
bool isUpperCaseLetter = (c >= 64 && c <= 90);
bool isDigit = (c >= 48 && c <= 57);
if(!isUpperCaseLetter && !isDigit)
{
break;
}
result += (char)c;
}
return(result);
}
void AuraMouseController::SaveMode()
{
unsigned char usb_save_buf[ASUS_AURA_MOUSE_PACKET_SIZE] = { 0x00, 0x50, 0x03 };
hid_write(dev, usb_save_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
}
void AuraMouseController::SendUpdate
(
unsigned char zone,
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu,
unsigned char dir,
bool random,
unsigned char speed,
unsigned char brightness
)
{
int bytes_read = 1;
unsigned char usb_buf_flush[ASUS_AURA_MOUSE_PACKET_SIZE];
while(bytes_read > 0)
{
bytes_read = hid_read_timeout(dev, usb_buf_flush, ASUS_AURA_MOUSE_PACKET_SIZE, 0);
}
unsigned char usb_buf[ASUS_AURA_MOUSE_PACKET_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, ASUS_AURA_MOUSE_PACKET_SIZE);
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
if (device_pid == AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID)
{
// this device supports 2 color for breathing,
// but since this mode is per led and openrgb doesn't support 2 colors per led this feature is not implemented
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x28;
usb_buf[0x03] = zone;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = mode;
usb_buf[0x06] = brightness;
usb_buf[0x07] = 0x00; // boolean signaling if the 2nd set of colors is in use
usb_buf[0x08] = red;
usb_buf[0x09] = grn;
usb_buf[0x0A] = blu;
usb_buf[0x0B] = 0; // 2nd red
usb_buf[0x0C] = 0; // 2nd green
usb_buf[0x0D] = 0; // 2nd blue
usb_buf[0x0E] = dir;
usb_buf[0x0F] = random;
usb_buf[0x10] = speed;
}
else
{
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x28;
usb_buf[0x03] = zone;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = mode;
usb_buf[0x06] = brightness;
usb_buf[0x07] = red;
usb_buf[0x08] = grn;
usb_buf[0x09] = blu;
usb_buf[0x0A] = dir;
usb_buf[0x0B] = random;
usb_buf[0x0C] = speed;
}
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
unsigned char usb_buf_out[ASUS_AURA_MOUSE_PACKET_SIZE];
hid_read_timeout(dev, usb_buf_out, ASUS_AURA_MOUSE_PACKET_SIZE, 10);
}
void AuraMouseController::SendDirect
(
std::vector<RGBColor> zone_colors
)
{
std::vector<RGBColor> colors = {};
colors.resize(aura_mouse_led_maps[device_pid].led_amount);
for(unsigned char zone = 0; zone < zone_colors.size(); zone++)
{
std::vector<uint8_t> zone_map = aura_mouse_led_maps[device_pid].map[zone];
for(unsigned char led = 0; led < zone_map.size(); led++)
{
colors[zone_map[led]] = zone_colors[zone];
}
}
/*-----------------------------------------------------*\
| Only 5 colors can be sent in each packet |
\*-----------------------------------------------------*/
for(unsigned char led = 0; led < aura_mouse_led_maps[device_pid].led_amount; led += 5)
{
unsigned char usb_buf[ASUS_AURA_MOUSE_PACKET_SIZE];
memset(usb_buf, 0x00, ASUS_AURA_MOUSE_PACKET_SIZE);
unsigned char colors_in_packet = (aura_mouse_led_maps[device_pid].led_amount >= led + 5) ? 5 : aura_mouse_led_maps[device_pid].led_amount - led;
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x29;
usb_buf[0x03] = colors_in_packet; // colors in this packet
usb_buf[0x04] = 0x00;
usb_buf[0x05] = led; // offset
for(unsigned char color = 0; color < colors_in_packet; color++)
{
usb_buf[0x06 + color * 3] = RGBGetRValue(colors[led + color]);
usb_buf[0x07 + color * 3] = RGBGetGValue(colors[led + color]);
usb_buf[0x08 + color * 3] = RGBGetBValue(colors[led + color]);
}
hid_write(dev, usb_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
}
};
Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseController.h
+58
View File
@@ -0,0 +1,58 @@
/*---------------------------------------------------------*\
| AsusAuraMouseController.h |
| |
| Driver for ASUS Aura mouse |
| |
| Adam Honse (CalcProgrammer1) 23 Oct 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <hidapi.h>
#include "RGBController.h"
#include "AsusAuraMouseDevices.h"
#define ASUS_AURA_MOUSE_PACKET_SIZE 65
class AuraMouseController
{
public:
AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
virtual ~AuraMouseController();
std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString();
std::string GetVersion(bool wireless, int protocol);
std::string CleanSerial(const std::wstring& wstr);
void SaveMode();
void SendUpdate
(
unsigned char zone,
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu,
unsigned char dir,
bool random,
unsigned char speed,
unsigned char brightness
);
void SendDirect
(
std::vector<RGBColor> zone_colors
);
uint16_t device_pid;
private:
hid_device* dev;
std::string location;
std::string name;
};
Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseDevices.h
+806
View File
@@ -0,0 +1,806 @@
/*---------------------------------------------------------*\
| AsusAuraMouseDevices.h |
| |
| Device list for ASUS Aura mouse |
| |
| Chris M (Dr_No) 11 Jul 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <vector>
#include <map>
#define AURA_ROG_GLADIUS_II_CORE_PID 0x18DD
#define AURA_ROG_GLADIUS_II_PID 0x1845
#define AURA_ROG_GLADIUS_II_ORIGIN_PID 0x1877
#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID 0x18CD
#define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID 0x18B1
#define AURA_ROG_GLADIUS_II_WIRELESS_1_PID 0x189E
#define AURA_ROG_GLADIUS_II_WIRELESS_2_PID 0x18A0
#define AURA_ROG_GLADIUS_III_PID 0x197B
#define AURA_ROG_GLADIUS_III_CORE_PID 0x1C8D
#define AURA_ROG_GLADIUS_III_WIRELESS_USB_PID 0x197D
#define AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID 0x197F
#define AURA_ROG_GLADIUS_III_WIRELESS_BT_PID 0x1981
#define AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID 0x1A70
#define AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID 0x1A72
#define AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_BT_PID 0x1A74
#define AURA_ROG_CHAKRAM_WIRELESS_PID 0x18E5
#define AURA_ROG_CHAKRAM_WIRED_1_PID 0x18E3
#define AURA_ROG_CHAKRAM_CORE_PID 0x1958
#define AURA_ROG_CHAKRAM_X_USB_PID 0x1A18
#define AURA_ROG_CHAKRAM_X_2_4_PID 0x1A1A
#define AURA_ROG_SPATHA_X_USB_PID 0x1977
#define AURA_ROG_SPATHA_X_2_4_PID 0x1979
#define AURA_ROG_SPATHA_X_DOCK_PID 0x1979
#define AURA_ROG_PUGIO_PID 0x1846
#define AURA_ROG_PUGIO_II_WIRED_PID 0x1906
#define AURA_ROG_PUGIO_II_WIRELESS_PID 0x1908
#define AURA_ROG_STRIX_IMPACT_PID 0x1847
#define AURA_ROG_STRIX_IMPACT_II_PID 0x18E1
#define AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID 0x189E
#define AURA_ROG_STRIX_IMPACT_II_PUNK_PID 0x1956
#define AURA_ROG_STRIX_IMPACT_II_WHITE_PID 0x19D2
#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID 0x1947
#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID 0x1949
#define AURA_ROG_STRIX_IMPACT_III_PID 0x1A88
#define AURA_ROG_KERIS 0x195C
#define AURA_ROG_KERIS_WIRELESS_USB_PID 0x195E
#define AURA_ROG_KERIS_WIRELESS_2_4_PID 0x1960
#define AURA_ROG_KERIS_WIRELESS_BT_PID 0x1962
#define AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID 0x1A66
#define AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID 0x1A68
#define AURA_ROG_KERIS_WIRELESS_AIMPOINT_BT_PID 0x1A6A
#define AURA_TUF_M3_PID 0x1910
#define AURA_TUF_M3_GEN_II_PID 0x1A9B
#define AURA_TUF_M5_PID 0x1898
#define AURA_ROG_SPATHA_X_DOCK_FAKE_PID 0xFFFF
enum
{
AURA_MOUSE_ZONE_LOGO = 0,
AURA_MOUSE_ZONE_SCROLL = 1,
AURA_MOUSE_ZONE_UNDERGLOW = 2,
AURA_MOUSE_ZONE_ALL = 3,
AURA_MOUSE_ZONE_DOCK = 4,
};
enum
{
AURA_MOUSE_MODE_STATIC = 0,
AURA_MOUSE_MODE_BREATHING = 1,
AURA_MOUSE_MODE_SPECTRUM = 2,
AURA_MOUSE_MODE_WAVE = 3,
AURA_MOUSE_MODE_REACTIVE = 4,
AURA_MOUSE_MODE_COMET = 5,
AURA_MOUSE_MODE_BATTERY = 6,
AURA_MOUSE_MODE_DIRECT = 254,
AURA_MOUSE_MODE_NONE = 255,
};
typedef struct
{
uint8_t speed_min;
uint8_t speed_max;
uint8_t brightness_min;
uint8_t brightness_max;
bool wireless;
int version_protocol;
bool direct;
std::vector<uint8_t> mouse_zones;
std::vector<uint8_t> mouse_modes;
} mouse_type;
/*-----------------------------------------------------------------*\
| DEVICE MAP |
| |
| This structure maps the OpenRGB modes to the mode values |
| sent to each mouse. As not all modes are present on each |
| mouse the "mode index" is different. Eg. "Reactive" is mode |
| 4 on the Gladius II and mode 3 on the Gladius II wireless |
\*-----------------------------------------------------------------*/
static std::map<int,mouse_type> aura_mouse_devices =
{
{
AURA_ROG_GLADIUS_II_CORE_PID, // ROG Gladius II Core
{
0, // Speed Min - The Asus Mouse protocol defines larger numbers as slow
0, // Speed Max
0, // Brightness Min
4, // Brightness Max
false, // is wireless? (important for fetching the version)
1, // version protocol
false, // direct - defines whether the mouse has a native direct mode or just uses static as direct (only present on newer devices)
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
}
},
{
AURA_ROG_GLADIUS_II_PID, // ROG Gladius II
{
255,
1,
0,
4,
false,
0,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
}
},
{
AURA_ROG_GLADIUS_II_ORIGIN_PID, // ROG Gladius II Origin
{
255,
1,
0,
4,
false,
0,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
}
},
{
AURA_ROG_GLADIUS_II_ORIGIN_COD_PID, // ROG Gladius II COD
{
255,
1,
0,
4,
false,
0,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
}
},
{
AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID, // ROG Gladius II PNK LTD
{
255,
1,
0,
4,
false,
0,
false,
{ AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
}
},
{
AURA_ROG_GLADIUS_II_WIRELESS_1_PID, // ROG Gladius II Wireless
{
0,
0,
0,
4,
true,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_GLADIUS_II_WIRELESS_2_PID, // ROG Gladius II Wireless
{
0,
0,
0,
4,
true,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_GLADIUS_III_PID, // ROG Gladius III
{
255,
1,
0,
100,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_GLADIUS_III_CORE_PID, // ROG Gladius III Core
{
0,
0,
0,
100,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
}
},
{
AURA_ROG_GLADIUS_III_WIRELESS_USB_PID, // ROG Gladius III Wireless USB
{
255,
1,
0,
100,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID, // ROG Gladius III Wireless 2.4 GHz Dongle
{
255,
1,
0,
100,
true,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_GLADIUS_III_WIRELESS_BT_PID, // ROG Gladius III Wireless Bluetooth
{
255,
1,
0,
100,
true,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID, // ROG Gladius III Wireless AimPoint USB
{
255,
1,
0,
100,
false,
2,
true,
{ AURA_MOUSE_ZONE_LOGO },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID, // ROG Gladius III Wireless AimPoint 2.4 GHz Dongle
{
255,
1,
0,
100,
true,
2,
true,
{ AURA_MOUSE_ZONE_LOGO },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_CHAKRAM_WIRELESS_PID, // ROG Chakram Wireless
{
15,
1,
0,
4,
true,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_CHAKRAM_WIRED_1_PID, // ROG Chakram Wired 1
{
15,
1,
0,
4,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_CHAKRAM_CORE_PID, // ROG Chakram Core
{
0,
0,
0,
4,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
}
},
{
AURA_ROG_CHAKRAM_X_USB_PID, // ROG Chakram X USB
{
15, // technically until 255, but unusably slow after 15
1,
0,
100,
false,
2,
true,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_CHAKRAM_X_2_4_PID, // ROG Chakram X 2.4GHz Dongle
{
15, // technically until 255, but unusably slow after 15
1,
0,
100,
true,
2,
true,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_SPATHA_X_USB_PID, // ROG Spatha X USB
{
15, // technically until 255, but unusably slow after 15
1,
0,
100,
false,
1,
true,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_SPATHA_X_2_4_PID, // ROG Spatha X 2.4GHz Dock
{
15, // technically until 255, but unusably slow after 15
1,
0,
100,
true,
1,
true,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_PUGIO_PID, // ROG Pugio
{
255,
1,
0,
4,
false,
0,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
}
},
{
AURA_ROG_PUGIO_II_WIRED_PID, // ROG Pugio II Wired
{
15,
1,
0,
4,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_PUGIO_II_WIRELESS_PID, // ROG Pugio II Wireless
{
15,
1,
0,
4,
true,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_STRIX_IMPACT_PID, // ROG Strix Impact
{
0,
0,
0,
4,
false,
4,
false,
{ AURA_MOUSE_ZONE_LOGO },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
}
},
{
AURA_ROG_STRIX_IMPACT_II_PID, // ROG Strix Impact II
{
0,
0,
0,
4,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
}
},
{
AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID, // ROG Strix Impact II Gundam
{
0,
0,
0,
4,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
}
},
{
AURA_ROG_STRIX_IMPACT_II_PUNK_PID, // ROG Strix Impact II Electro Punk
{
0,
0,
0,
4,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
}
},
{
AURA_ROG_STRIX_IMPACT_II_WHITE_PID, // ROG Strix Impact II Moonlight White
{
0,
0,
0,
4,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
}
},
{
AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID, // ROG Strix Impact II Wireless USB
{
0,
0,
0,
4,
false,
1, // not tested, but likely same as ROG Strix Impact II non wireless
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID, // ROG Strix Impact II Wireless 2.4 GHz Dongle
{
0,
0,
0,
4,
true,
1, // not tested, but likely same as ROG Strix Impact II non wireless
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_STRIX_IMPACT_III_PID, // ROG Strix Impact III
{
0,
0,
0,
100,
false,
1,
true,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
}
},
{
AURA_ROG_KERIS, // ROG Keris
{
0,
0,
0,
4,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
}
},
{
AURA_ROG_KERIS_WIRELESS_USB_PID, // ROG Keris
{
0,
0,
0,
4,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_KERIS_WIRELESS_2_4_PID, // ROG Keris
{
0,
0,
0,
4,
true,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_KERIS_WIRELESS_BT_PID, // ROG Keris
{
0,
0,
0,
4,
true,
1,
false,
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID, // ROG Keris Wireless AimPoint
{
0,
0,
0,
100,
false,
1,
true,
{ AURA_MOUSE_ZONE_LOGO },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID, // ROG Keris Wireless AimPoint
{
0,
0,
0,
100,
true,
2,
true,
{ AURA_MOUSE_ZONE_LOGO },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
}
},
{
AURA_TUF_M3_PID, // TUF M3
{
0,
0,
0,
4,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
}
},
{
AURA_TUF_M3_GEN_II_PID, // TUF M3 Gen II
{
0,
0,
0,
100,
false,
1,
false,
{ AURA_MOUSE_ZONE_LOGO },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
}
},
{
AURA_TUF_M5_PID, // TUF M5
{
0,
0,
0,
4,
false,
3,
false,
{ AURA_MOUSE_ZONE_LOGO },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
}
},
{
AURA_ROG_SPATHA_X_DOCK_FAKE_PID, // Asus ROG Spatha X Dock (only in wireless mode)
{
0,
0,
0,
100,
false,
1,
false,
{ AURA_MOUSE_ZONE_DOCK },
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
}
},
};
typedef struct
{
unsigned char led_amount;
std::map< unsigned char, std::vector<unsigned char>> map;
} led_map;
/*-----------------------------------------------------------------*\
| LED MAP |
| |
| This maps the LEDs to the correct zone. |
| This is necessary, because openrgb doesn't support per-zone |
| lighting. To allow for per-zone color of modes like breathing, |
| the leds defined need to be the zones, which means the actual |
| LEDs can't be implemented. |
\*-----------------------------------------------------------------*/
static std::map<unsigned short, led_map > aura_mouse_led_maps =
{
{
AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID,
{
1,
{
{ AURA_MOUSE_ZONE_LOGO, { 0 } },
}
}
},
{
AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID,
{
1,
{
{ AURA_MOUSE_ZONE_LOGO, { 0 } },
}
}
},
{
AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID,
{
1,
{
{ AURA_MOUSE_ZONE_LOGO, { 0 } },
}
}
},
{
AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID,
{
1,
{
{ AURA_MOUSE_ZONE_LOGO, { 0 } },
}
}
},
{
AURA_ROG_SPATHA_X_2_4_PID,
{
5,
{
{ AURA_MOUSE_ZONE_LOGO, { 0 } },
{ AURA_MOUSE_ZONE_SCROLL, { 1 } },
{ AURA_MOUSE_ZONE_UNDERGLOW, { 2, 3, 4 } },
}
}
},
{
AURA_ROG_SPATHA_X_USB_PID,
{
5,
{
{ AURA_MOUSE_ZONE_LOGO, { 0 } },
{ AURA_MOUSE_ZONE_SCROLL, { 1 } },
{ AURA_MOUSE_ZONE_UNDERGLOW, { 2, 3, 4 } },
}
}
},
{
AURA_ROG_CHAKRAM_X_USB_PID,
{
9,
{
{ AURA_MOUSE_ZONE_LOGO, { 7 } },
{ AURA_MOUSE_ZONE_SCROLL, { 8 } },
{ AURA_MOUSE_ZONE_UNDERGLOW, { 0, 1, 2, 3, 4, 5, 6 } },
}
}
},
{
AURA_ROG_CHAKRAM_X_2_4_PID,
{
9,
{
{ AURA_MOUSE_ZONE_LOGO, { 7 } },
{ AURA_MOUSE_ZONE_SCROLL, { 8 } },
{ AURA_MOUSE_ZONE_UNDERGLOW, { 0, 1, 2, 3, 4, 5, 6 } },
}
}
},
{
AURA_ROG_STRIX_IMPACT_III_PID,
{
2,
{
{ AURA_MOUSE_ZONE_LOGO, { 0 } },
{ AURA_MOUSE_ZONE_SCROLL, { 1 } },
}
}
}
};
Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.cpp
+304
View File
@@ -0,0 +1,304 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraMouse.cpp |
| |
| RGBController for ASUS Aura mouse |
| |
| Adam Honse (CalcProgrammer1) 25 Oct 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_AsusAuraMouse.h"
static std::string aura_mouse_zone_names[5]
{
"Logo",
"Scroll Wheel",
"Underglow",
"All",
"Dock"
};
/**------------------------------------------------------------------*\
@name Asus Aura Mouse
@category Mouse
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraUSBMice
@comment
\*-------------------------------------------------------------------*/
RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller_ptr)
{
controller = controller_ptr;
pid = controller->device_pid;
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_MOUSE;
description = "ASUS Aura Mouse Device";
version = controller->GetVersion(aura_mouse_devices[pid].wireless, aura_mouse_devices[pid].version_protocol);
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
std::vector<uint8_t> mm = aura_mouse_devices[pid].mouse_modes;
if(aura_mouse_devices[pid].direct)
{
mode Direct;
Direct.name = "Direct";
Direct.value = 254;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
}
int mode_value = 0;
for(std::vector<uint8_t>::iterator it = mm.begin(); it != mm.end(); it++)
{
switch(*it)
{
case AURA_MOUSE_MODE_STATIC:
/*-----------------------------------------------------------------*\
| If there is no direct mode, this mode can be used as direct |
| (Asus does it the same way). |
| The acutal direct mode is only found on new devices and on |
| these devices static can't be used as direct anymore as it is |
| too slow. The Spatha X's dock can't be controlled, because |
| static is too slow and it can't be adressed in direct |
\*-----------------------------------------------------------------*/
{
mode Static;
Static.name = (aura_mouse_devices[pid].direct || pid == AURA_ROG_SPATHA_X_DOCK_FAKE_PID)? "Static" : "Direct";
Static.value = mode_value;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Static.brightness_min = aura_mouse_devices[pid].brightness_min;
Static.brightness_max = aura_mouse_devices[pid].brightness_max;
Static.brightness = aura_mouse_devices[pid].brightness_max;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
}
break;
case AURA_MOUSE_MODE_BREATHING:
{
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = mode_value;
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Breathing.brightness_min = aura_mouse_devices[pid].brightness_min;
Breathing.brightness_max = aura_mouse_devices[pid].brightness_max;
Breathing.brightness = aura_mouse_devices[pid].brightness_max;
Breathing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);
}
break;
case AURA_MOUSE_MODE_SPECTRUM:
{
mode ColorCycle;
ColorCycle.name = "Spectrum Cycle";
ColorCycle.value = mode_value;
ColorCycle.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE ;
ColorCycle.brightness_min = aura_mouse_devices[pid].brightness_min;
ColorCycle.brightness_max = aura_mouse_devices[pid].brightness_max;
ColorCycle.brightness = aura_mouse_devices[pid].brightness_max;
ColorCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(ColorCycle);
}
break;
case AURA_MOUSE_MODE_WAVE:
{
mode Wave;
Wave.name = "Rainbow Wave";
Wave.value = mode_value;
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Wave.direction = 0;
Wave.speed_min = aura_mouse_devices[pid].speed_min;
Wave.speed_max = aura_mouse_devices[pid].speed_max;
Wave.speed = (aura_mouse_devices[pid].speed_min + aura_mouse_devices[pid].speed_max) / 2;
Wave.brightness_min = aura_mouse_devices[pid].brightness_min;
Wave.brightness_max = aura_mouse_devices[pid].brightness_max;
Wave.brightness = aura_mouse_devices[pid].brightness_max;
Wave.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave);
}
break;
case AURA_MOUSE_MODE_REACTIVE:
{
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = mode_value;
Reactive.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Reactive.brightness_min = aura_mouse_devices[pid].brightness_min;
Reactive.brightness_max = aura_mouse_devices[pid].brightness_max;
Reactive.brightness = aura_mouse_devices[pid].brightness_max;
Reactive.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Reactive);
}
break;
case AURA_MOUSE_MODE_COMET:
{
mode Comet;
Comet.name = "Comet";
Comet.value = mode_value;
Comet.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Comet.brightness_min = aura_mouse_devices[pid].brightness_min;
Comet.brightness_max = aura_mouse_devices[pid].brightness_max;
Comet.brightness = aura_mouse_devices[pid].brightness_max;
Comet.color_mode = MODE_COLORS_MODE_SPECIFIC;
Comet.direction = 0;
Comet.colors_min = 1;
Comet.colors_max = 1;
Comet.colors.resize(1);
modes.push_back(Comet);
}
break;
case AURA_MOUSE_MODE_BATTERY:
{
mode BatteryMode;
BatteryMode.name = "Battery";
BatteryMode.value = mode_value;
BatteryMode.flags = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
BatteryMode.brightness_min = aura_mouse_devices[pid].brightness_min;
BatteryMode.brightness_max = aura_mouse_devices[pid].brightness_max;
BatteryMode.brightness = aura_mouse_devices[pid].brightness_max;
BatteryMode.color_mode = MODE_COLORS_NONE;
modes.push_back(BatteryMode);
}
break;
}
mode_value++;
}
SetupZones();
}
RGBController_AuraMouse::~RGBController_AuraMouse()
{
delete controller;
}
void RGBController_AuraMouse::SetupZones()
{
for(std::vector<uint8_t>::iterator zone_it = aura_mouse_devices[pid].mouse_zones.begin(); zone_it != aura_mouse_devices[pid].mouse_zones.end(); zone_it++)
{
zone mouse_zone;
mouse_zone.name = aura_mouse_zone_names[*zone_it];
mouse_zone.type = ZONE_TYPE_SINGLE;
mouse_zone.leds_min = 1;
mouse_zone.leds_max = 1;
mouse_zone.leds_count = 1;
mouse_zone.matrix_map = NULL;
zones.push_back(mouse_zone);
led mouse_led;
mouse_led.name = mouse_zone.name + " LED";
mouse_led.value = *zone_it;
leds.push_back(mouse_led);
}
SetupColors();
}
void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)
{
}
void RGBController_AuraMouse::DeviceUpdateLEDs()
{
if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
{
controller->SendDirect(colors);
}
else
{
for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
{
UpdateSingleLED(zone_index);
}
}
}
void RGBController_AuraMouse::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraMouse::UpdateSingleLED(int led)
{
if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
{
DeviceUpdateLEDs();
return;
}
uint8_t red = RGBGetRValue(colors[led]);
uint8_t grn = RGBGetGValue(colors[led]);
uint8_t blu = RGBGetBValue(colors[led]);
controller->SendUpdate(leds[led].value, modes[active_mode].value, red, grn, blu, 0, false, 0, modes[active_mode].brightness);
}
void RGBController_AuraMouse::DeviceUpdateMode()
{
if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
{
return;
}
if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
{
DeviceUpdateLEDs();
}
else
{
unsigned char red = 0;
unsigned char grn = 0;
unsigned char blu = 0;
if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
{
red = RGBGetRValue(modes[active_mode].colors[0]);
grn = RGBGetGValue(modes[active_mode].colors[0]);
blu = RGBGetBValue(modes[active_mode].colors[0]);
}
if(pid == AURA_ROG_SPATHA_X_DOCK_FAKE_PID)
{
controller->SendUpdate(AURA_MOUSE_ZONE_DOCK, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
}
else if(pid == AURA_ROG_STRIX_IMPACT_PID)
{
/*-----------------------------------------------------------------*\
| The ROG Impact doesn't accept AURA_MOUSE_ZONE_ALL |
\*-----------------------------------------------------------------*/
controller->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
}
else
{
controller->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
}
}
}
void RGBController_AuraMouse::DeviceSaveMode()
{
DeviceUpdateMode();
controller->SaveMode();
}
Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.h
+37
View File
@@ -0,0 +1,37 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraMouse.h |
| |
| RGBController for ASUS Aura mouse |
| |
| Adam Honse (CalcProgrammer1) 25 Oct 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusAuraMouseController.h"
class RGBController_AuraMouse : public RGBController
{
public:
RGBController_AuraMouse(AuraMouseController* controller_ptr);
~RGBController_AuraMouse();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
AuraMouseController* controller;
uint16_t pid;
};
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/AsusAuraMouseGen1Controller.cpp
+181
View File
@@ -0,0 +1,181 @@
/*---------------------------------------------------------*\
| AsusAuraMouseGen1Controller.cpp |
| |
| Driver for ASUS Aura gen 1 mouse |
| |
| Mola19 30 Nov 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include <chrono>
#include <thread>
#include "AsusAuraMouseGen1Controller.h"
#include "StringUtils.h"
AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
{
dev = dev_handle;
location = path;
device_pid = pid;
name = dev_name;
}
AsusAuraMouseGen1Controller::~AsusAuraMouseGen1Controller()
{
hid_close(dev);
}
std::string AsusAuraMouseGen1Controller::GetDeviceLocation()
{
return("HID: " + location);
}
std::string AsusAuraMouseGen1Controller::GetName()
{
return(name);
}
std::string AsusAuraMouseGen1Controller::GetSerialString()
{
wchar_t serial_string[HID_MAX_STR];
int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string AsusAuraMouseGen1Controller::GetVersion()
{
unsigned char usb_buf[9] = { 0x0C, 0xC4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
usb_buf[3] = (device_pid == 0x1824) ? 0x02 : 0x00;
hid_send_feature_report(dev, usb_buf, 9);
unsigned char usb_buf_out[9] = { 0x0C };
hid_get_feature_report(dev, usb_buf_out, 9);
return std::string("1." + std::to_string(usb_buf_out[3]));
}
int AsusAuraMouseGen1Controller::GetActiveProfile()
{
unsigned char profile;
unsigned char profile_amount = 0;
unsigned char profile_key = 0;
switch(device_pid)
{
case 0x185B:
profile_amount = 3;
profile_key = 0xF0;
break;
case 0x181C:
case 0x1824:
default:
profile_amount = 6;
profile_key = 0x60;
break;
}
do
{
unsigned char usb_buf[9] = { 0x0C, 0xDF, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
hid_send_feature_report(dev, usb_buf, 9);
unsigned char usb_buf_out[9] = { 0x0C };
hid_get_feature_report(dev, usb_buf_out, 9);
profile = usb_buf_out[4];
} while(profile < profile_key || profile > profile_key + profile_amount - 1);
return (profile % 16) + 1;
}
void AsusAuraMouseGen1Controller::SendUpdate
(
unsigned char key,
unsigned char value
)
{
unsigned char usb_buf[9];
memset(usb_buf, 0x00, 9);
usb_buf[0x00] = 0x0C;
usb_buf[0x01] = 0xC4;
usb_buf[0x02] = 0x0F;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = key;
usb_buf[0x05] = value;
hid_send_feature_report(dev, usb_buf, 9);
unsigned char buf_in[9];
buf_in[0] = 0x0C;
hid_get_feature_report(dev, buf_in, 9);
std::this_thread::sleep_for(std::chrono::milliseconds(15));
}
void AsusAuraMouseGen1Controller::UpdateProfile
(
unsigned char key,
unsigned char profile,
unsigned char value
)
{
unsigned char usb_buf[9];
memset(usb_buf, 0x00, 9);
usb_buf[0x00] = 0x0C;
usb_buf[0x01] = 0xDE;
usb_buf[0x02] = key;
usb_buf[0x03] = profile;
usb_buf[0x04] = value;
hid_send_feature_report(dev, usb_buf, 9);
unsigned char buf_in[9];
buf_in[0] = 0x0C;
hid_get_feature_report(dev, buf_in, 9);
}
void AsusAuraMouseGen1Controller::SendDirectSpatha(std::vector<RGBColor> colors)
{
unsigned char usb_buf[33];
memset(usb_buf, 0x00, 33);
usb_buf[0x00] = 0x10;
usb_buf[0x01] = 0x00;
usb_buf[0x02] = 0xF0;
usb_buf[0x03] = 0x00;
for(unsigned char i = 0; i < 3; i++)
{
usb_buf[4 + i * 3] = RGBGetRValue(colors[i]);
usb_buf[5 + i * 3] = RGBGetGValue(colors[i]);
usb_buf[6 + i * 3] = RGBGetBValue(colors[i]);
}
hid_send_feature_report(dev, usb_buf, 33);
}
void AsusAuraMouseGen1Controller::ResetToSavedLighting()
{
unsigned char usb_buf[9];
memset(usb_buf, 0x00, 9);
usb_buf[0x00] = 0x0C;
usb_buf[0x01] = 0xC4;
hid_send_feature_report(dev, usb_buf, 9);
}
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/AsusAuraMouseGen1Controller.h
+57
View File
@@ -0,0 +1,57 @@
/*---------------------------------------------------------*\
| AsusAuraMouseGen1Controller.h |
| |
| Driver for ASUS Aura gen 1 mouse |
| |
| Mola19 30 Nov 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"
#define HID_MAX_STR 255
class AsusAuraMouseGen1Controller
{
public:
AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
virtual ~AsusAuraMouseGen1Controller();
std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString();
std::string GetVersion();
int GetActiveProfile();
void SendUpdate
(
unsigned char key,
unsigned char value
);
void UpdateProfile
(
unsigned char key,
unsigned char profile,
unsigned char value
);
void SendDirectSpatha(std::vector<RGBColor> colors);
void ResetToSavedLighting();
uint16_t device_pid;
private:
hid_device* dev;
std::string location;
std::string name;
};
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.cpp
+274
View File
@@ -0,0 +1,274 @@
/*---------------------------------------------------------*\
| RGBController_AsusROGSpatha.cpp |
| |
| RGBController for ASUS ROG Spatha |
| |
| Mola19 05 Nov 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_AsusROGSpatha.h"
/**------------------------------------------------------------------*\
@name Asus Aura Spatha
@category Mouse
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraUSBSpatha
@comment This device allows indiviual modes for each zone,
which currently can't be implemented in OpenRGB.
Also there seem to be a firmware bug which causes static
to use a random colorand random to use a static color
that was previously set. This can be worked around by saving
\*-------------------------------------------------------------------*/
RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_MOUSE;
description = "ASUS Aura Mouse Device";
version = controller->GetVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = ASUS_ROG_SPATHA_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 = ASUS_ROG_SPATHA_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Static.brightness_min = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
Static.brightness_max = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
Static.brightness = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = ASUS_ROG_SPATHA_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Breathing.brightness_min = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
Breathing.brightness_max = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
Breathing.brightness = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
Breathing.colors_min = 2;
Breathing.colors_max = 2;
Breathing.colors.resize(2);
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Breathing);
mode ColorCycle;
ColorCycle.name = "Spectrum Cycle";
ColorCycle.value = ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE;
ColorCycle.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
ColorCycle.brightness_min = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
ColorCycle.brightness_max = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
ColorCycle.brightness = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
ColorCycle.colors_min = 12;
ColorCycle.colors_max = 12;
ColorCycle.colors.resize(12);
ColorCycle.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(ColorCycle);
mode Random;
Random.name = "Random";
Random.value = ASUS_ROG_SPATHA_MODE_RANDOM;
Random.flags = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Random.brightness_min = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
Random.brightness_max = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
Random.brightness = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
Random.color_mode = MODE_COLORS_NONE;
modes.push_back(Random);
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = ASUS_ROG_SPATHA_MODE_REACTIVE;
Reactive.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Reactive.brightness_min = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
Reactive.brightness_max = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
Reactive.brightness = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
Reactive.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Reactive);
mode Battery;
Battery.name = "Battery";
Battery.value = ASUS_ROG_SPATHA_MODE_BATTERY;
Battery.flags = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Battery.brightness_min = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
Battery.brightness_max = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
Battery.brightness = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
Battery.color_mode = MODE_COLORS_NONE;
modes.push_back(Battery);
SetupZones();
}
RGBController_AsusROGSpatha::~RGBController_AsusROGSpatha()
{
delete controller;
}
void RGBController_AsusROGSpatha::SetupZones()
{
std::string zones_names[3] = {"Side", "Scroll Wheel", "Logo"};
for(unsigned char i = 0; i < 3; i++)
{
zone spatha_zone;
spatha_zone.name = zones_names[i];
spatha_zone.type = ZONE_TYPE_SINGLE;
spatha_zone.leds_min = 1;
spatha_zone.leds_max = 1;
spatha_zone.leds_count = 1;
spatha_zone.matrix_map = NULL;
zones.push_back(spatha_zone);
led spatha_led;
spatha_led.name = zones_names[i];
spatha_led.value = 1;
leds.push_back(spatha_led);
}
SetupColors();
}
void RGBController_AsusROGSpatha::ResizeZone(int /*zone*/, int /*new_size*/)
{
}
void RGBController_AsusROGSpatha::DeviceUpdateLEDs()
{
if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
{
controller->SendDirectSpatha(colors);
}
else
{
UpdateSingleLED(0);
UpdateSingleLED(1);
UpdateSingleLED(2);
}
}
void RGBController_AsusROGSpatha::UpdateZoneLEDs(int zone)
{
if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
{
controller->SendDirectSpatha(colors);
}
else
{
UpdateSingleLED(zone);
}
}
void RGBController_AsusROGSpatha::UpdateSingleLED(int led)
{
if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
{
controller->SendDirectSpatha(colors);
}
else
{
controller->SendUpdate(0x13 + led * 38, RGBGetRValue(colors[led]));
controller->SendUpdate(0x14 + led * 38, RGBGetGValue(colors[led]));
controller->SendUpdate(0x15 + led * 38, RGBGetBValue(colors[led]));
}
}
void RGBController_AsusROGSpatha::DeviceUpdateMode()
{
if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
{
return;
}
/*-----------------------------------------------------*\
| Needed to overwrite direct |
\*-----------------------------------------------------*/
controller->ResetToSavedLighting();
/*-----------------------------------------------------*\
| Send data to all 3 zones |
\*-----------------------------------------------------*/
for(int i = 0; i < 3; i++)
{
controller->SendUpdate(0x11 + i * 38, modes[active_mode].value);
/*------------------------------------------------------------------*\
| This mouse has independent brightness for wired and wireless. |
| Each is 4-bit in the same byte (wireless is the first/bigger one). |
| OpenRGB misses that feature, hence both are the same |
\*------------------------------------------------------------------*/
controller->SendUpdate(0x12 + i * 38, (modes[active_mode].brightness << 4) + modes[active_mode].brightness);
if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_BREATHING)
{
for(unsigned int j = 0; j < modes[active_mode].colors.size(); j++)
{
controller->SendUpdate(0x13 + j * 3 + i * 38, RGBGetRValue(modes[active_mode].colors[j]));
controller->SendUpdate(0x14 + j * 3 + i * 38, RGBGetGValue(modes[active_mode].colors[j]));
controller->SendUpdate(0x15 + j * 3 + i * 38, RGBGetBValue(modes[active_mode].colors[j]));
}
}
}
}
void RGBController_AsusROGSpatha::DeviceSaveMode()
{
if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
{
return;
}
unsigned int profile = controller->GetActiveProfile();
/*-----------------------------------------------------*\
| Send data to all 3 zones |
\*-----------------------------------------------------*/
for(int i = 0; i < 3; i++)
{
controller->UpdateProfile(0x11 + i * 38, profile, modes[active_mode].value);
/*------------------------------------------------------------------*\
| This mouse has independent brightness for wired and wireless. |
| Each is 4-bit in the same byte (wireless is the first/bigger one). |
| OpenRGB misses that feature, hence both are the same |
\*------------------------------------------------------------------*/
controller->UpdateProfile(0x12 + i * 38, profile, (modes[active_mode].brightness << 4) + modes[active_mode].brightness);
if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_BREATHING)
{
for(unsigned int j = 0; j < modes[active_mode].colors.size(); j++)
{
controller->UpdateProfile(0x13 + j * 3 + i * 38, profile, RGBGetRValue(modes[active_mode].colors[j]));
controller->UpdateProfile(0x14 + j * 3 + i * 38, profile, RGBGetGValue(modes[active_mode].colors[j]));
controller->UpdateProfile(0x15 + j * 3 + i * 38, profile, RGBGetBValue(modes[active_mode].colors[j]));
}
}
else if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_STATIC || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_REACTIVE)
{
controller->UpdateProfile(0x13 + i * 38, profile, RGBGetRValue(colors[i]));
controller->UpdateProfile(0x14 + i * 38, profile, RGBGetGValue(colors[i]));
controller->UpdateProfile(0x15 + i * 38, profile, RGBGetBValue(colors[i]));
}
}
controller->ResetToSavedLighting();
}
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.h
+54
View File
@@ -0,0 +1,54 @@
/*---------------------------------------------------------*\
| RGBController_AsusROGSpatha.h |
| |
| RGBController for ASUS ROG Spatha |
| |
| Mola19 05 Nov 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusAuraMouseGen1Controller.h"
enum
{
ASUS_ROG_SPATHA_BRIGHTNESS_MIN = 0,
ASUS_ROG_SPATHA_BRIGHTNESS_MAX = 15,
ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT = 15
};
enum
{
ASUS_ROG_SPATHA_MODE_DIRECT = 0xFF,
ASUS_ROG_SPATHA_MODE_STATIC = 0x01,
ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE = 0x05,
ASUS_ROG_SPATHA_MODE_RANDOM = 0x06,
ASUS_ROG_SPATHA_MODE_BREATHING = 0x0A,
ASUS_ROG_SPATHA_MODE_BATTERY = 0x0B,
ASUS_ROG_SPATHA_MODE_REACTIVE = 0x0C,
};
class RGBController_AsusROGSpatha : public RGBController
{
public:
RGBController_AsusROGSpatha(AsusAuraMouseGen1Controller* controller_ptr);
~RGBController_AsusROGSpatha();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
AsusAuraMouseGen1Controller* controller;
};
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.cpp
+152
View File
@@ -0,0 +1,152 @@
/*---------------------------------------------------------*\
| RGBController_AsusROGStrixEvolve.cpp |
| |
| RGBController for ASUS ROG Evolve |
| |
| Mola19 30 Nov 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_AsusROGStrixEvolve.h"
/**------------------------------------------------------------------*\
@name Asus Aura Strix Evolve
@category Mouse
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraUSBStrixEvolve
@comment
\*-------------------------------------------------------------------*/
RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouseGen1Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_MOUSE;
description = "ASUS Aura Mouse Device";
version = controller->GetVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = ASUS_ROG_STRIX_EVOLVE_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Direct.brightness_min = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
Direct.brightness_max = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
Direct.brightness = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = ASUS_ROG_STRIX_EVOLVE_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Breathing.brightness_min = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
Breathing.brightness_max = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
Breathing.brightness = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
Breathing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);
mode ColorCycle;
ColorCycle.name = "Spectrum Cycle";
ColorCycle.value = ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE;
ColorCycle.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
ColorCycle.brightness_min = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
ColorCycle.brightness_max = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
ColorCycle.brightness = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
ColorCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(ColorCycle);
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = ASUS_ROG_STRIX_EVOLVE_MODE_REACTIVE;
Reactive.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Reactive.brightness_min = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
Reactive.brightness_max = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
Reactive.brightness = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
Reactive.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Reactive);
SetupZones();
}
RGBController_AsusROGStrixEvolve::~RGBController_AsusROGStrixEvolve()
{
delete controller;
}
void RGBController_AsusROGStrixEvolve::SetupZones()
{
zone mouse_zone;
mouse_zone.name = "Underglow";
mouse_zone.type = ZONE_TYPE_SINGLE;
mouse_zone.leds_min = 1;
mouse_zone.leds_max = 1;
mouse_zone.leds_count = 1;
mouse_zone.matrix_map = NULL;
zones.push_back(mouse_zone);
led mouse_led;
mouse_led.name = "Underglow";
mouse_led.value = 1;
leds.push_back(mouse_led);
SetupColors();
}
void RGBController_AsusROGStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/)
{
}
void RGBController_AsusROGStrixEvolve::DeviceUpdateLEDs()
{
UpdateSingleLED(0);
}
void RGBController_AsusROGStrixEvolve::UpdateZoneLEDs(int zone)
{
UpdateSingleLED(zone);
}
void RGBController_AsusROGStrixEvolve::UpdateSingleLED(int /*led*/)
{
controller->SendUpdate(0x1C, RGBGetRValue(colors[0]));
controller->SendUpdate(0x1D, RGBGetGValue(colors[0]));
controller->SendUpdate(0x1E, RGBGetBValue(colors[0]));
}
void RGBController_AsusROGStrixEvolve::DeviceUpdateMode()
{
controller->SendUpdate(0x19, modes[active_mode].value);
controller->SendUpdate(0x1A, modes[active_mode].brightness);
}
void RGBController_AsusROGStrixEvolve::DeviceSaveMode()
{
unsigned int profile = controller->GetActiveProfile();
controller->UpdateProfile(0x19, profile, modes[active_mode].value);
controller->UpdateProfile(0x1A, profile, modes[active_mode].brightness);
if(modes[active_mode].value != ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE)
{
controller->UpdateProfile(0x1C, profile, RGBGetRValue(colors[0]));
controller->UpdateProfile(0x1D, profile, RGBGetGValue(colors[0]));
controller->UpdateProfile(0x1E, profile, RGBGetBValue(colors[0]));
}
controller->ResetToSavedLighting();
}
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.h
+51
View File
@@ -0,0 +1,51 @@
/*---------------------------------------------------------*\
| RGBController_AsusROGStrixEvolve.h |
| |
| RGBController for ASUS ROG Evolve |
| |
| Mola19 30 Nov 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusAuraMouseGen1Controller.h"
enum
{
ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN = 0,
ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX = 255,
ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT = 255,
};
enum
{
ASUS_ROG_STRIX_EVOLVE_MODE_DIRECT = 0x01,
ASUS_ROG_STRIX_EVOLVE_MODE_BREATHING = 0x02,
ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE = 0x03,
ASUS_ROG_STRIX_EVOLVE_MODE_REACTIVE = 0x04,
};
class RGBController_AsusROGStrixEvolve : public RGBController
{
public:
RGBController_AsusROGStrixEvolve(AsusAuraMouseGen1Controller* controller_ptr);
~RGBController_AsusROGStrixEvolve();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
AsusAuraMouseGen1Controller* controller;
};
Controllers/AsusAuraUSBController/AsusAuraMousematController/AsusAuraMousematController.cpp
+140
View File
@@ -0,0 +1,140 @@
/*---------------------------------------------------------*\
| AsusAuraMousematController.cpp |
| |
| Driver for ASUS Aura mousemat |
| |
| Adam Honse (CalcProgrammer1) 10 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "AsusAuraMousematController.h"
#include "StringUtils.h"
AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
}
AuraMousematController::~AuraMousematController()
{
hid_close(dev);
}
std::string AuraMousematController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string AuraMousematController::GetName()
{
return(name);
}
std::string AuraMousematController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string AuraMousematController::GetVersion()
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0xEE;
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];
snprintf(version, 9, "%X.%02X.%02X", usb_buf_out[6], usb_buf_out[7], usb_buf_out[8]);
return std::string(version);
}
void AuraMousematController::UpdateLeds
(
std::vector<RGBColor> colors
)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0xEE;
usb_buf[0x01] = 0xC0;
usb_buf[0x02] = 0x81;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = 0x00;
for(unsigned int i = 0; i < 60; i += 4)
{
usb_buf[5 + i] = 0x00;
usb_buf[6 + i] = RGBGetRValue(colors[i / 4]);
usb_buf[7 + i] = RGBGetGValue(colors[i / 4]);
usb_buf[8 + i] = RGBGetBValue(colors[i / 4]);
}
hid_write(dev, usb_buf, 65);
}
void AuraMousematController::UpdateDevice
(
unsigned char mode,
std::vector<RGBColor> colors,
unsigned char speed,
unsigned char brightness,
unsigned char pattern
)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0xEE;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x28;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = mode;
usb_buf[0x06] = speed;
usb_buf[0x07] = brightness;
usb_buf[0x08] = pattern;
usb_buf[0x09] = 0x00;
for(unsigned int i = 0; i < colors.size(); i++)
{
usb_buf[0x0a + i * 3] = RGBGetRValue(colors[i]);
usb_buf[0x0b + i * 3] = RGBGetGValue(colors[i]);
usb_buf[0x0c + i * 3] = RGBGetBValue(colors[i]);
}
hid_write(dev, usb_buf, 65);
}
void AuraMousematController::SaveMode()
{
unsigned char usb_save_buf[65];
memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
usb_save_buf[0x00] = 0xEE;
usb_save_buf[0x01] = 0x50;
usb_save_buf[0x02] = 0x03;
hid_write(dev, usb_save_buf, 65);
}
Controllers/AsusAuraUSBController/AsusAuraMousematController/AsusAuraMousematController.h
+62
View File
@@ -0,0 +1,62 @@
/*---------------------------------------------------------*\
| AsusAuraMousematController.h |
| |
| Driver for ASUS Aura mousemat |
| |
| Adam Honse (CalcProgrammer1) 10 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <hidapi.h>
#include "RGBController.h"
enum
{
AURA_MOUSEMAT_MODE_STATIC = 0,
AURA_MOUSEMAT_MODE_BREATHING = 1,
AURA_MOUSEMAT_MODE_COLOR_CYCLE = 2,
AURA_MOUSEMAT_MODE_WAVE = 3,
AURA_MOUSEMAT_MODE_WAVE_PLANE = 4,
AURA_MOUSEMAT_MODE_COMET = 5,
AURA_MOUSEMAT_MODE_GLOWING_YOYO = 6,
AURA_MOUSEMAT_MODE_CROSS = 7,
AURA_MOUSEMAT_MODE_STARRY_NIGHT = 8,
AURA_MOUSEMAT_MODE_DIRECT = 0xFF,
};
class AuraMousematController
{
public:
AuraMousematController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~AuraMousematController();
std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString();
std::string GetVersion();
void UpdateLeds
(
std::vector<RGBColor> colors
);
void UpdateDevice
(
unsigned char mode,
std::vector<RGBColor> colors,
unsigned char speed,
unsigned char brightness,
unsigned char pattern
);
void SaveMode();
private:
hid_device* dev;
std::string location;
std::string name;
};
Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.cpp
+300
View File
@@ -0,0 +1,300 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraMousemat.cpp |
| |
| RGBController for ASUS Aura mousemat |
| |
| Adam Honse (CalcProgrammer1) 10 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_AsusAuraMousemat.h"
/**------------------------------------------------------------------*\
@name Asus Aura Mousemat
@category Mousemat
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraUSBMousemats
@comment
\*-------------------------------------------------------------------*/
RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_MOUSEMAT;
description = "ASUS Aura Mousemat Device";
version = controller->GetVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = AURA_MOUSEMAT_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_MOUSEMAT_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
Static.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
Static.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(1);
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = AURA_MOUSEMAT_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC | MODE_COLORS_RANDOM;
Breathing.speed_min = AURA_MOUSEMAT_SPEED_MIN;
Breathing.speed_max = AURA_MOUSEMAT_SPEED_MAX;
Breathing.speed = AURA_MOUSEMAT_SPEED_DEFAULT_BREATHING;
Breathing.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
Breathing.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
Breathing.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
Breathing.colors_min = 1;
Breathing.colors_max = 2;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode ColorCycle;
ColorCycle.name = "Color Cycle";
ColorCycle.value = AURA_MOUSEMAT_MODE_COLOR_CYCLE;
ColorCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
ColorCycle.color_mode = MODE_COLORS_NONE;
ColorCycle.speed_min = AURA_MOUSEMAT_SPEED_MIN;
ColorCycle.speed_max = AURA_MOUSEMAT_SPEED_MAX;
ColorCycle.speed = AURA_MOUSEMAT_SPEED_DEFAULT_COLOR_CYCLE;
ColorCycle.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
ColorCycle.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
ColorCycle.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
modes.push_back(ColorCycle);
mode Wave;
Wave.name = "Wave";
Wave.value = AURA_MOUSEMAT_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
Wave.speed_min = AURA_MOUSEMAT_SPEED_MIN;
Wave.speed_max = AURA_MOUSEMAT_SPEED_MAX;
Wave.speed = AURA_MOUSEMAT_SPEED_DEFAULT_WAVE;
Wave.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
Wave.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
Wave.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
Wave.direction = MODE_DIRECTION_LEFT;
Wave.colors_min = 7;
Wave.colors_max = 7;
Wave.colors.resize(7);
modes.push_back(Wave);
mode WavePlane;
WavePlane.name = "Wave Plane";
WavePlane.value = AURA_MOUSEMAT_MODE_WAVE_PLANE;
WavePlane.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE;
WavePlane.color_mode = MODE_COLORS_NONE;
WavePlane.speed_min = AURA_MOUSEMAT_SPEED_MIN;
WavePlane.speed_max = AURA_MOUSEMAT_SPEED_MAX;
WavePlane.speed = AURA_MOUSEMAT_SPEED_DEFAULT_WAVE_PLANE;
WavePlane.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
WavePlane.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
WavePlane.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
WavePlane.direction = MODE_DIRECTION_LEFT;
modes.push_back(WavePlane);
mode Comet;
Comet.name = "Comet";
Comet.value = AURA_MOUSEMAT_MODE_COMET;
Comet.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE;
Comet.color_mode = MODE_COLORS_MODE_SPECIFIC;
Comet.speed_min = AURA_MOUSEMAT_SPEED_MIN;
Comet.speed_max = AURA_MOUSEMAT_SPEED_MAX;
Comet.speed = AURA_MOUSEMAT_SPEED_DEFAULT_COMET;
Comet.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
Comet.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
Comet.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
Comet.direction = MODE_DIRECTION_LEFT;
Comet.colors_min = 1;
Comet.colors_max = 1;
Comet.colors.resize(1);
modes.push_back(Comet);
mode GlowingYoyo;
GlowingYoyo.name = "Glowing Yoyo";
GlowingYoyo.value = AURA_MOUSEMAT_MODE_GLOWING_YOYO;
GlowingYoyo.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
GlowingYoyo.color_mode = MODE_COLORS_NONE;
GlowingYoyo.speed_min = AURA_MOUSEMAT_SPEED_MIN;
GlowingYoyo.speed_max = AURA_MOUSEMAT_SPEED_MAX;
GlowingYoyo.speed = AURA_MOUSEMAT_SPEED_DEFAULT_GLOWING_YOYO;
GlowingYoyo.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
GlowingYoyo.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
GlowingYoyo.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
GlowingYoyo.direction = MODE_DIRECTION_LEFT;
modes.push_back(GlowingYoyo);
mode Cross;
Cross.name = "Cross";
Cross.value = AURA_MOUSEMAT_MODE_CROSS;
Cross.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Cross.color_mode = MODE_COLORS_MODE_SPECIFIC;
Cross.speed_min = AURA_MOUSEMAT_SPEED_MIN;
Cross.speed_max = AURA_MOUSEMAT_SPEED_MAX;
Cross.speed = AURA_MOUSEMAT_SPEED_DEFAULT_CROSS;
Cross.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
Cross.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
Cross.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
Cross.colors_min = 2;
Cross.colors_max = 2;
Cross.colors.resize(2);
modes.push_back(Cross);
mode StarryNight;
StarryNight.name = "Starry Night";
StarryNight.value = AURA_MOUSEMAT_MODE_STARRY_NIGHT;
StarryNight.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
StarryNight.color_mode = MODE_COLORS_MODE_SPECIFIC | MODE_COLORS_RANDOM;
StarryNight.speed_min = AURA_MOUSEMAT_SPEED_MIN;
StarryNight.speed_max = AURA_MOUSEMAT_SPEED_MAX;
StarryNight.speed = AURA_MOUSEMAT_SPEED_DEFAULT_STARRY_NIGHT;
StarryNight.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
StarryNight.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
StarryNight.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
StarryNight.colors_min = 2;
StarryNight.colors_max = 2;
StarryNight.colors.resize(2);
modes.push_back(StarryNight);
SetupZones();
}
RGBController_AuraMousemat::~RGBController_AuraMousemat()
{
delete controller;
}
void RGBController_AuraMousemat::SetupZones()
{
zone mousemat_zone;
mousemat_zone.name = "Mousemat";
mousemat_zone.type = ZONE_TYPE_LINEAR;
mousemat_zone.leds_min = 15;
mousemat_zone.leds_max = 15;
mousemat_zone.leds_count = 15;
mousemat_zone.matrix_map = NULL;
zones.push_back(mousemat_zone);
for(unsigned int i = 0; i < 15; i++)
{
led mousemat_led;
mousemat_led.name = "Mousemat LED " + std::to_string(i);
leds.push_back(mousemat_led);
}
SetupColors();
}
void RGBController_AuraMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AuraMousemat::DeviceUpdateLEDs()
{
controller->UpdateLeds(std::vector<RGBColor>(colors));
}
void RGBController_AuraMousemat::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraMousemat::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraMousemat::DeviceUpdateMode()
{
if(modes[active_mode].value == AURA_MOUSEMAT_MODE_DIRECT)
{
DeviceUpdateLEDs();
}
else
{
int pattern = 0;
switch(modes[active_mode].value)
{
case AURA_MOUSEMAT_MODE_BREATHING:
if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
{
pattern = 2;
}
else
{
pattern = (int)modes[active_mode].colors.size() - 1;
}
break;
case AURA_MOUSEMAT_MODE_WAVE:
pattern = (int)modes[active_mode].colors.size() * 16 + modes[active_mode].direction;
break;
case AURA_MOUSEMAT_MODE_WAVE_PLANE:
switch(modes[active_mode].direction)
{
case MODE_DIRECTION_LEFT:
pattern = 2;
break;
case MODE_DIRECTION_RIGHT:
pattern = 3;
break;
case MODE_DIRECTION_UP:
pattern = 0;
break;
case MODE_DIRECTION_DOWN:
pattern = 1;
break;
}
break;
case AURA_MOUSEMAT_MODE_COMET:
pattern = modes[active_mode].direction;
if(pattern == MODE_DIRECTION_HORIZONTAL || pattern == MODE_DIRECTION_VERTICAL) pattern = 2;
break;
case AURA_MOUSEMAT_MODE_GLOWING_YOYO:
pattern = modes[active_mode].direction;
break;
case AURA_MOUSEMAT_MODE_STARRY_NIGHT:
pattern = 16 + (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
break;
default:
pattern = 255;
break;
}
controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), modes[active_mode].speed, modes[active_mode].brightness, pattern);
}
}
void RGBController_AuraMousemat::DeviceSaveMode()
{
DeviceUpdateMode();
controller->SaveMode();
}
Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.h
+54
View File
@@ -0,0 +1,54 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraMousemat.h |
| |
| RGBController for ASUS Aura mousemat |
| |
| Mola19 06 Apr 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusAuraMousematController.h"
enum
{
AURA_MOUSEMAT_BRIGHTNESS_MIN = 0,
AURA_MOUSEMAT_BRIGHTNESS_MAX = 4,
AURA_MOUSEMAT_BRIGHTNESS_DEFAULT = 4,
AURA_MOUSEMAT_SPEED_MIN = 127,
AURA_MOUSEMAT_SPEED_MAX = 0,
AURA_MOUSEMAT_SPEED_DEFAULT_STATIC = 0,
AURA_MOUSEMAT_SPEED_DEFAULT_BREATHING = 1,
AURA_MOUSEMAT_SPEED_DEFAULT_COLOR_CYCLE = 1,
AURA_MOUSEMAT_SPEED_DEFAULT_WAVE = 14,
AURA_MOUSEMAT_SPEED_DEFAULT_WAVE_PLANE = 2,
AURA_MOUSEMAT_SPEED_DEFAULT_COMET = 2,
AURA_MOUSEMAT_SPEED_DEFAULT_GLOWING_YOYO = 4,
AURA_MOUSEMAT_SPEED_DEFAULT_CROSS = 12,
AURA_MOUSEMAT_SPEED_DEFAULT_STARRY_NIGHT = 2,
};
class RGBController_AuraMousemat : public RGBController
{
public:
RGBController_AuraMousemat(AuraMousematController* controller_ptr);
~RGBController_AuraMousemat();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
AuraMousematController* controller;
};
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.cpp
+125
View File
@@ -0,0 +1,125 @@
/*---------------------------------------------------------*\
| AsusAuraRyuoAIOController.cpp |
| |
| Driver for ASUS Aura Ryuo |
| |
| Cooper Hall (geobot19 / Geo_bot) 08 Apr 2022 |
| using snipets from Chris M (Dr.No) |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "AsusAuraRyuoAIOController.h"
AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
{
/*-----------------------------------------------------*\
| Add addressable devices |
| Manually adding device info for now |
| TODO: Implement config table accurately |
\*-----------------------------------------------------*/
uint8_t leds = (dev_name.find("Ryujin") != std::string::npos) ? 5 : 12;
device_info.push_back({0x00, 0x00, leds, 0, AuraDeviceType::FIXED});
}
AsusAuraRyuoAIOController::~AsusAuraRyuoAIOController()
{
/*---------------------------------------------------------*\
| HID device is closed in the base class |
\*---------------------------------------------------------*/
}
std::string AsusAuraRyuoAIOController::GetLocation()
{
return("HID: " + location);
}
void AsusAuraRyuoAIOController::SetMode(unsigned char /*channel*/, unsigned char /*mode*/, unsigned char /*red*/, unsigned char /*grn*/, unsigned char /*blu*/)
{
/*---------------------------------------------------------*\
| This interface is not used in this controller however is |
| required by the abstract class |
\*---------------------------------------------------------*/
}
void AsusAuraRyuoAIOController::SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour)
{
//check if update is needed
if(!((current_mode == mode) && (ToRGBColor(current_red, current_green, current_blue) == colour) && (current_speed == speed) && (current_direction == direction)))
{
current_mode = mode;
current_speed = speed;
current_direction = direction;
current_red = RGBGetRValue(colour);
current_green = RGBGetGValue(colour);
current_blue = RGBGetBValue(colour);
SendUpdate();
}
}
void AsusAuraRyuoAIOController::SetChannelLEDs(unsigned char /*channel*/, RGBColor* /*colors*/, unsigned int /*num_colors*/)
{
/*---------------------------------------------------------*\
| This interface is not used in this controller however is |
| required by the abstract class |
\*---------------------------------------------------------*/
}
void AsusAuraRyuoAIOController::SetLedsDirect(RGBColor * led_colours, uint8_t led_count)
{
uint8_t buffer[write_packet_size] = { 0xEC, 0x40, 0x80, 0x00, led_count };
/*---------------------------------------------------------*\
| Set the colour bytes in the packet |
\*---------------------------------------------------------*/
for(uint8_t index = 0; index < led_count; index++)
{
uint8_t offset = (index * 3) + RED_BYTE;
buffer[offset + 0] = RGBGetRValue(led_colours[index]);
buffer[offset + 1] = RGBGetGValue(led_colours[index]);
buffer[offset + 2] = RGBGetBValue(led_colours[index]);
}
hid_write(dev, buffer, write_packet_size);
}
void AsusAuraRyuoAIOController::GetStatus()
{
uint8_t buffer[write_packet_size] = { 0xEC, 0x01, 0x02 };
hid_write(dev, buffer, write_packet_size);
hid_read_timeout(dev, buffer, read_packet_size, ASUSAURARYUOAIOCONTROLLER_TIMEOUT);
current_red = buffer[RED_BYTE - 1];
current_green = buffer[GREEN_BYTE - 1];
current_blue = buffer[BLUE_BYTE - 1];
}
void AsusAuraRyuoAIOController::SendUpdate()
{
uint8_t buffer[write_packet_size];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(buffer, 0x00, write_packet_size);
buffer[REPORTID_BYTE] = reportid;
buffer[COMMAND_BYTE] = modefx;
buffer[ZONE_BYTE] = 0;
buffer[PROGRAM_ID_BYTE] = program_id;
buffer[MODE_BYTE] = current_mode;
buffer[RED_BYTE] = current_red;
buffer[GREEN_BYTE] = current_green;
buffer[BLUE_BYTE] = current_blue;
buffer[DIRECTION_BYTE]= current_direction;
buffer[SPEED_BYTE] = current_speed;
hid_write(dev, buffer, write_packet_size);
}
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.h
+96
View File
@@ -0,0 +1,96 @@
/*---------------------------------------------------------*\
| AsusAuraRyuoAIOController.h |
| |
| Driver for ASUS Aura Ryuo |
| |
| Cooper Hall (geobot19 / Geo_bot) 08 Apr 2022 |
| using snipets from Chris M (Dr.No) |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <hidapi.h>
#include "RGBController.h"
#include "AsusAuraUSBController.h"
#define ASUSAURARYUOAIOCONTROLLER_TIMEOUT 250
#define ASUSAURARYUOAIOCONTROLLER_HID_MAX_STR 255
#define ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN 0
#define ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX 255
class AsusAuraRyuoAIOController : public AuraUSBController
{
public:
enum
{
MODE_DIRECT = 0xFF, //Direct Led Control - Independently set LEDs in zone
MODE_STATIC = 0x01, //Static Mode - Set entire zone to a single color.
MODE_BREATHING = 0x02, //Breathing Mode - Fades between fully off and fully on.
MODE_FLASHING = 0x03, //Flashing Mode - Abruptly changing between fully off and fully on.
MODE_SPECTRUM = 0x04, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device
MODE_RAINBOW = 0x05, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs
MODE_FLASHANDDASH = 0x0A, //Flash n Dash - Flash twice and then flash in direction
};
enum PacketMap
{
REPORTID_BYTE = 0,
COMMAND_BYTE = 1,
ZONE_BYTE = 2,
PROGRAM_ID_BYTE= 3,
MODE_BYTE = 4,
RED_BYTE = 5,
GREEN_BYTE = 6,
BLUE_BYTE = 7,
DIRECTION_BYTE = 8,
SPEED_BYTE = 9,
};
enum
{
SPEED_SLOWEST = 0x04, // Slowest speed
SPEED_SLOW = 0x03, // Slower speed
SPEED_NORMAL = 0x02, // Normal speed
SPEED_FAST = 0x01, // Fast speed
SPEED_FASTEST = 0x00, // Fastest speed
};
AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path, std::string dev_name);
~AsusAuraRyuoAIOController();
std::string GetLocation();
void SetChannelLEDs(unsigned char channel, RGBColor *colors, unsigned int num_colors);
void SetLedsDirect(RGBColor * led_colours, uint8_t led_count);
void SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu);
void SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour);
private:
static const uint8_t read_packet_size = 65;
static const uint8_t write_packet_size = 65;
static const uint8_t modefx = 0x3B;
static const uint8_t direct = 0x40;
static const uint8_t reportid = 0xEC;
static const uint8_t program_id = 0x22;
std::string location;
uint8_t zone_index;
uint8_t current_mode;
uint8_t current_speed;
uint8_t current_red;
uint8_t current_green;
uint8_t current_blue;
uint8_t current_direction;
void GetStatus();
void SendUpdate();
void SendEffect(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu);
void SendDirectApply(unsigned char channel);
};
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.cpp
+220
View File
@@ -0,0 +1,220 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraRyuoAIO.cpp |
| |
| RGBController for ASUS Aura Ryuo |
| |
| Cooper Hall (geobot19 / Geo_bot) 08 Apr 2022 |
| using snipets from Chris M (Dr.No) |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBControllerKeyNames.h"
#include "RGBController_AsusAuraRyuoAIO.h"
/**------------------------------------------------------------------*\
@name Asus Aura Ryuo AIO
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraUSBRyuoAIO
@category Cooler
@comment
\*-------------------------------------------------------------------*/
RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOController *controller_ptr)
{
controller = controller_ptr;
uint8_t speed = controller->SPEED_NORMAL;
name = controller->GetDeviceName();
vendor = "ASUS";
type = DEVICE_TYPE_COOLER;
description = "ASUS Liquid Cooler with 120mm and 240mm radiators.";
location = controller->GetLocation();
mode Direct;
Direct.name = "Direct";
Direct.value = controller->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 = controller->MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(Static.colors_max);
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = controller->MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(Breathing.colors_max);
Breathing.brightness_min = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
Breathing.brightness_max = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Breathing.brightness = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Breathing.speed_min = controller->SPEED_SLOWEST;
Breathing.speed_max = controller->SPEED_FASTEST;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed = speed;
modes.push_back(Breathing);
mode Flashing;
Flashing.name = "Flashing";
Flashing.value = controller->MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Flashing.colors_min = 1;
Flashing.colors_max = 1;
Flashing.colors.resize(Flashing.colors_max);
Flashing.brightness_min = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
Flashing.brightness_max = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Flashing.brightness = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Flashing.speed_min = controller->SPEED_SLOWEST;
Flashing.speed_max = controller->SPEED_FASTEST;
Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Flashing.speed = speed;
modes.push_back(Flashing);
mode Spectrum;
Spectrum.name = "Spectrum";
Spectrum.value = controller->MODE_SPECTRUM;
Spectrum.flags = MODE_FLAG_HAS_SPEED;
Spectrum.brightness_min = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
Spectrum.brightness_max = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Spectrum.brightness = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Spectrum.speed_min = controller->SPEED_SLOWEST;
Spectrum.speed_max = controller->SPEED_FASTEST;
Spectrum.color_mode = MODE_COLORS_NONE;
Spectrum.speed = speed;
modes.push_back(Spectrum);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = controller->MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Rainbow.brightness_min = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
Rainbow.brightness_max = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Rainbow.brightness = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Rainbow.speed_min = controller->SPEED_SLOWEST;
Rainbow.speed_max = controller->SPEED_FASTEST;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.speed = speed;
modes.push_back(Rainbow);
mode FlashAndDash;
FlashAndDash.name = "Flash and Dash";
FlashAndDash.value = controller->MODE_FLASHANDDASH;
FlashAndDash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
FlashAndDash.brightness_min = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
FlashAndDash.brightness_max = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
FlashAndDash.brightness = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
FlashAndDash.speed_min = controller->SPEED_SLOWEST;
FlashAndDash.speed_max = controller->SPEED_FASTEST;
FlashAndDash.color_mode = MODE_COLORS_NONE;
FlashAndDash.speed = speed;
modes.push_back(FlashAndDash);
SetupZones();
}
RGBController_AsusAuraRyuoAIO::~RGBController_AsusAuraRyuoAIO()
{
delete controller;
}
void RGBController_AsusAuraRyuoAIO::SetupZones()
{
/*-------------------------------------------------*\
| Set up zones |
\*-------------------------------------------------*/
LOG_DEBUG("[%s] - Get channel count: %i", name.c_str(), controller->GetChannelCount());
zones.resize(controller->GetChannelCount());
LOG_DEBUG("[%s] - Creating Zones and LEDs", name.c_str());
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx];
LOG_INFO("[%s] %s Zone %i - Header Count %i LED Count %i FX %02X Direct %02X", name.c_str(),
((device_info.device_type == AuraDeviceType::FIXED) ? "Fixed" : "Addressable"),
zone_idx, device_info.num_headers, device_info.num_leds, device_info.effect_channel, device_info.direct_channel);
zones[zone_idx].name = name + " Zone ";
zones[zone_idx].name.append(std::to_string(zone_idx));
zones[zone_idx].type = ZONE_TYPE_LINEAR;
zones[zone_idx].leds_min = device_info.num_leds;
zones[zone_idx].leds_max = device_info.num_leds;
zones[zone_idx].leds_count = device_info.num_leds;
for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
{
led new_led;
new_led.name = zones[zone_idx].name;
new_led.name.append(" LED " + std::to_string(lp_idx));
new_led.value = lp_idx;
leds.push_back(new_led);
}
}
LOG_DEBUG("[%s] - Device zones and LEDs set", name.c_str());
SetupColors();
}
void RGBController_AsusAuraRyuoAIO::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AsusAuraRyuoAIO::DeviceUpdateLEDs()
{
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
UpdateZoneLEDs(zone_idx);
}
}
void RGBController_AsusAuraRyuoAIO::UpdateZoneLEDs(int zone)
{
controller->SetLedsDirect(zones[zone].colors, zones[zone].leds_count);
}
void RGBController_AsusAuraRyuoAIO::UpdateSingleLED(int led)
{
UpdateZoneLEDs(GetLED_Zone(led));
}
void RGBController_AsusAuraRyuoAIO::DeviceUpdateMode()
{
RGBColor colour = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
controller->SetMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, colour);
}
int RGBController_AsusAuraRyuoAIO::GetLED_Zone(int led_idx)
{
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
int zone_start = zones[zone_idx].start_idx;
int zone_end = zone_start + zones[zone_idx].leds_count - 1;
if(zone_start <= led_idx && zone_end >= led_idx)
{
return(zone_idx);
}
}
return(-1);
}
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.h
+41
View File
@@ -0,0 +1,41 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraRyuoAIO.h |
| |
| RGBController for ASUS Aura Ryuo |
| |
| Cooper Hall (geobot19 / Geo_bot) 08 Apr 2022 |
| using snipets from Chris M (Dr.No) |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <vector>
#include "LogManager.h"
#include "RGBController.h"
#include "AsusAuraRyuoAIOController.h"
class RGBController_AsusAuraRyuoAIO : public RGBController
{
public:
RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOController* controller_ptr);
~RGBController_AsusAuraRyuoAIO();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
int GetDeviceMode();
int GetLED_Zone(int led_idx);
AsusAuraRyuoAIOController* controller;
};
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;
};
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraAddressableController.cpp
+96
View File
@@ -0,0 +1,96 @@
/*---------------------------------------------------------*\
| AsusAuraAddressableController.cpp |
| |
| Driver for ASUS Aura addressable controller |
| |
| Adam Honse (CalcProgrammer1) 18 Jan 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "AsusAuraAddressableController.h"
AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
{
/*-----------------------------------------------------*\
| Add addressable devices |
\*-----------------------------------------------------*/
for(int i = 0; i < config_table[0x02]; ++i)
{
device_info.push_back({0x01, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
}
}
AuraAddressableController::~AuraAddressableController()
{
}
void AuraAddressableController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
{
SendDirect
(
device_info[channel].direct_channel,
num_colors,
colors
);
}
void AuraAddressableController::SetMode
(
unsigned char channel,
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu
)
{
SendEffect
(
channel,
mode,
red,
grn,
blu
);
}
void AuraAddressableController::SendEffect
(
unsigned char channel,
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu
)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0xEC;
usb_buf[0x01] = AURA_ADDRESSABLE_CONTROL_MODE_EFFECT;
usb_buf[0x02] = channel;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = mode;
/*-----------------------------------------------------*\
| Copy in color data bytes |
\*-----------------------------------------------------*/
usb_buf[0x05] = red;
usb_buf[0x06] = grn;
usb_buf[0x07] = blu;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
}
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraAddressableController.h
+56
View File
@@ -0,0 +1,56 @@
/*---------------------------------------------------------*\
| AsusAuraAddressableController.h |
| |
| Driver for ASUS Aura addressable controller |
| |
| Adam Honse (CalcProgrammer1) 18 Jan 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <hidapi.h>
#include "RGBController.h"
#include "AsusAuraUSBController.h"
enum
{
AURA_ADDRESSABLE_CONTROL_MODE_EFFECT = 0x3B, /* Effect control mode */
};
class AuraAddressableController : public AuraUSBController
{
public:
AuraAddressableController(hid_device* dev_handle, const char* path, std::string dev_name);
~AuraAddressableController();
void SetChannelLEDs
(
unsigned char channel,
RGBColor * colors,
unsigned int num_colors
);
void SetMode
(
unsigned char channel,
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu
);
private:
void SendEffect
(
unsigned char channel,
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu
);
};
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraMainboardController.cpp
+235
View File
@@ -0,0 +1,235 @@
/*---------------------------------------------------------*\
| AsusAuraMainboardController.cpp |
| |
| Driver for ASUS Aura mainboard |
| |
| Martin Hartl (inlart) 25 Apr 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "AsusAuraMainboardController.h"
AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name), mode(AURA_MODE_DIRECT)
{
unsigned char num_total_mainboard_leds = config_table[0x1B];
unsigned char num_rgb_headers = config_table[0x1D];
unsigned char num_addressable_headers = config_table[0x02];
unsigned char effect_channel = 0;
if(num_total_mainboard_leds < num_rgb_headers)
{
num_rgb_headers = 0;
}
/*-----------------------------------------------------*\
| Add mainboard device |
\*-----------------------------------------------------*/
if(num_total_mainboard_leds > 0)
{
device_info.push_back({effect_channel, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});
effect_channel++;
}
/*-----------------------------------------------------*\
| Add addressable devices |
\*-----------------------------------------------------*/
for(int i = 0; i < num_addressable_headers; i++)
{
device_info.push_back({effect_channel, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
effect_channel++;
}
SetGen1();
}
AuraMainboardController::~AuraMainboardController()
{
}
void AuraMainboardController::SetGen1()
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up custom command packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0xEC;
usb_buf[0x01] = 0x52;
usb_buf[0x02] = 0x53;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = 0x01;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
}
void AuraMainboardController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
{
SendDirect
(
device_info[channel].direct_channel,
num_colors,
colors
);
}
void AuraMainboardController::SetMode
(
unsigned char channel,
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu
)
{
SetMode(channel, mode, red, grn, blu, false);
}
void AuraMainboardController::SetMode
(
unsigned char channel,
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu,
bool shutdown_effect
)
{
this->mode = mode;
RGBColor color = ToRGBColor(red, grn, blu);
SendEffect(device_info[channel].effect_channel, mode, shutdown_effect);
if(mode == AURA_MODE_DIRECT)
{
return;
}
unsigned char led_data[60];
unsigned char start_led = 0;
for(std::size_t i = 0; i < channel; ++i)
{
start_led += device_info[i].num_leds;
}
for(std::size_t led_idx = 0; led_idx < device_info[channel].num_leds; led_idx++)
{
led_data[(led_idx * 3) + 0] = RGBGetRValue(color);
led_data[(led_idx * 3) + 1] = RGBGetGValue(color);
led_data[(led_idx * 3) + 2] = RGBGetBValue(color);
}
SendColor
(
channel,
start_led,
device_info[channel].num_leds,
led_data,
shutdown_effect
);
}
unsigned short AuraMainboardController::GetMask(int start, int size)
{
return(((1 << size) - 1) << start);
}
void AuraMainboardController::SendEffect
(
unsigned char channel,
unsigned char mode,
bool shutdown_effect
)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0xEC;
usb_buf[0x01] = AURA_MAINBOARD_CONTROL_MODE_EFFECT;
usb_buf[0x02] = channel;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = shutdown_effect ? 0x01 : 0x00;
usb_buf[0x05] = mode;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
}
void AuraMainboardController::SendColor
(
unsigned char /*channel*/,
unsigned char start_led,
unsigned char led_count,
unsigned char* led_data,
bool shutdown_effect
)
{
unsigned short mask = GetMask(start_led, led_count);
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0xEC;
usb_buf[0x01] = AURA_MAINBOARD_CONTROL_MODE_EFFECT_COLOR;
usb_buf[0x02] = mask >> 8;
usb_buf[0x03] = mask & 0xff;
usb_buf[0x04] = shutdown_effect ? 0x01 : 0x00;
/*-----------------------------------------------------*\
| Copy in color data bytes |
\*-----------------------------------------------------*/
memcpy(&usb_buf[0x05 + 3 * start_led], led_data, led_count * 3);
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
}
void AuraMainboardController::SendCommit()
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0xEC;
usb_buf[0x01] = AURA_MAINBOARD_CONTROL_MODE_COMMIT;
usb_buf[0x02] = 0x55;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
}
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraMainboardController.h
+82
View File
@@ -0,0 +1,82 @@
/*---------------------------------------------------------*\
| AsusAuraMainboardController.h |
| |
| Driver for ASUS Aura mainboard |
| |
| Martin Hartl (inlart) 25 Apr 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <hidapi.h>
#include "RGBController.h"
#include "AsusAuraUSBController.h"
enum
{
AURA_MAINBOARD_CONTROL_MODE_EFFECT = 0x35, /* Effect control mode */
AURA_MAINBOARD_CONTROL_MODE_EFFECT_COLOR = 0x36, /* Effect color control mode */
AURA_MAINBOARD_CONTROL_MODE_COMMIT = 0x3F, /* Commit mode */
};
class AuraMainboardController : public AuraUSBController
{
public:
AuraMainboardController(hid_device* dev_handle, const char* path, std::string dev_name);
~AuraMainboardController();
void SetChannelLEDs
(
unsigned char channel,
RGBColor * colors,
unsigned int num_colors
);
void SetMode
(
unsigned char channel,
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu
);
void SetMode
(
unsigned char channel,
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu,
bool shutdown_effect
);
void SendCommit();
private:
unsigned int mode;
unsigned short GetMask(int start, int size);
void SendEffect
(
unsigned char channel,
unsigned char mode,
bool shutdown_effect
);
void SendColor
(
unsigned char channel,
unsigned char start_led,
unsigned char led_count,
unsigned char* led_data,
bool shutdown_effect
);
void SetGen1();
};
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraUSBController.cpp
+203
View File
@@ -0,0 +1,203 @@
/*---------------------------------------------------------*\
| AsusAuraUSBController.cpp |
| |
| Driver for ASUS Aura USB device |
| |
| Martin Hartl (inlart) 25 Apr 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "AsusAuraUSBController.h"
#include "LogManager.h"
#include "StringUtils.h"
AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
GetFirmwareVersion();
GetConfigTable();
}
AuraUSBController::~AuraUSBController()
{
hid_close(dev);
}
unsigned int AuraUSBController::GetChannelCount()
{
return((unsigned int)device_info.size());
}
std::string AuraUSBController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string AuraUSBController::GetDeviceName()
{
return(name);
}
std::string AuraUSBController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string AuraUSBController::GetDeviceVersion()
{
return(std::string(version));
}
const std::vector<AuraDeviceInfo>& AuraUSBController::GetAuraDevices() const
{
return(device_info);
}
void AuraUSBController::GetConfigTable()
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0xEC;
usb_buf[0x01] = AURA_REQUEST_CONFIG_TABLE;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
hid_read(dev, usb_buf, 65);
/*-----------------------------------------------------*\
| Copy the firmware string if the reply ID is correct |
\*-----------------------------------------------------*/
if(usb_buf[1] == 0x30)
{
memcpy(config_table, &usb_buf[4], 60);
LOG_DEBUG("[%s] ASUS Aura USB config table:", version);
for(int i = 0; i < 60; i+=6)
{
LOG_DEBUG("[%s] %02X %02X %02X %02X %02X %02X", version,
config_table[i + 0],
config_table[i + 1],
config_table[i + 2],
config_table[i + 3],
config_table[i + 4],
config_table[i + 5]);
}
}
else
{
LOG_INFO("[%s] Could not read config table, can not add device", version);
delete this;
}
}
void AuraUSBController::GetFirmwareVersion()
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up firmware version request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0xEC;
usb_buf[0x01] = AURA_REQUEST_FIRMWARE_VERSION;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
hid_read(dev, usb_buf, 65);
/*-----------------------------------------------------*\
| Copy the firmware string if the reply ID is correct |
\*-----------------------------------------------------*/
if(usb_buf[1] == 0x02)
{
memcpy(version, &usb_buf[2], 16);
}
}
void AuraUSBController::SendDirect
(
unsigned char device,
unsigned char led_count,
RGBColor* colors
)
{
unsigned char usb_buf[65];
unsigned char offset = 0x00;
unsigned char sent_led_count = LEDS_PER_PACKET;
bool apply = false;
while(!apply)
{
if(offset + sent_led_count > led_count)
{
sent_led_count = led_count - offset;
}
if(offset + sent_led_count == led_count)
{
apply = true;
}
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0xEC;
usb_buf[0x01] = AURA_CONTROL_MODE_DIRECT;
usb_buf[0x02] = (apply ? 0x80 : 0x00) | device;
usb_buf[0x03] = offset;
usb_buf[0x04] = sent_led_count;
/*-----------------------------------------------------*\
| Copy in color data bytes |
\*-----------------------------------------------------*/
for(unsigned char led_idx = 0; led_idx < sent_led_count; led_idx++)
{
usb_buf[0x05 + (led_idx * 3)] = RGBGetRValue(colors[offset + led_idx]);
usb_buf[0x06 + (led_idx * 3)] = RGBGetGValue(colors[offset + led_idx]);
usb_buf[0x07 + (led_idx * 3)] = RGBGetBValue(colors[offset + led_idx]);
}
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
offset += sent_led_count;
}
}
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraUSBController.h
+113
View File
@@ -0,0 +1,113 @@
/*---------------------------------------------------------*\
| AsusAuraUSBController.h |
| |
| Driver for ASUS Aura USB device |
| |
| Martin Hartl (inlart) 25 Apr 2020 |
| |
| 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 "LogManager.h"
enum
{
AURA_MODE_OFF = 0, /* OFF mode */
AURA_MODE_STATIC = 1, /* Static color mode */
AURA_MODE_BREATHING = 2, /* Breathing effect mode */
AURA_MODE_FLASHING = 3, /* Flashing effect mode */
AURA_MODE_SPECTRUM_CYCLE = 4, /* Spectrum Cycle mode */
AURA_MODE_RAINBOW = 5, /* Rainbow effect mode */
AURA_MODE_SPECTRUM_CYCLE_BREATHING = 6, /* Rainbow Breathing effect mode */
AURA_MODE_CHASE_FADE = 7, /* Chase with Fade effect mode */
AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE = 8, /* Chase with Fade, Rainbow effect mode */
AURA_MODE_CHASE = 9, /* Chase effect mode */
AURA_MODE_SPECTRUM_CYCLE_CHASE = 10, /* Chase with Rainbow effect mode */
AURA_MODE_SPECTRUM_CYCLE_WAVE = 11, /* Wave effect mode */
AURA_MODE_CHASE_RAINBOW_PULSE = 12, /* Chase with Rainbow Pulse effect mode*/
AURA_MODE_RANDOM_FLICKER = 13, /* Random flicker effect mode */
AURA_MODE_MUSIC = 14, /* Music effect mode */
AURA_MODE_DIRECT = 0xFF, /* Direct control mode */
};
enum
{
AURA_REQUEST_FIRMWARE_VERSION = 0x82, /* Request firmware string */
AURA_REQUEST_CONFIG_TABLE = 0xB0, /* Request configuration table */
AURA_CONTROL_MODE_DIRECT = 0x40, /* Direct control mode */
};
enum class AuraDeviceType
{
FIXED,
ADDRESSABLE,
};
#define LEDS_PER_PACKET 0x14;
struct AuraDeviceInfo
{
unsigned char effect_channel;
unsigned char direct_channel;
unsigned char num_leds;
unsigned char num_headers;
AuraDeviceType device_type;
};
class AuraUSBController
{
public:
AuraUSBController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~AuraUSBController();
unsigned int GetChannelCount();
std::string GetDeviceLocation();
std::string GetDeviceName();
std::string GetSerialString();
std::string GetDeviceVersion();
const std::vector<AuraDeviceInfo>& GetAuraDevices() const;
virtual void SetChannelLEDs
(
unsigned char channel,
RGBColor * colors,
unsigned int num_colors
) = 0;
virtual void SetMode
(
unsigned char channel,
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu
) = 0;
protected:
hid_device* dev;
unsigned char config_table[60];
std::vector<AuraDeviceInfo> device_info;
std::string location;
std::string name;
char version[16];
void SendDirect
(
unsigned char device,
unsigned char led_count,
RGBColor * colors
);
private:
void GetConfigTable();
void GetFirmwareVersion();
};
Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraMainboard.cpp
+77
View File
@@ -0,0 +1,77 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraMainboard.cpp |
| |
| RGBController for ASUS Aura mainboard |
| |
| rytypete 30 Aug 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_AsusAuraMainboard.h"
/**------------------------------------------------------------------*\
@name Asus Aura USB Mainboard
@category Motherboard
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraUSBMotherboards
@comment The Asus Aura USB Mainboard controller applies to most
AMD and Intel mainboards from the x570 chipset onwards.
\*-------------------------------------------------------------------*/
RGBController_AuraMainboard::RGBController_AuraMainboard(AuraMainboardController* controller_ptr) :
RGBController_AuraUSB(controller_ptr)
{
description = "ASUS Aura USB Mainboard Device";
/*-------------------------------------------------------*\
| Add manual save flag to all modes except direct mode |
\*-------------------------------------------------------*/
for(unsigned int mode_idx = 0; mode_idx < modes.size(); mode_idx++)
{
mode Mode = modes[mode_idx];
if(Mode.value != AURA_MODE_DIRECT)
{
Mode.flags |= MODE_FLAG_MANUAL_SAVE;
modes[mode_idx] = Mode;
}
}
}
void RGBController_AuraMainboard::DeviceUpdateShutdownEffect()
{
unsigned char red = 0;
unsigned char grn = 0;
unsigned char blu = 0;
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
{
red = RGBGetRValue(modes[active_mode].colors[0]);
grn = RGBGetGValue(modes[active_mode].colors[0]);
blu = RGBGetBValue(modes[active_mode].colors[0]);
}
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx];
/*---------------------------------------------------*\
| Shutdown effect only works with onboard lighting |
\*---------------------------------------------------*/
if(device_info.device_type == AuraDeviceType::FIXED && zones[zone_idx].leds_count > 0)
{
((AuraMainboardController*) controller)->SetMode(zone_idx, modes[active_mode].value, red, grn, blu, true);
}
}
}
void RGBController_AuraMainboard::DeviceSaveMode()
{
DeviceUpdateMode();
DeviceUpdateShutdownEffect();
((AuraMainboardController*) controller)->SendCommit();
}
Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraMainboard.h
+26
View File
@@ -0,0 +1,26 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraMainboard.h |
| |
| RGBController for ASUS Aura mainboard |
| |
| rytypete 30 Aug 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController_AsusAuraUSB.h"
#include "AsusAuraMainboardController.h"
class RGBController_AuraMainboard : public RGBController_AuraUSB
{
public:
RGBController_AuraMainboard(AuraMainboardController* controller_ptr);
void DeviceSaveMode();
private:
void DeviceUpdateShutdownEffect();
};
Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp
+275
View File
@@ -0,0 +1,275 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraUSB.cpp |
| |
| RGBController for ASUS Aura USB device |
| |
| Adam Honse (CalcProgrammer1) 18 Jan 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_AsusAuraUSB.h"
/**------------------------------------------------------------------*\
@name Asus Aura USB
@category Motherboard
@type USB
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable
@comment The Asus Aura USB controller applies to most AMD and
Intel mainboards from the x470 and z390 chipset generations.
\*-------------------------------------------------------------------*/
RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr) :
initializedMode(false)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "ASUS";
type = DEVICE_TYPE_MOTHERBOARD;
description = "ASUS Aura USB Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
version = controller->GetDeviceVersion();
mode Direct;
Direct.name = "Direct";
Direct.value = AURA_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Off;
Off.name = "Off";
Off.value = AURA_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Static;
Static.name = "Static";
Static.value = AURA_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = AURA_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode Flashing;
Flashing.name = "Flashing";
Flashing.value = AURA_MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Flashing.colors_min = 1;
Flashing.colors_max = 1;
Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Flashing.colors.resize(1);
modes.push_back(Flashing);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = AURA_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = 0;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = AURA_MODE_RAINBOW;
Rainbow.flags = 0;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
mode ChaseFade;
ChaseFade.name = "Chase Fade";
ChaseFade.value = AURA_MODE_CHASE_FADE;
ChaseFade.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
ChaseFade.colors_min = 1;
ChaseFade.colors_max = 1;
ChaseFade.color_mode = MODE_COLORS_MODE_SPECIFIC;
ChaseFade.colors.resize(1);
modes.push_back(ChaseFade);
mode Chase;
Chase.name = "Chase";
Chase.value = AURA_MODE_CHASE;
Chase.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Chase.colors_min = 1;
Chase.colors_max = 1;
Chase.color_mode = MODE_COLORS_MODE_SPECIFIC;
Chase.colors.resize(1);
modes.push_back(Chase);
SetupZones();
}
RGBController_AuraUSB::~RGBController_AuraUSB()
{
delete controller;
}
void RGBController_AuraUSB::SetupZones()
{
/*-------------------------------------------------*\
| Only set LED count on the first run |
\*-------------------------------------------------*/
bool first_run = false;
if(zones.size() == 0)
{
first_run = true;
}
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
leds.clear();
colors.clear();
zones.resize(controller->GetChannelCount());
/*-------------------------------------------------*\
| Set zones and leds |
\*-------------------------------------------------*/
int addressableCounter = 1;
for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
{
AuraDeviceInfo device_info = controller->GetAuraDevices()[channel_idx];
zones[channel_idx].type = ZONE_TYPE_LINEAR;
if(device_info.device_type == AuraDeviceType::FIXED)
{
zones[channel_idx].name = "Aura Mainboard";
zones[channel_idx].leds_min = device_info.num_leds;
zones[channel_idx].leds_max = device_info.num_leds;
zones[channel_idx].leds_count = device_info.num_leds;
}
else
{
zones[channel_idx].name = "Aura Addressable ";
zones[channel_idx].name.append(std::to_string(addressableCounter));
zones[channel_idx].leds_min = 0;
zones[channel_idx].leds_max = AURA_ADDRESSABLE_MAX_LEDS;
addressableCounter++;
if(first_run)
{
zones[channel_idx].leds_count = 0;
}
}
unsigned int num_mainboard_leds = device_info.num_leds - device_info.num_headers;
for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
{
unsigned led_idx = led_ch_idx + 1;
led new_led;
new_led.name = zones[channel_idx].name;
if(device_info.device_type == AuraDeviceType::FIXED && led_ch_idx >= num_mainboard_leds)
{
new_led.name.append(", RGB Header ");
led_idx -= num_mainboard_leds;
}
else
{
new_led.name.append(", LED ");
}
new_led.name.append(std::to_string(led_idx));
new_led.value = channel_idx;
leds.push_back(new_led);
}
zones[channel_idx].matrix_map = NULL;
}
SetupColors();
}
void RGBController_AuraUSB::ResizeZone(int zone, int new_size)
{
if((size_t) zone >= zones.size())
{
return;
}
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
{
zones[zone].leds_count = new_size;
SetupZones();
}
}
void RGBController_AuraUSB::DeviceUpdateLEDs()
{
if(!initializedMode)
{
DeviceUpdateMode();
}
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
controller->SetChannelLEDs((unsigned char)zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
}
void RGBController_AuraUSB::UpdateZoneLEDs(int zone)
{
if(!initializedMode)
{
DeviceUpdateMode();
}
controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
}
void RGBController_AuraUSB::UpdateSingleLED(int led)
{
if(!initializedMode)
{
DeviceUpdateMode();
}
unsigned int channel = leds[led].value;
controller->SetChannelLEDs(channel, zones[channel].colors, zones[channel].leds_count);
}
void RGBController_AuraUSB::DeviceUpdateMode()
{
initializedMode = true;
unsigned char red = 0;
unsigned char grn = 0;
unsigned char blu = 0;
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
{
red = RGBGetRValue(modes[active_mode].colors[0]);
grn = RGBGetGValue(modes[active_mode].colors[0]);
blu = RGBGetBValue(modes[active_mode].colors[0]);
}
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
if(zones[zone_idx].leds_count > 0)
{
controller->SetMode(zone_idx, modes[active_mode].value, red, grn, blu);
}
}
}
Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.h
+42
View File
@@ -0,0 +1,42 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraUSB.h |
| |
| RGBController for ASUS Aura USB device |
| |
| Adam Honse (CalcProgrammer1) 18 Jan 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusAuraUSBController.h"
#define AURA_ADDRESSABLE_MAX_LEDS 120
class RGBController_AuraUSB : public RGBController
{
public:
RGBController_AuraUSB(AuraUSBController* controller_ptr);
~RGBController_AuraUSB();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
protected:
AuraUSBController* controller;
private:
std::vector<unsigned int> leds_channel;
std::vector<unsigned int> zones_channel;
bool initializedMode;
};
Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
+463
View File
@@ -0,0 +1,463 @@
/*---------------------------------------------------------*\
| AsusAuraUSBControllerDetect.cpp |
| |
| Detector for ASUS Aura USB devices |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <stdexcept>
#include <hidapi.h>
#include "Detector.h"
#include "AsusAuraAddressableController.h"
#include "AsusAuraHeadsetStandController.h"
#include "AsusAuraKeyboardController.h"
#include "AsusAuraTUFKeyboardController.h"
#include "AsusAuraMainboardController.h"
#include "AsusAuraMouseController.h"
#include "AsusROGAllyController.h"
#include "AsusROGStrixLCController.h"
#include "AsusAuraMouseGen1Controller.h"
#include "AsusAuraMousematController.h"
#include "AsusAuraMonitorController.h"
#include "AsusAuraRyuoAIOController.h"
#include "RGBController_AsusAuraUSB.h"
#include "RGBController_AsusAuraHeadsetStand.h"
#include "RGBController_AsusAuraKeyboard.h"
#include "RGBController_AsusAuraTUFKeyboard.h"
#include "RGBController_AsusAuraMainboard.h"
#include "RGBController_AsusAuraMouse.h"
#include "RGBController_AsusAuraMousemat.h"
#include "RGBController_AsusROGAlly.h"
#include "RGBController_AsusROGStrixLC.h"
#include "RGBController_AsusROGSpatha.h"
#include "RGBController_AsusROGStrixEvolve.h"
#include "RGBController_AsusAuraMonitor.h"
#include "RGBController_AsusAuraRyuoAIO.h"
#include "dmiinfo.h"
#define AURA_USB_VID 0x0B05
/*-----------------------------------------------------------------*\
| MOTHERBOARDS |
\*-----------------------------------------------------------------*/
#define AURA_ADDRESSABLE_1_PID 0x1867
#define AURA_ADDRESSABLE_2_PID 0x1872
#define AURA_ADDRESSABLE_3_PID 0x18A3
#define AURA_ADDRESSABLE_4_PID 0x18A5
#define AURA_MOTHERBOARD_1_PID 0x18F3
#define AURA_MOTHERBOARD_2_PID 0x1939
#define AURA_MOTHERBOARD_3_PID 0x19AF
#define AURA_MOTHERBOARD_4_PID 0x1AA6
#define AURA_MOTHERBOARD_5_PID 0x1BED
/*-----------------------------------------------------------------*\
| KEYBOARDS |
\*-----------------------------------------------------------------*/
#define AURA_ROG_AZOTH_USB_PID 0x1A83
#define AURA_ROG_AZOTH_2_4_PID 0x1A85
#define AURA_ROG_CLAYMORE_PID 0x184D
#define AURA_ROG_FALCHION_WIRED_PID 0x193C
#define AURA_ROG_FALCHION_WIRELESS_PID 0x193E
#define AURA_ROG_STRIX_FLARE_PID 0x1875
#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID 0x18CF
#define AURA_ROG_STRIX_FLARE_COD_BO4_PID 0x18AF
#define AURA_ROG_STRIX_FLARE_II_ANIMATE_PID 0x19FC
#define AURA_ROG_STRIX_FLARE_II_PID 0x19FE
#define AURA_ROG_STRIX_SCOPE_PID 0x18F8
#define AURA_ROG_STRIX_SCOPE_TKL_PID 0x190C
#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID 0x1954
#define AURA_ROG_STRIX_SCOPE_RX_PID 0x1951
#define AURA_ROG_STRIX_SCOPE_RX_EVA_02_PID 0x1B12
#define AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID 0x1A05
#define AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID 0x19F6
#define AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID 0x19F8
#define AURA_ROG_STRIX_SCOPE_II_PID 0x1AB3
#define AURA_ROG_STRIX_SCOPE_II_RX_PID 0x1AB5
#define AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID 0x1AAE
#define AURA_ROG_STRIX_SCOPE_II_96_RX_WIRELESS_USB_PID 0x1B78
#define AURA_TUF_K1_GAMING_PID 0x1945
#define AURA_TUF_K3_GAMING_PID 0x194B
#define AURA_TUF_K3_GAMING_GEN_II_PID 0x1B30
#define AURA_TUF_K5_GAMING_PID 0x1899
#define AURA_TUF_K7_GAMING_PID 0x18AA
#define AURA_TUF_K3_GENII_MIKU_EDITION_PID 0x1C5E
/*-----------------------------------------------------------------*\
| MICE - defined in AsusAuraMouseDevices.h |
\*-----------------------------------------------------------------*/
#define AURA_ROG_STRIX_EVOLVE_PID 0x185B
#define AURA_ROG_SPATHA_WIRED_PID 0x181C
#define AURA_ROG_SPATHA_WIRELESS_PID 0x1824
/*-----------------------------------------------------------------*\
| MOUSEMATS |
\*-----------------------------------------------------------------*/
#define AURA_ROG_BALTEUS_PID 0x1891
#define AURA_ROG_BALTEUS_QI_PID 0x1890
/*-----------------------------------------------------------------*\
| MONITORS |
\*-----------------------------------------------------------------*/
#define AURA_ROG_STRIX_XG27AQ_PID 0x198C
#define AURA_ROG_STRIX_XG27AQM_PID 0x19BB
#define AURA_ROG_STRIX_XG279Q_PID 0x1919
#define AURA_ROG_STRIX_XG27W_PID 0x1933
#define AURA_ROG_STRIX_XG32VC_PID 0x1968
#define AURA_ROG_PG32UQ_PID 0x19B9
/*-----------------------------------------------------------------*\
| HEADSET STANDS |
\*-----------------------------------------------------------------*/
#define AURA_ROG_THRONE_PID 0x18D9
#define AURA_ROG_THRONE_QI_PID 0x18C5
#define AURA_ROG_THRONE_QI_GUNDAM_PID 0x1994
/*-----------------------------------------------------------------*\
| OTHER |
\*-----------------------------------------------------------------*/
#define AURA_TERMINAL_PID 0x1889
#define ROG_STRIX_LC120_PID 0x879E
#define AURA_RYUO_AIO_PID 0x1887
#define AURA_RYUJIN_AIO_PID 0x18AE
#define ASUS_ROG_ALLY_PID 0x1ABE
#define ASUS_ROG_ALLY_X_PID 0x1B4C
AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
{
switch(pid)
{
case AURA_ROG_STRIX_SCOPE_PID:
return SCOPE_LAYOUT;
case AURA_ROG_STRIX_SCOPE_RX_PID:
return SCOPE_RX_LAYOUT;
case AURA_ROG_STRIX_SCOPE_TKL_PID:
case AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID:
case AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID:
return SCOPE_TKL_LAYOUT;
default:
return FLARE_LAYOUT;
}
}
void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AuraAddressableController* controller = new AuraAddressableController(dev, info->path, name);
RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*name*/)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
DMIInfo dmi;
AuraAddressableController* controller = new AuraAddressableController(dev, info->path, "ASUS " + dmi.getMainboard() + " Addressable");
RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*name*/)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
try
{
DMIInfo dmi;
AuraMainboardController* controller = new AuraMainboardController(dev, info->path, "ASUS " + dmi.getMainboard());
RGBController_AuraMainboard* rgb_controller = new RGBController_AuraMainboard(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
catch(const std::runtime_error& ex)
{
// reading the config table failed
LOG_ERROR("[AsusAuraUSB] An error occured while reading the config table: %s", ex.what());
}
}
}
void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AuraKeyboardController* controller = new AuraKeyboardController(dev, info->path, name);
AuraKeyboardMappingLayoutType layout = GetKeyboardMappingLayoutType(info->product_id);
RGBController_AuraKeyboard* rgb_controller = new RGBController_AuraKeyboard(controller, layout);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
uint16_t pid = (name == "Asus ROG Spatha X Dock") ? AURA_ROG_SPATHA_X_DOCK_FAKE_PID : info->product_id;
AuraMouseController* controller = new AuraMouseController(dev, info->path, pid, name);
RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBMousemats(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AuraMousematController* controller = new AuraMousematController(dev, info->path, name);
RGBController_AuraMousemat* rgb_controller = new RGBController_AuraMousemat(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AsusROGStrixLCController* controller = new AsusROGStrixLCController(dev, info->path, name);
RGBController_AsusROGStrixLC* rgb_controller = new RGBController_AsusROGStrixLC(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBRyuoAIO(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AsusAuraRyuoAIOController* controller = new AsusAuraRyuoAIOController(dev, info->path, name);
RGBController_AsusAuraRyuoAIO* rgb_controller = new RGBController_AsusAuraRyuoAIO(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AsusAuraMouseGen1Controller* controller = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
RGBController_AsusROGStrixEvolve* rgb_controller = new RGBController_AsusROGStrixEvolve(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBSpatha(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AsusAuraMouseGen1Controller* controller = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
RGBController_AsusROGSpatha* rgb_controller = new RGBController_AsusROGSpatha(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AuraHeadsetStandController* controller = new AuraHeadsetStandController(dev, info->path, name);
RGBController_AuraHeadsetStand* rgb_controller = new RGBController_AuraHeadsetStand(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number, name);
RGBController_AuraTUFKeyboard* rgb_controller = new RGBController_AuraTUFKeyboard(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AuraMonitorController* controller = new AuraMonitorController(dev, info->path, info->product_id, name);
RGBController_AuraMonitor* rgb_controller = new RGBController_AuraMonitor(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusROGAlly(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
ROGAllyController* controller = new ROGAllyController(dev, info->path, name);
RGBController_AsusROGAlly* rgb_controller = new RGBController_AsusROGAlly(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
/*-----------------------------------------------------------------*\
| MOTHERBOARDS |
\*-----------------------------------------------------------------*/
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_3_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_4_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Motherboard", DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Motherboard", DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Motherboard", DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_3_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Motherboard", DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_4_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Motherboard", DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_5_PID);
/*-----------------------------------------------------------------*\
| KEYBOARDS |
\*-----------------------------------------------------------------*/
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 RX TKL Wireless Deluxe", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_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 Azoth USB", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_AZOTH_USB_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Azoth 2.4GHz", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_AZOTH_2_4_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 ROG Falchion (Wired)", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare CoD Black Ops 4 Edition", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_FLARE_COD_BO4_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare II Animate", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_ANIMATE_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare II", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX EVA-02 Edition", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_EVA_02_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope NX Wireless Deluxe USB", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope NX Wireless Deluxe 2.4GHz", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II RX", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_RX_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II 96 Wireless USB", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II 96 RX Wireless USB", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_96_RX_WIRELESS_USB_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K1", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K1_GAMING_PID, 2, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K3_GAMING_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3 GEN II", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K3_GAMING_GEN_II_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K5", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K5_GAMING_PID, 2, 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 GEN II MIKU EDITION", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K3_GENII_MIKU_EDITION_PID, 1, 0xFF00);
/*-----------------------------------------------------------------*\
| MICE |
\*-----------------------------------------------------------------*/
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID, 1, 0xFF13);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_III_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Core", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_III_CORE_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless AimPoint USB", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless AimPoint 2.4Ghz", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X USB", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_CHAKRAM_X_USB_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X 2.4GHz", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_CHAKRAM_X_2_4_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X USB", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_SPATHA_X_USB_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X 2.4GHz", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_SPATHA_X_2_4_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X Dock", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_SPATHA_X_DOCK_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_PUGIO_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Gundam", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Electro Punk", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PUNK_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Moonlight White", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WHITE_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless USB", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless 2.4 Ghz", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact III", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_STRIX_IMPACT_III_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Keris", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_KERIS, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless USB", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_USB_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless 2.4Ghz", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_2_4_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless Bluetooth", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_BT_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless AimPoint USB", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless AimPoint 2.4Ghz", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_TUF_M3_PID, 1, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3 Gen II", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_TUF_M3_GEN_II_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_TUF_M5_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Evolve", DetectAsusAuraUSBStrixEvolve, AURA_USB_VID, AURA_ROG_STRIX_EVOLVE_PID, 1, 0x0008);
REGISTER_HID_DETECTOR_IP("ASUS ROG Spatha Wired", DetectAsusAuraUSBSpatha, AURA_USB_VID, AURA_ROG_SPATHA_WIRED_PID, 1, 0x0008);
REGISTER_HID_DETECTOR_IP("ASUS ROG Spatha Wireless", DetectAsusAuraUSBSpatha, AURA_USB_VID, AURA_ROG_SPATHA_WIRELESS_PID, 1, 0x0008);
/*-----------------------------------------------------------------*\
| MOUSEMATS |
\*-----------------------------------------------------------------*/
REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus", DetectAsusAuraUSBMousemats, AURA_USB_VID, AURA_ROG_BALTEUS_PID, 0xFF06, 1);
REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi", DetectAsusAuraUSBMousemats, AURA_USB_VID, AURA_ROG_BALTEUS_QI_PID, 0xFF06, 1);
/*-----------------------------------------------------------------*\
| MONITORS |
\*-----------------------------------------------------------------*/
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQ", DetectAsusAuraUSBMonitor, AURA_USB_VID, AURA_ROG_STRIX_XG27AQ_PID, 0xFFA0, 1);
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQM", DetectAsusAuraUSBMonitor, AURA_USB_VID, AURA_ROG_STRIX_XG27AQM_PID, 0xFFA0, 1);
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG279Q", DetectAsusAuraUSBMonitor, AURA_USB_VID, AURA_ROG_STRIX_XG279Q_PID, 0xFFA0, 1);
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27W", DetectAsusAuraUSBMonitor, AURA_USB_VID, AURA_ROG_STRIX_XG27W_PID, 0xFFA0, 1);
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG32VC", DetectAsusAuraUSBMonitor, AURA_USB_VID, AURA_ROG_STRIX_XG32VC_PID, 0xFFA0, 1);
REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ", DetectAsusAuraUSBMonitor, AURA_USB_VID, AURA_ROG_PG32UQ_PID, 0xFFA0, 1);
/*-----------------------------------------------------------------*\
| OTHER |
\*-----------------------------------------------------------------*/
REGISTER_HID_DETECTOR ("ASUS ROG AURA Terminal", DetectAsusAuraUSBTerminal, AURA_USB_VID, AURA_TERMINAL_PID);
REGISTER_HID_DETECTOR_PU ("ASUS ROG Strix LC", DetectAsusAuraUSBROGStrixLC, AURA_USB_VID, ROG_STRIX_LC120_PID, 0x00FF, 1);
REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryuo AIO", DetectAsusAuraUSBRyuoAIO, AURA_USB_VID, AURA_RYUO_AIO_PID, 0xFF72, 0x00A1);
REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryujin AIO", DetectAsusAuraUSBRyuoAIO, AURA_USB_VID, AURA_RYUJIN_AIO_PID, 0xFF72, 0x00A1);
REGISTER_HID_DETECTOR_I ("ASUS ROG Throne", DetectAsusAuraUSBHeadsetStand, AURA_USB_VID, AURA_ROG_THRONE_PID, 0);
REGISTER_HID_DETECTOR_I ("ASUS ROG Throne QI", DetectAsusAuraUSBHeadsetStand, AURA_USB_VID, AURA_ROG_THRONE_QI_PID, 0);
REGISTER_HID_DETECTOR_I ("ASUS ROG Throne QI GUNDAM", DetectAsusAuraUSBHeadsetStand, AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID, 0);
REGISTER_HID_DETECTOR_IPU("ASUS ROG Ally", DetectAsusROGAlly, AURA_USB_VID, ASUS_ROG_ALLY_PID, 2, 0xFF31, 0x0076);
REGISTER_HID_DETECTOR_IPU("ASUS ROG Ally X", DetectAsusROGAlly, AURA_USB_VID, ASUS_ROG_ALLY_X_PID, 2, 0xFF31, 0x0076);
Controllers/AsusAuraUSBController/AsusROGAllyController/AsusROGAllyController.cpp
+183
View File
@@ -0,0 +1,183 @@
/*---------------------------------------------------------*\
| AsusROGAllyController.cpp |
| |
| Driver for ASUS ROG Ally |
| |
| Adam Honse (CalcProgrammer1) 12 Jul 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "AsusROGAllyController.h"
#include "StringUtils.h"
ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
SendInitialization();
}
ROGAllyController::~ROGAllyController()
{
hid_close(dev);
}
std::string ROGAllyController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string ROGAllyController::GetName()
{
return(name);
}
std::string ROGAllyController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string ROGAllyController::GetVersion()
{
return("");
}
void ROGAllyController::SendInitialization()
{
unsigned char usb_buf[64];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x5D;
usb_buf[0x01] = 0xB9;
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x5D;
usb_buf[0x01] = 0x41;
usb_buf[0x02] = 0x53;
usb_buf[0x03] = 0x55;
usb_buf[0x04] = 0x53;
usb_buf[0x05] = 0x20;
usb_buf[0x06] = 0x54;
usb_buf[0x07] = 0x65;
usb_buf[0x08] = 0x63;
usb_buf[0x09] = 0x68;
usb_buf[0x0A] = 0x2E;
usb_buf[0x0B] = 0x49;
usb_buf[0x0C] = 0x6E;
usb_buf[0x0D] = 0x63;
usb_buf[0x0E] = 0x2E;
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
}
void ROGAllyController::UpdateBrightness
(
unsigned char brightness
)
{
unsigned char usb_buf[64];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x5A;
usb_buf[0x01] = 0xBA;
usb_buf[0x02] = 0xC5;
usb_buf[0x03] = 0xC4;
usb_buf[0x04] = brightness;
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
}
void ROGAllyController::UpdateLeds
(
std::vector<RGBColor> colors
)
{
unsigned char usb_buf[64];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x5A;
usb_buf[0x01] = 0xD1;
usb_buf[0x02] = 0x08;
usb_buf[0x03] = 0x0C;
for(unsigned int color_idx = 0; color_idx < colors.size(); color_idx++)
{
usb_buf[color_idx * 3 + 4] = RGBGetRValue(colors[color_idx]);
usb_buf[color_idx * 3 + 5] = RGBGetGValue(colors[color_idx]);
usb_buf[color_idx * 3 + 6] = RGBGetBValue(colors[color_idx]);
}
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
}
void ROGAllyController::UpdateDevice
(
unsigned char mode,
std::vector<RGBColor> colors,
unsigned char speed,
unsigned char direction
)
{
unsigned char usb_buf[64];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x5A;
usb_buf[0x01] = 0xB3;
usb_buf[0x02] = 0x00;
usb_buf[0x03] = mode;
if(colors.size() > 0)
{
usb_buf[0x04] = RGBGetRValue(colors[0]);
usb_buf[0x05] = RGBGetGValue(colors[0]);
usb_buf[0x06] = RGBGetBValue(colors[0]);
}
usb_buf[0x07] = speed;
usb_buf[0x08] = direction;
if(colors.size() > 1)
{
usb_buf[0x0A] = RGBGetRValue(colors[1]);
usb_buf[0x0B] = RGBGetGValue(colors[1]);
usb_buf[0x0C] = RGBGetBValue(colors[1]);
}
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x5A;
usb_buf[0x01] = 0xB5;
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
}
void ROGAllyController::SaveMode()
{
unsigned char usb_buf[64];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x5A;
usb_buf[0x01] = 0xB4;
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
}
Controllers/AsusAuraUSBController/AsusROGAllyController/AsusROGAllyController.h
+77
View File
@@ -0,0 +1,77 @@
/*---------------------------------------------------------*\
| AsusROGAllyController.h |
| |
| Driver for ASUS ROG Ally |
| |
| Adam Honse (CalcProgrammer1) 12 Jul 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <hidapi.h>
#include "RGBController.h"
enum
{
ROG_ALLY_MODE_STATIC = 0,
ROG_ALLY_MODE_BREATHING = 1,
ROG_ALLY_MODE_COLOR_CYCLE = 2,
ROG_ALLY_MODE_RAINBOW = 3,
ROG_ALLY_MODE_STROBING = 10,
ROG_ALLY_MODE_DIRECT = 0xFF,
};
enum
{
ROG_ALLY_SPEED_MIN = 0xE1,
ROG_ALLY_SPEED_MED = 0xEB,
ROG_ALLY_SPEED_MAX = 0xF5
};
enum
{
ROG_ALLY_DIRECTION_RIGHT = 0x00,
ROG_ALLY_DIRECTION_LEFT = 0x01
};
class ROGAllyController
{
public:
ROGAllyController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~ROGAllyController();
std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString();
std::string GetVersion();
void SendInitialization();
void UpdateBrightness
(
unsigned char brightness
);
void UpdateLeds
(
std::vector<RGBColor> colors
);
void UpdateDevice
(
unsigned char mode,
std::vector<RGBColor> colors,
unsigned char speed,
unsigned char direction
);
void SaveMode();
private:
hid_device* dev;
std::string location;
std::string name;
};
Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.cpp
+218
View File
@@ -0,0 +1,218 @@
/*---------------------------------------------------------*\
| RGBController_AsusROGAlly.cpp |
| |
| RGBController for ASUS ROG Ally |
| |
| Adam Honse (CalcProgrammer1) 12 Jul 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_AsusROGAlly.h"
/**------------------------------------------------------------------*\
@name Asus ROG Ally
@category Gamepad
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusROGAlly
@comment
\*-------------------------------------------------------------------*/
RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_GAMEPAD;
description = "ASUS ROG Ally Device";
version = controller->GetVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = ROG_ALLY_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Direct.color_mode = MODE_COLORS_PER_LED;
Direct.brightness_min = 0;
Direct.brightness_max = 3;
Direct.brightness = 3;
modes.push_back(Direct);
mode Static;
Static.name = "Static";
Static.value = ROG_ALLY_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(1);
Static.brightness_min = 0;
Static.brightness_max = 3;
Static.brightness = 3;
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = ROG_ALLY_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed_min = ROG_ALLY_SPEED_MIN;
Breathing.speed_max = ROG_ALLY_SPEED_MAX;
Breathing.speed = ROG_ALLY_SPEED_MED;
Breathing.colors_min = 2;
Breathing.colors_max = 2;
Breathing.colors.resize(2);
Breathing.brightness_min = 0;
Breathing.brightness_max = 3;
Breathing.brightness = 3;
modes.push_back(Breathing);
mode ColorCycle;
ColorCycle.name = "Spectrum Cycle";
ColorCycle.value = ROG_ALLY_MODE_COLOR_CYCLE;
ColorCycle.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
ColorCycle.color_mode = MODE_COLORS_RANDOM;
ColorCycle.speed_min = ROG_ALLY_SPEED_MIN;
ColorCycle.speed_max = ROG_ALLY_SPEED_MAX;
ColorCycle.speed = ROG_ALLY_SPEED_MED;
ColorCycle.brightness_min = 0;
ColorCycle.brightness_max = 3;
ColorCycle.brightness = 3;
modes.push_back(ColorCycle);
mode Rainbow;
Rainbow.name = "Rainbow Wave";
Rainbow.value = ROG_ALLY_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS;
Rainbow.color_mode = MODE_COLORS_RANDOM;
Rainbow.speed_min = ROG_ALLY_SPEED_MIN;
Rainbow.speed_max = ROG_ALLY_SPEED_MAX;
Rainbow.speed = ROG_ALLY_SPEED_MED;
Rainbow.brightness_min = 0;
Rainbow.brightness_max = 3;
Rainbow.brightness = 3;
modes.push_back(Rainbow);
mode Strobing;
Strobing.name = "Strobing";
Strobing.value = ROG_ALLY_MODE_STROBING;
Strobing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Strobing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Strobing.colors_min = 1;
Strobing.colors_max = 1;
Strobing.brightness_min = 0;
Strobing.brightness_max = 3;
Strobing.brightness = 3;
Strobing.colors.resize(1);
modes.push_back(Strobing);
SetupZones();
}
RGBController_AsusROGAlly::~RGBController_AsusROGAlly()
{
delete controller;
}
void RGBController_AsusROGAlly::SetupZones()
{
zone left_stick_zone;
left_stick_zone.name = "Left Stick";
left_stick_zone.type = ZONE_TYPE_SINGLE;
left_stick_zone.leds_min = 2;
left_stick_zone.leds_max = 2;
left_stick_zone.leds_count = 2;
left_stick_zone.matrix_map = NULL;
zones.push_back(left_stick_zone);
for(unsigned int i = 0; i < 2; i++)
{
led left_stick_led;
left_stick_led.name = "Left Stick LED " + std::to_string(i);
leds.push_back(left_stick_led);
}
zone right_stick_zone;
right_stick_zone.name = "Right Stick";
right_stick_zone.type = ZONE_TYPE_SINGLE;
right_stick_zone.leds_min = 2;
right_stick_zone.leds_max = 2;
right_stick_zone.leds_count = 2;
right_stick_zone.matrix_map = NULL;
zones.push_back(right_stick_zone);
for(unsigned int i = 0; i < 2; i++)
{
led right_stick_led;
right_stick_led.name = "Right Stick LED " + std::to_string(i);
leds.push_back(right_stick_led);
}
SetupColors();
}
void RGBController_AsusROGAlly::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AsusROGAlly::DeviceUpdateLEDs()
{
if(modes[active_mode].value == ROG_ALLY_MODE_DIRECT)
{
controller->UpdateLeds(std::vector<RGBColor>(colors));
}
}
void RGBController_AsusROGAlly::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_AsusROGAlly::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_AsusROGAlly::DeviceUpdateMode()
{
controller->UpdateBrightness(modes[active_mode].brightness);
if(modes[active_mode].value == ROG_ALLY_MODE_DIRECT)
{
DeviceUpdateLEDs();
}
else
{
unsigned int rog_ally_direction = ROG_ALLY_DIRECTION_RIGHT;
if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && (modes[active_mode].direction == MODE_DIRECTION_LEFT))
{
rog_ally_direction = ROG_ALLY_DIRECTION_LEFT;
}
controller->UpdateDevice(modes[active_mode].value, modes[active_mode].colors, modes[active_mode].speed, rog_ally_direction);
}
}
void RGBController_AsusROGAlly::DeviceSaveMode()
{
DeviceUpdateMode();
controller->SaveMode();
}
Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.h
+36
View File
@@ -0,0 +1,36 @@
/*---------------------------------------------------------*\
| RGBController_AsusROGAlly.h |
| |
| RGBController for ASUS ROG Ally |
| |
| Adam Honse (CalcProgrammer1) 12 Jul 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusROGAllyController.h"
class RGBController_AsusROGAlly : public RGBController
{
public:
RGBController_AsusROGAlly(ROGAllyController* controller_ptr);
~RGBController_AsusROGAlly();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
ROGAllyController* controller;
};
Controllers/AsusAuraUSBController/AsusROGStrixLCController/AsusROGStrixLCController.cpp
+128
View File
@@ -0,0 +1,128 @@
/*---------------------------------------------------------*\
| AsusROGStrixLCController.cpp |
| |
| Driver for ASUS Aura liquid cooler |
| |
| Chris M (Dr_No) 17 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "AsusROGStrixLCController.h"
AsusROGStrixLCController::AsusROGStrixLCController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
{
/*-----------------------------------------------------*\
| Add addressable devices |
| Manually adding device info for now |
| TODO: Implement config table accurately |
| LC120 - 1F FF 05 05 04 00 00 00 |
\*-----------------------------------------------------*/
device_info.push_back({0x00, 0x00, 4, 0, AuraDeviceType::FIXED});
}
AsusROGStrixLCController::~AsusROGStrixLCController()
{
// Device will close at AuraUSBController destructor
}
std::string AsusROGStrixLCController::GetLocation()
{
return("HID: " + location);
}
void AsusROGStrixLCController::SetMode(unsigned char /*channel*/, unsigned char /*mode*/, unsigned char /*red*/, unsigned char /*grn*/, unsigned char /*blu*/)
{
/*---------------------------------------------------------*\
| This interface is not used in this controller however is |
| required by the abstract class |
\*---------------------------------------------------------*/
}
void AsusROGStrixLCController::SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour)
{
bool needs_update = !( (current_mode == mode) && (ToRGBColor(current_red, current_green, current_blue) == colour) && (current_speed == speed) && (current_direction == direction));
if (needs_update)
{
current_mode = mode;
current_speed = speed;
current_direction = direction;
current_red = RGBGetRValue(colour);
current_green = RGBGetGValue(colour);
current_blue = RGBGetBValue(colour);
SendUpdate();
}
}
void AsusROGStrixLCController::SetChannelLEDs(unsigned char /*channel*/, RGBColor* /*colors*/, unsigned int /*num_colors*/)
{
/*---------------------------------------------------------*\
| This interface is not used in this controller however is |
| required by the abstract class |
\*---------------------------------------------------------*/
}
void AsusROGStrixLCController::SetLedsDirect(RGBColor * led_colours, uint8_t led_count)
{
uint8_t buffer[write_packet_size] = { 0xEC, 0x40, 0x00, 0xFF, led_count };
/*---------------------------------------------------------*\
| Set the colour bytes in the packet |
\*---------------------------------------------------------*/
for(uint8_t index = 0; index < led_count; index++)
{
uint8_t offset = (index * 3) + ROGSTRIXLC_GREEN_BYTE;
buffer[offset + 0] = RGBGetRValue(led_colours[index]);
buffer[offset + 1] = RGBGetGValue(led_colours[index]);
buffer[offset + 2] = RGBGetBValue(led_colours[index]);
}
/*---------------------------------------------------------*\
| These 3 bytes might be timing bytes |
\*---------------------------------------------------------*/
uint8_t offset = led_count * 3 + ROGSTRIXLC_GREEN_BYTE;
buffer[offset + 0] = 0x77;
buffer[offset + 1] = 0x10;
buffer[offset + 2] = 0xF3;
hid_write(dev, buffer, write_packet_size);
}
void AsusROGStrixLCController::GetStatus()
{
uint8_t buffer[write_packet_size] = { 0xEC, 0x01, 0x02 };
hid_write(dev, buffer, write_packet_size);
hid_read_timeout(dev, buffer, read_packet_size, ROGSTRIXLC_CONTROLLER_TIMEOUT);
current_red = buffer[ROGSTRIXLC_RED_BYTE - 1];
current_green = buffer[ROGSTRIXLC_GREEN_BYTE - 1];
current_blue = buffer[ROGSTRIXLC_BLUE_BYTE - 1];
}
void AsusROGStrixLCController::SendUpdate()
{
uint8_t buffer[write_packet_size];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(buffer, 0x00, write_packet_size);
buffer[ROGSTRIXLC_REPORTID_BYTE] = rogstrixlc_reportid;
buffer[ROGSTRIXLC_COMMAND_BYTE] = rogstrixlc_modefx;
buffer[ROGSTRIXLC_ZONE_BYTE] = 0;
buffer[ROGSTRIXLC_MODE_BYTE] = current_mode;
buffer[ROGSTRIXLC_RED_BYTE] = current_red;
buffer[ROGSTRIXLC_GREEN_BYTE] = current_green;
buffer[ROGSTRIXLC_BLUE_BYTE] = current_blue;
buffer[ROGSTRIXLC_DIRECTION_BYTE] = current_direction;
buffer[ROGSTRIXLC_SPEED_BYTE] = current_speed;
hid_write(dev, buffer, write_packet_size);
}
Controllers/AsusAuraUSBController/AsusROGStrixLCController/AsusROGStrixLCController.h
+93
View File
@@ -0,0 +1,93 @@
/*---------------------------------------------------------*\
| AsusROGStrixLCController.h |
| |
| Driver for ASUS Aura liquid cooler |
| |
| Chris M (Dr_No) 17 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <hidapi.h>
#include "RGBController.h"
#include "AsusAuraUSBController.h"
#define ROGSTRIXLC_CONTROLLER_TIMEOUT 250
#define HID_MAX_STR 255
#define ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN 0
#define ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX 255
enum
{
ROGSTRIXLC_CONTROLLER_MODE_DIRECT = 0xFF, //Direct Led Control - Independently set LEDs in zone
ROGSTRIXLC_CONTROLLER_MODE_STATIC = 0x01, //Static Mode - Set entire zone to a single color.
ROGSTRIXLC_CONTROLLER_MODE_BREATHING = 0x02, //Breathing Mode - Fades between fully off and fully on.
ROGSTRIXLC_CONTROLLER_MODE_FLASHING = 0x03, //Flashing Mode - Abruptly changing between fully off and fully on.
ROGSTRIXLC_CONTROLLER_MODE_SPECTRUM = 0x04, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device
ROGSTRIXLC_CONTROLLER_MODE_RAINBOW = 0x05, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs
ROGSTRIXLC_CONTROLLER_MODE_FLASHANDDASH = 0x0A, //Flash n Dash - Flash twice and then flash in direction
};
enum AsusAuraStrixLC_PacketMap
{
ROGSTRIXLC_REPORTID_BYTE = 0,
ROGSTRIXLC_COMMAND_BYTE = 1,
ROGSTRIXLC_ZONE_BYTE = 2,
ROGSTRIXLC_MODE_BYTE = 3,
ROGSTRIXLC_RED_BYTE = 4,
ROGSTRIXLC_GREEN_BYTE = 5,
ROGSTRIXLC_BLUE_BYTE = 6,
ROGSTRIXLC_DIRECTION_BYTE = 7,
ROGSTRIXLC_SPEED_BYTE = 8,
};
enum
{
ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST = 0x04, // Slowest speed
ROGSTRIXLC_CONTROLLER_SPEED_SLOW = 0x03, // Slower speed
ROGSTRIXLC_CONTROLLER_SPEED_NORMAL = 0x02, // Normal speed
ROGSTRIXLC_CONTROLLER_SPEED_FAST = 0x01, // Fast speed
ROGSTRIXLC_CONTROLLER_SPEED_FASTEST = 0x00, // Fastest speed
};
class AsusROGStrixLCController : public AuraUSBController
{
public:
AsusROGStrixLCController(hid_device* dev_handle, const char* path, std::string dev_name);
~AsusROGStrixLCController();
std::string GetLocation();
void SetChannelLEDs(unsigned char channel, RGBColor *colors, unsigned int num_colors);
void SetLedsDirect(RGBColor * led_colours, uint8_t led_count);
void SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu);
void SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour);
private:
static const uint8_t read_packet_size = 64;
static const uint8_t write_packet_size = read_packet_size + 1;
static const uint8_t rogstrixlc_modefx = 0x3B;
static const uint8_t rogstrixlc_direct = 0x40;
static const uint8_t rogstrixlc_reportid = 0xEC;
std::string location;
uint8_t zone_index;
uint8_t current_mode;
uint8_t current_speed;
uint8_t current_red;
uint8_t current_green;
uint8_t current_blue;
uint8_t current_direction;
void GetStatus();
void SendUpdate();
void SendEffect(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu);
void SendDirectApply(unsigned char channel);
};
Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.cpp
+221
View File
@@ -0,0 +1,221 @@
/*---------------------------------------------------------*\
| RGBController_AsusROGStrixLC.cpp |
| |
| RGBController for ASUS Aura liquid cooler |
| |
| Chris M (Dr_No) 17 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBControllerKeyNames.h"
#include "RGBController_AsusROGStrixLC.h"
/**------------------------------------------------------------------*\
@name Asus ROG Strix Liquid Cooler
@category Cooler
@type USB
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraUSBROGStrixLC
@comment
\*-------------------------------------------------------------------*/
RGBController_AsusROGStrixLC::RGBController_AsusROGStrixLC(AsusROGStrixLCController *controller_ptr)
{
controller = controller_ptr;
uint8_t speed = ROGSTRIXLC_CONTROLLER_SPEED_NORMAL;
name = controller->GetDeviceName();
vendor = "ASUS";
type = DEVICE_TYPE_COOLER;
description = "ASUS Liquid Cooler including 120mm, 140mm, 240mm, 280mm and 360mm radiators.";
version = KEY_EN_UNUSED;
serial = KEY_EN_UNUSED;
location = controller->GetLocation();
mode Direct;
Direct.name = "Direct";
Direct.value = ROGSTRIXLC_CONTROLLER_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 = ROGSTRIXLC_CONTROLLER_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(Static.colors_max);
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = ROGSTRIXLC_CONTROLLER_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(Breathing.colors_max);
Breathing.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
Breathing.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Breathing.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Breathing.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
Breathing.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed = speed;
modes.push_back(Breathing);
mode Flashing;
Flashing.name = "Flashing";
Flashing.value = ROGSTRIXLC_CONTROLLER_MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Flashing.colors_min = 1;
Flashing.colors_max = 1;
Flashing.colors.resize(Flashing.colors_max);
Flashing.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
Flashing.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Flashing.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Flashing.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
Flashing.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Flashing.speed = speed;
modes.push_back(Flashing);
mode Spectrum;
Spectrum.name = "Spectrum";
Spectrum.value = ROGSTRIXLC_CONTROLLER_MODE_SPECTRUM;
Spectrum.flags = MODE_FLAG_HAS_SPEED;
Spectrum.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
Spectrum.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Spectrum.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Spectrum.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
Spectrum.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
Spectrum.color_mode = MODE_COLORS_NONE;
Spectrum.speed = speed;
modes.push_back(Spectrum);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = ROGSTRIXLC_CONTROLLER_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Rainbow.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
Rainbow.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Rainbow.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Rainbow.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
Rainbow.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.speed = speed;
modes.push_back(Rainbow);
mode FlashAndDash;
FlashAndDash.name = "Flash and Dash";
FlashAndDash.value = ROGSTRIXLC_CONTROLLER_MODE_FLASHANDDASH;
FlashAndDash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
FlashAndDash.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
FlashAndDash.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
FlashAndDash.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
FlashAndDash.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
FlashAndDash.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
FlashAndDash.color_mode = MODE_COLORS_NONE;
FlashAndDash.speed = speed;
modes.push_back(FlashAndDash);
SetupZones();
}
RGBController_AsusROGStrixLC::~RGBController_AsusROGStrixLC()
{
delete controller;
}
void RGBController_AsusROGStrixLC::SetupZones()
{
/*-------------------------------------------------*\
| Set up zones |
\*-------------------------------------------------*/
LOG_DEBUG("[%s] - Get channel count: %i", name.c_str(), controller->GetChannelCount());
zones.resize(controller->GetChannelCount());
LOG_DEBUG("[%s] - Creating Zones and LEDs", name.c_str());
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx];
LOG_INFO("[%s] %s Zone %i - Header Count %i LED Count %i FX %02X Direct %02X", name.c_str(),
((device_info.device_type == AuraDeviceType::FIXED) ? "Fixed" : "Addressable"),
zone_idx, device_info.num_headers, device_info.num_leds, device_info.effect_channel, device_info.direct_channel);
zones[zone_idx].name = name + " Zone ";
zones[zone_idx].name.append(std::to_string(zone_idx));
zones[zone_idx].type = ZONE_TYPE_LINEAR;
zones[zone_idx].leds_min = device_info.num_leds;
zones[zone_idx].leds_max = device_info.num_leds;
zones[zone_idx].leds_count = device_info.num_leds;
for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
{
led new_led;
new_led.name = zones[zone_idx].name;
new_led.name.append(" LED " + std::to_string(lp_idx));
new_led.value = lp_idx;
leds.push_back(new_led);
}
}
LOG_DEBUG("[%s] - Device zones and LEDs set", name.c_str());
SetupColors();
}
void RGBController_AsusROGStrixLC::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AsusROGStrixLC::DeviceUpdateLEDs()
{
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
UpdateZoneLEDs(zone_idx);
}
}
void RGBController_AsusROGStrixLC::UpdateZoneLEDs(int zone)
{
controller->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
}
void RGBController_AsusROGStrixLC::UpdateSingleLED(int led)
{
UpdateZoneLEDs(GetLED_Zone(led));
}
void RGBController_AsusROGStrixLC::DeviceUpdateMode()
{
RGBColor colour = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
controller->SetMode( modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, colour );
}
int RGBController_AsusROGStrixLC::GetLED_Zone(int led_idx)
{
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
int zone_start = zones[zone_idx].start_idx;
int zone_end = zone_start + zones[zone_idx].leds_count - 1;
if(zone_start <= led_idx && zone_end >= led_idx)
{
return(zone_idx);
}
}
return -1;
}
Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.h
+38
View File
@@ -0,0 +1,38 @@
/*---------------------------------------------------------*\
| RGBController_AsusROGStrixLC.h |
| |
| RGBController for ASUS Aura liquid cooler |
| |
| Chris M (Dr_No) 17 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <vector>
#include "LogManager.h"
#include "RGBController.h"
#include "AsusROGStrixLCController.h"
class RGBController_AsusROGStrixLC : public RGBController
{
public:
RGBController_AsusROGStrixLC(AsusROGStrixLCController* controller_ptr);
~RGBController_AsusROGStrixLC();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
int GetDeviceMode();
int GetLED_Zone(int led_idx);
AsusROGStrixLCController* controller;
};