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

Store name in AsusAuraUSBControllers to avoid setting it in detectors

Browse source
This commit is contained in:
Adam Honse 2025-08-16 18:26:09 -05:00
parent a0726dc065
commit c82a6052a2
40 changed files with 662 additions and 582 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/AsusAuraHeadsetStandController.cpp
View file

@ -13,10 +13,11 @@
#include "AsusAuraHeadsetStandController.h" #include "AsusAuraHeadsetStandController.h"
#include "StringUtils.h" #include "StringUtils.h"
AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path) AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path, std::string dev_name)
{ {
dev = dev_handle; dev = dev_handle;
location = path; location = path;
name = dev_name;
} }
AuraHeadsetStandController::~AuraHeadsetStandController() AuraHeadsetStandController::~AuraHeadsetStandController()
@ -29,6 +30,11 @@ std::string AuraHeadsetStandController::GetDeviceLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string AuraHeadsetStandController::GetName()
{
return(name);
}
std::string AuraHeadsetStandController::GetSerialString() std::string AuraHeadsetStandController::GetSerialString()
{ {
wchar_t serial_string[128]; wchar_t serial_string[128];

36
Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/AsusAuraHeadsetStandController.h
View file

@ -33,31 +33,33 @@ enum
class AuraHeadsetStandController class AuraHeadsetStandController
{ {
public: public:
AuraHeadsetStandController(hid_device* dev_handle, const char* path); AuraHeadsetStandController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~AuraHeadsetStandController(); virtual ~AuraHeadsetStandController();
std::string GetDeviceLocation(); std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString(); std::string GetSerialString();
std::string GetVersion(); std::string GetVersion();
void UpdateLeds void UpdateLeds
( (
std::vector<RGBColor> colors std::vector<RGBColor> colors
); );
void UpdateDevice void UpdateDevice
( (
unsigned char mode, unsigned char mode,
unsigned char red, unsigned char red,
unsigned char grn, unsigned char grn,
unsigned char blu, unsigned char blu,
unsigned char speed, unsigned char speed,
unsigned char brightness unsigned char brightness
); );
void SaveMode(); void SaveMode();
private: private:
hid_device* dev; hid_device* dev;
std::string location; std::string location;
std::string name;
}; };

122
Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/RGBController_AsusAuraHeadsetStand.cpp
View file

@ -24,88 +24,88 @@
RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandController* controller_ptr) RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandController* controller_ptr)
{ {
controller = controller_ptr; controller = controller_ptr;
name = "ASUS Aura Headset Stand"; name = controller->GetName();
vendor = "ASUS"; vendor = "ASUS";
type = DEVICE_TYPE_HEADSET_STAND; type = DEVICE_TYPE_HEADSET_STAND;
description = "ASUS Aura Headset Stand Device"; description = "ASUS Aura Headset Stand Device";
version = controller->GetVersion(); version = controller->GetVersion();
location = controller->GetDeviceLocation(); location = controller->GetDeviceLocation();
serial = controller->GetSerialString(); serial = controller->GetSerialString();
mode Direct; mode Direct;
Direct.name = "Direct"; Direct.name = "Direct";
Direct.value = AURA_HEADSET_STAND_MODE_DIRECT; Direct.value = AURA_HEADSET_STAND_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED; Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct); modes.push_back(Direct);
mode Static; mode Static;
Static.name = "Static"; Static.name = "Static";
Static.value = AURA_HEADSET_STAND_MODE_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.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Static.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN; Static.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
Static.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX; Static.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
Static.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT; Static.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC; Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_min = 1; Static.colors_min = 1;
Static.colors_max = 1; Static.colors_max = 1;
Static.colors.resize(1); Static.colors.resize(1);
modes.push_back(Static); modes.push_back(Static);
mode Breathing; mode Breathing;
Breathing.name = "Breathing"; Breathing.name = "Breathing";
Breathing.value = AURA_HEADSET_STAND_MODE_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.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.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed_min = AURA_HEADSETSTAND_SPEED_MIN; Breathing.speed_min = AURA_HEADSETSTAND_SPEED_MIN;
Breathing.speed_max = AURA_HEADSETSTAND_SPEED_MAX; Breathing.speed_max = AURA_HEADSETSTAND_SPEED_MAX;
Breathing.speed = AURA_HEADSETSTAND_SPEED_DEFAULT; Breathing.speed = AURA_HEADSETSTAND_SPEED_DEFAULT;
Breathing.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN; Breathing.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
Breathing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX; Breathing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
Breathing.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT; Breathing.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
Breathing.colors_min = 1; Breathing.colors_min = 1;
Breathing.colors_max = 1; Breathing.colors_max = 1;
Breathing.colors.resize(1); Breathing.colors.resize(1);
modes.push_back(Breathing); modes.push_back(Breathing);
mode Strobing; mode Strobing;
Strobing.name = "Flashing"; Strobing.name = "Flashing";
Strobing.value = AURA_HEADSET_STAND_MODE_STROBING; Strobing.value = AURA_HEADSET_STAND_MODE_STROBING;
Strobing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; 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_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
Strobing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX; Strobing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
Strobing.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT; Strobing.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
Strobing.color_mode = MODE_COLORS_MODE_SPECIFIC; Strobing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Strobing.colors_min = 1; Strobing.colors_min = 1;
Strobing.colors_max = 1; Strobing.colors_max = 1;
Strobing.colors.resize(1); Strobing.colors.resize(1);
modes.push_back(Strobing); modes.push_back(Strobing);
mode SpectrumCycle; mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle"; SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = AURA_HEADSET_STAND_MODE_COLOR_CYCLE; SpectrumCycle.value = AURA_HEADSET_STAND_MODE_COLOR_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
SpectrumCycle.speed_min = AURA_HEADSETSTAND_SPEED_MIN; SpectrumCycle.speed_min = AURA_HEADSETSTAND_SPEED_MIN;
SpectrumCycle.speed_max = AURA_HEADSETSTAND_SPEED_MAX; SpectrumCycle.speed_max = AURA_HEADSETSTAND_SPEED_MAX;
SpectrumCycle.speed = AURA_HEADSETSTAND_SPEED_DEFAULT; SpectrumCycle.speed = AURA_HEADSETSTAND_SPEED_DEFAULT;
SpectrumCycle.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN; SpectrumCycle.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
SpectrumCycle.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX; SpectrumCycle.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
SpectrumCycle.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT; SpectrumCycle.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
SpectrumCycle.color_mode = MODE_COLORS_NONE; SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle); modes.push_back(SpectrumCycle);
mode Rainbow; mode Rainbow;
Rainbow.name = "Rainbow Wave"; Rainbow.name = "Rainbow Wave";
Rainbow.value = AURA_HEADSET_STAND_MODE_RAINBOW; Rainbow.value = AURA_HEADSET_STAND_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Rainbow.speed_min = AURA_HEADSETSTAND_SPEED_MIN; Rainbow.speed_min = AURA_HEADSETSTAND_SPEED_MIN;
Rainbow.speed_max = AURA_HEADSETSTAND_SPEED_MAX; Rainbow.speed_max = AURA_HEADSETSTAND_SPEED_MAX;
Rainbow.speed = AURA_HEADSETSTAND_SPEED_DEFAULT; Rainbow.speed = AURA_HEADSETSTAND_SPEED_DEFAULT;
Rainbow.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN; Rainbow.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
Rainbow.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX; Rainbow.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
Rainbow.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT; Rainbow.brightness = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
modes.push_back(Rainbow); modes.push_back(Rainbow);
SetupZones(); SetupZones();
} }

8
Controllers/AsusAuraUSBController/AsusAuraKeyboardController/AsusAuraKeyboardController.cpp
View file

@ -13,10 +13,11 @@
#include "AsusAuraKeyboardController.h" #include "AsusAuraKeyboardController.h"
#include "StringUtils.h" #include "StringUtils.h"
AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path) AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name)
{ {
dev = dev_handle; dev = dev_handle;
location = path; location = path;
name = dev_name;
} }
AuraKeyboardController::~AuraKeyboardController() AuraKeyboardController::~AuraKeyboardController()
@ -29,6 +30,11 @@ std::string AuraKeyboardController::GetDeviceLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string AuraKeyboardController::GetNameString()
{
return(name);
}
std::string AuraKeyboardController::GetSerialString() std::string AuraKeyboardController::GetSerialString()
{ {
wchar_t serial_string[128]; wchar_t serial_string[128];

18
Controllers/AsusAuraUSBController/AsusAuraKeyboardController/AsusAuraKeyboardController.h
View file

@ -19,19 +19,21 @@
class AuraKeyboardController class AuraKeyboardController
{ {
public: public:
AuraKeyboardController(hid_device* dev_handle, const char* path); AuraKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~AuraKeyboardController(); virtual ~AuraKeyboardController();
std::string GetDeviceLocation(); std::string GetDeviceLocation();
std::string GetNameString();
std::string GetSerialString(); std::string GetSerialString();
void SendDirect void SendDirect
( (
unsigned char frame_count, unsigned char frame_count,
unsigned char * frame_data unsigned char * frame_data
); );
private: private:
hid_device* dev; hid_device* dev;
std::string location; std::string location;
std::string name;
}; };

24
Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.cpp
View file

@ -358,21 +358,21 @@ static const std::vector<aura_keyboard_led> default_65pct_led_names =
RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* controller_ptr, AuraKeyboardMappingLayoutType keyboard_layout) RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* controller_ptr, AuraKeyboardMappingLayoutType keyboard_layout)
{ {
controller = controller_ptr; controller = controller_ptr;
layout = keyboard_layout; layout = keyboard_layout;
name = "ASUS Aura Keyboard"; name = controller->GetNameString();
vendor = "ASUS"; vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD; type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Aura Keyboard Device"; description = "ASUS Aura Keyboard Device";
location = controller->GetDeviceLocation(); location = controller->GetDeviceLocation();
serial = controller->GetSerialString(); serial = controller->GetSerialString();
mode Direct; mode Direct;
Direct.name = "Direct"; Direct.name = "Direct";
Direct.value = 0; Direct.value = 0;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED; Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct); modes.push_back(Direct);
SetupZones(); SetupZones();

8
Controllers/AsusAuraUSBController/AsusAuraMonitorController/AsusAuraMonitorController.cpp
View file

@ -14,11 +14,12 @@
#include "LogManager.h" #include "LogManager.h"
#include "StringUtils.h" #include "StringUtils.h"
AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid) AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
{ {
dev = dev_handle; dev = dev_handle;
location = path; location = path;
device_pid = pid; device_pid = pid;
name = dev_name;
} }
AuraMonitorController::~AuraMonitorController() AuraMonitorController::~AuraMonitorController()
@ -31,6 +32,11 @@ std::string AuraMonitorController::GetDeviceLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string AuraMonitorController::GetNameString()
{
return(name);
}
std::string AuraMonitorController::GetSerialString() std::string AuraMonitorController::GetSerialString()
{ {
wchar_t serial_string[128]; wchar_t serial_string[128];

16
Controllers/AsusAuraUSBController/AsusAuraMonitorController/AsusAuraMonitorController.h
View file

@ -27,19 +27,21 @@ enum
class AuraMonitorController class AuraMonitorController
{ {
public: public:
AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid); AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
virtual ~AuraMonitorController(); virtual ~AuraMonitorController();
std::string GetDeviceLocation(); std::string GetDeviceLocation();
std::string GetNameString();
std::string GetSerialString(); std::string GetSerialString();
void BeginUpdate(); void BeginUpdate();
void UpdateLed(int led, unsigned char red, unsigned char green, unsigned char blue); void UpdateLed(int led, unsigned char red, unsigned char green, unsigned char blue);
void ApplyChanges(); void ApplyChanges();
uint16_t device_pid; uint16_t device_pid;
private: private:
hid_device* dev; hid_device* dev;
std::string location; std::string location;
std::string name;
}; };

22
Controllers/AsusAuraUSBController/AsusAuraMonitorController/RGBController_AsusAuraMonitor.cpp
View file

@ -24,20 +24,20 @@
RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* controller_ptr) RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* controller_ptr)
{ {
controller = controller_ptr; controller = controller_ptr;
name = "ASUS Aura Monitor"; name = controller->GetNameString();
vendor = "ASUS"; vendor = "ASUS";
type = DEVICE_TYPE_MONITOR; type = DEVICE_TYPE_MONITOR;
description = "ASUS Aura Monitor Device"; description = "ASUS Aura Monitor Device";
location = controller->GetDeviceLocation(); location = controller->GetDeviceLocation();
serial = controller->GetSerialString(); serial = controller->GetSerialString();
mode Direct; mode Direct;
Direct.name = "Direct"; Direct.name = "Direct";
Direct.value = 0; Direct.value = 0;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED; Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct); modes.push_back(Direct);
SetupZones(); SetupZones();

54
Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseController.cpp
View file

@ -15,11 +15,12 @@
#define HID_MAX_STR 255 #define HID_MAX_STR 255
AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid) AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
{ {
dev = dev_handle; dev = dev_handle;
location = path; location = path;
device_pid = pid; device_pid = pid;
name = dev_name;
} }
AuraMouseController::~AuraMouseController() AuraMouseController::~AuraMouseController()
@ -32,30 +33,9 @@ std::string AuraMouseController::GetDeviceLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string AuraMouseController::CleanSerial(const std::wstring& wstr) std::string AuraMouseController::GetName()
{ {
/*---------------------------------------------------------------*\ return(name);
| 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);
} }
std::string AuraMouseController::GetSerialString() std::string AuraMouseController::GetSerialString()
@ -125,6 +105,32 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
return str; 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() void AuraMouseController::SaveMode()
{ {
unsigned char usb_save_buf[ASUS_AURA_MOUSE_PACKET_SIZE] = { 0x00, 0x50, 0x03 }; unsigned char usb_save_buf[ASUS_AURA_MOUSE_PACKET_SIZE] = { 0x00, 0x50, 0x03 };

47
Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseController.h
View file

@ -21,35 +21,38 @@
class AuraMouseController class AuraMouseController
{ {
public: public:
AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid); AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
virtual ~AuraMouseController(); virtual ~AuraMouseController();
std::string GetDeviceLocation(); std::string GetDeviceLocation();
std::string CleanSerial(const std::wstring& wstr); std::string GetName();
std::string GetSerialString(); std::string GetSerialString();
std::string GetVersion(bool wireless, int protocol); std::string GetVersion(bool wireless, int protocol);
void SaveMode(); std::string CleanSerial(const std::wstring& wstr);
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; 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: private:
hid_device* dev; hid_device* dev;
std::string location; std::string location;
std::string name;
}; };

22
Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.cpp
View file

@ -33,19 +33,19 @@ static std::string aura_mouse_zone_names[5]
RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller_ptr) RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller_ptr)
{ {
controller = controller_ptr; controller = controller_ptr;
pid = controller->device_pid; pid = controller->device_pid;
name = "ASUS Aura Mouse"; name = controller->GetName();
vendor = "ASUS"; vendor = "ASUS";
type = DEVICE_TYPE_MOUSE; type = DEVICE_TYPE_MOUSE;
description = "ASUS Aura Mouse Device"; description = "ASUS Aura Mouse Device";
version = controller->GetVersion(aura_mouse_devices[pid].wireless, aura_mouse_devices[pid].version_protocol); version = controller->GetVersion(aura_mouse_devices[pid].wireless, aura_mouse_devices[pid].version_protocol);
location = controller->GetDeviceLocation(); location = controller->GetDeviceLocation();
serial = controller->GetSerialString(); serial = controller->GetSerialString();
std::vector<uint8_t> mm = aura_mouse_devices[pid].mouse_modes; std::vector<uint8_t> mm = aura_mouse_devices[pid].mouse_modes;
if(aura_mouse_devices[pid].direct) if(aura_mouse_devices[pid].direct)
{ {
@ -57,7 +57,7 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
modes.push_back(Direct); modes.push_back(Direct);
} }
int mode_value = 0; int mode_value = 0;
for(std::vector<uint8_t>::iterator it = mm.begin(); it != mm.end(); it++) for(std::vector<uint8_t>::iterator it = mm.begin(); it != mm.end(); it++)
{ {

8
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/AsusAuraMouseGen1Controller.cpp
View file

@ -15,11 +15,12 @@
#include "AsusAuraMouseGen1Controller.h" #include "AsusAuraMouseGen1Controller.h"
#include "StringUtils.h" #include "StringUtils.h"
AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid) AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
{ {
dev = dev_handle; dev = dev_handle;
location = path; location = path;
device_pid = pid; device_pid = pid;
name = dev_name;
} }
AsusAuraMouseGen1Controller::~AsusAuraMouseGen1Controller() AsusAuraMouseGen1Controller::~AsusAuraMouseGen1Controller()
@ -32,6 +33,11 @@ std::string AsusAuraMouseGen1Controller::GetDeviceLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string AsusAuraMouseGen1Controller::GetName()
{
return(name);
}
std::string AsusAuraMouseGen1Controller::GetSerialString() std::string AsusAuraMouseGen1Controller::GetSerialString()
{ {
wchar_t serial_string[HID_MAX_STR]; wchar_t serial_string[HID_MAX_STR];

40
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/AsusAuraMouseGen1Controller.h
View file

@ -21,33 +21,37 @@
class AsusAuraMouseGen1Controller class AsusAuraMouseGen1Controller
{ {
public: public:
AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid); AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
virtual ~AsusAuraMouseGen1Controller(); virtual ~AsusAuraMouseGen1Controller();
std::string GetDeviceLocation(); std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString(); std::string GetSerialString();
std::string GetVersion(); std::string GetVersion();
int GetActiveProfile();
void SendUpdate int GetActiveProfile();
(
unsigned char key,
unsigned char value
);
void UpdateProfile void SendUpdate
( (
unsigned char key, unsigned char key,
unsigned char profile, unsigned char value
unsigned char value );
);
void SendDirectSpatha(std::vector<RGBColor> colors);
void ResetToSavedLighting(); void UpdateProfile
(
unsigned char key,
unsigned char profile,
unsigned char value
);
uint16_t device_pid; void SendDirectSpatha(std::vector<RGBColor> colors);
void ResetToSavedLighting();
uint16_t device_pid;
private: private:
hid_device* dev; hid_device* dev;
std::string location; std::string location;
std::string name;
}; };

2
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.cpp
View file

@ -30,7 +30,7 @@ RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Contro
{ {
controller = controller_ptr; controller = controller_ptr;
name = "ASUS ROG Spatha"; name = controller->GetName();
vendor = "ASUS"; vendor = "ASUS";
type = DEVICE_TYPE_MOUSE; type = DEVICE_TYPE_MOUSE;
description = "ASUS Aura Mouse Device"; description = "ASUS Aura Mouse Device";

2
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.cpp
View file

@ -26,7 +26,7 @@ RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouse
{ {
controller = controller_ptr; controller = controller_ptr;
name = "ASUS ROG Strix Evolve"; name = controller->GetName();
vendor = "ASUS"; vendor = "ASUS";
type = DEVICE_TYPE_MOUSE; type = DEVICE_TYPE_MOUSE;
description = "ASUS Aura Mouse Device"; description = "ASUS Aura Mouse Device";

8
Controllers/AsusAuraUSBController/AsusAuraMousematController/AsusAuraMousematController.cpp
View file

@ -13,10 +13,11 @@
#include "AsusAuraMousematController.h" #include "AsusAuraMousematController.h"
#include "StringUtils.h" #include "StringUtils.h"
AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path) AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path, std::string dev_name)
{ {
dev = dev_handle; dev = dev_handle;
location = path; location = path;
name = dev_name;
} }
AuraMousematController::~AuraMousematController() AuraMousematController::~AuraMousematController()
@ -29,6 +30,11 @@ std::string AuraMousematController::GetDeviceLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string AuraMousematController::GetName()
{
return(name);
}
std::string AuraMousematController::GetSerialString() std::string AuraMousematController::GetSerialString()
{ {
wchar_t serial_string[128]; wchar_t serial_string[128];

34
Controllers/AsusAuraUSBController/AsusAuraMousematController/AsusAuraMousematController.h
View file

@ -31,30 +31,32 @@ enum
class AuraMousematController class AuraMousematController
{ {
public: public:
AuraMousematController(hid_device* dev_handle, const char* path); AuraMousematController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~AuraMousematController(); virtual ~AuraMousematController();
std::string GetDeviceLocation(); std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString(); std::string GetSerialString();
std::string GetVersion(); std::string GetVersion();
void UpdateLeds void UpdateLeds
( (
std::vector<RGBColor> colors std::vector<RGBColor> colors
); );
void UpdateDevice void UpdateDevice
( (
unsigned char mode, unsigned char mode,
std::vector<RGBColor> colors, std::vector<RGBColor> colors,
unsigned char speed, unsigned char speed,
unsigned char brightness, unsigned char brightness,
unsigned char pattern unsigned char pattern
); );
void SaveMode(); void SaveMode();
private: private:
hid_device* dev; hid_device* dev;
std::string location; std::string location;
std::string name;
}; };

2
Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.cpp
View file

@ -26,7 +26,7 @@ RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* c
{ {
controller = controller_ptr; controller = controller_ptr;
name = "ASUS Aura Mousemat"; name = controller->GetName();
vendor = "ASUS"; vendor = "ASUS";
type = DEVICE_TYPE_MOUSEMAT; type = DEVICE_TYPE_MOUSEMAT;
description = "ASUS Aura Mousemat Device"; description = "ASUS Aura Mousemat Device";

2
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.cpp
View file

@ -12,7 +12,7 @@
#include "AsusAuraRyuoAIOController.h" #include "AsusAuraRyuoAIOController.h"
AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path) AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
{ {
/*-----------------------------------------------------*\ /*-----------------------------------------------------*\
| Add addressable devices | | Add addressable devices |

2
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.h
View file

@ -60,7 +60,7 @@ public:
SPEED_FASTEST = 0x00, // Fastest speed SPEED_FASTEST = 0x00, // Fastest speed
}; };
AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path); AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path, std::string dev_name);
~AsusAuraRyuoAIOController(); ~AsusAuraRyuoAIOController();
std::string GetLocation(); std::string GetLocation();

2
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.cpp
View file

@ -29,7 +29,7 @@ RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOCont
controller = controller_ptr; controller = controller_ptr;
uint8_t speed = controller->SPEED_NORMAL; uint8_t speed = controller->SPEED_NORMAL;
name = "ROG Ryuo AIO"; name = controller->GetDeviceName();
vendor = "ASUS"; vendor = "ASUS";
type = DEVICE_TYPE_COOLER; type = DEVICE_TYPE_COOLER;
description = "ASUS Liquid Cooler with 120mm and 240mm radiators."; description = "ASUS Liquid Cooler with 120mm and 240mm radiators.";

8
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/AsusAuraTUFKeyboardController.cpp
View file

@ -21,10 +21,11 @@
#define HID_MAX_STR 128 #define HID_MAX_STR 128
AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version) AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version, std::string dev_name)
{ {
dev = dev_handle; dev = dev_handle;
location = path; location = path;
name = dev_name;
device_pid = pid; device_pid = pid;
rev_version = version; rev_version = version;
@ -41,6 +42,11 @@ std::string AuraTUFKeyboardController::GetDeviceLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string AuraTUFKeyboardController::GetName()
{
return(name);
}
std::string AuraTUFKeyboardController::GetSerialString() std::string AuraTUFKeyboardController::GetSerialString()
{ {
wchar_t serial_string[HID_MAX_STR]; wchar_t serial_string[HID_MAX_STR];

112
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/AsusAuraTUFKeyboardController.h
View file

@ -67,77 +67,81 @@ struct led_color
class AuraTUFKeyboardController class AuraTUFKeyboardController
{ {
public: public:
AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version); AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version, std::string dev_name);
~AuraTUFKeyboardController(); ~AuraTUFKeyboardController();
std::string GetDeviceLocation(); std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString(); std::string GetSerialString();
std::string GetVersion(); std::string GetVersion();
int GetLayout(); int GetLayout();
int GetNumpadLocation(); int GetNumpadLocation();
void SaveMode(); void SaveMode();
void AllowRemoteControl(unsigned char type); void AllowRemoteControl(unsigned char type);
void UpdateSingleLed void UpdateSingleLed
( (
int led, int led,
unsigned char red, unsigned char red,
unsigned char green, unsigned char green,
unsigned char blue unsigned char blue
); );
void UpdateLeds void UpdateLeds
( (
std::vector<led_color> colors std::vector<led_color> colors
); );
void UpdateK1Wave void UpdateK1Wave
( (
std::vector<RGBColor> colors, std::vector<RGBColor> colors,
unsigned char direction, unsigned char direction,
unsigned char speed, unsigned char speed,
unsigned char brightness unsigned char brightness
); );
void UpdateScopeIIRainbowRipple void UpdateScopeIIRainbowRipple
( (
unsigned char mode, unsigned char mode,
std::vector<RGBColor> colors, std::vector<RGBColor> colors,
unsigned char direction, unsigned char direction,
unsigned char color_mode, unsigned char color_mode,
unsigned char speed, unsigned char speed,
unsigned char brightness unsigned char brightness
); );
void UpdateScopeIIQuicksand void UpdateScopeIIQuicksand
( (
std::vector<RGBColor> colors, std::vector<RGBColor> colors,
unsigned char direction, unsigned char direction,
unsigned char color_mode, unsigned char color_mode,
unsigned char speed, unsigned char speed,
unsigned char brightness unsigned char brightness
); );
void UpdateDevice void UpdateDevice
( (
unsigned char mode, unsigned char mode,
std::vector<RGBColor> colors, std::vector<RGBColor> colors,
unsigned char direction, unsigned char direction,
unsigned char color_mode, unsigned char color_mode,
unsigned char speed, unsigned char speed,
unsigned char brightness unsigned char brightness
); );
void UpdateQuicksandColors(std::vector<RGBColor> colors);
void UpdateMode(unsigned char mode);
void AwaitResponse(int ms);
void ClearResponses();
uint16_t device_pid; void UpdateQuicksandColors(std::vector<RGBColor> colors);
bool is_per_led_keyboard; void UpdateMode(unsigned char mode);
void AwaitResponse(int ms);
void ClearResponses();
uint16_t device_pid;
bool is_per_led_keyboard;
private: private:
hid_device* dev; hid_device* dev;
std::string location; std::string location;
unsigned short rev_version; std::string name;
unsigned short rev_version;
}; };

302
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.cpp
View file

@ -26,19 +26,19 @@
RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr) RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr)
{ {
controller = controller_ptr; controller = controller_ptr;
pid = controller->device_pid; pid = controller->device_pid;
if(pid != AURA_ROG_CLAYMORE_PID) if(pid != AURA_ROG_CLAYMORE_PID)
{ {
name = "ASUS Aura Keyboard"; name = controller->GetName();
vendor = "ASUS"; vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD; type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Aura Keyboard Device"; description = "ASUS Aura Keyboard Device";
version = controller->GetVersion(); version = controller->GetVersion();
location = controller->GetDeviceLocation(); location = controller->GetDeviceLocation();
serial = controller->GetSerialString(); serial = controller->GetSerialString();
unsigned char AURA_KEYBOARD_SPEED_MIN = 0; unsigned char AURA_KEYBOARD_SPEED_MIN = 0;
unsigned char AURA_KEYBOARD_SPEED_MAX = 0; unsigned char AURA_KEYBOARD_SPEED_MAX = 0;
@ -51,6 +51,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
AURA_KEYBOARD_SPEED_MAX = 2; AURA_KEYBOARD_SPEED_MAX = 2;
AURA_KEYBOARD_SPEED_DEFAULT = 1; AURA_KEYBOARD_SPEED_DEFAULT = 1;
break; break;
case AURA_ROG_STRIX_FLARE_PID: case AURA_ROG_STRIX_FLARE_PID:
case AURA_ROG_STRIX_FLARE_PNK_LTD_PID: case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
case AURA_ROG_STRIX_FLARE_COD_BO4_PID: case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
@ -60,6 +61,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
AURA_KEYBOARD_SPEED_MAX = 0; AURA_KEYBOARD_SPEED_MAX = 0;
AURA_KEYBOARD_SPEED_DEFAULT = 8; AURA_KEYBOARD_SPEED_DEFAULT = 8;
break; break;
case AURA_ROG_AZOTH_USB_PID: case AURA_ROG_AZOTH_USB_PID:
case AURA_ROG_AZOTH_2_4_PID: case AURA_ROG_AZOTH_2_4_PID:
case AURA_ROG_FALCHION_WIRED_PID: case AURA_ROG_FALCHION_WIRED_PID:
@ -79,77 +81,83 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
AURA_KEYBOARD_SPEED_MAX = 0; AURA_KEYBOARD_SPEED_MAX = 0;
AURA_KEYBOARD_SPEED_DEFAULT = 30; AURA_KEYBOARD_SPEED_DEFAULT = 30;
break; break;
default: default:
AURA_KEYBOARD_SPEED_MIN = 15; AURA_KEYBOARD_SPEED_MIN = 15;
AURA_KEYBOARD_SPEED_MAX = 0; AURA_KEYBOARD_SPEED_MAX = 0;
AURA_KEYBOARD_SPEED_DEFAULT = 8; AURA_KEYBOARD_SPEED_DEFAULT = 8;
break;
} }
mode Direct; mode Direct;
Direct.name = "Direct"; Direct.name = "Direct";
Direct.value = AURA_KEYBOARD_MODE_DIRECT; Direct.value = AURA_KEYBOARD_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED; Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct); modes.push_back(Direct);
mode Static; mode Static;
Static.name = "Static"; Static.name = "Static";
Static.value = AURA_KEYBOARD_MODE_STATIC; Static.value = AURA_KEYBOARD_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS; 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_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Static.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX; Static.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Static.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT; Static.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC; Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_min = 1; Static.colors_min = 1;
Static.colors_max = 1; Static.colors_max = 1;
Static.colors.resize(1); Static.colors.resize(1);
modes.push_back(Static); modes.push_back(Static);
mode Breathing; mode Breathing;
Breathing.name = "Breathing"; Breathing.name = "Breathing";
Breathing.value = AURA_KEYBOARD_MODE_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; 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; if(controller->is_per_led_keyboard)
{
Breathing.speed_min = AURA_KEYBOARD_SPEED_MIN; Breathing.flags |= MODE_FLAG_HAS_RANDOM_COLOR;
Breathing.speed_max = AURA_KEYBOARD_SPEED_MAX; }
Breathing.speed = AURA_KEYBOARD_SPEED_DEFAULT; Breathing.speed_min = AURA_KEYBOARD_SPEED_MIN;
Breathing.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN; Breathing.speed_max = AURA_KEYBOARD_SPEED_MAX;
Breathing.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX; Breathing.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Breathing.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT; Breathing.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; Breathing.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Breathing.colors_min = 1; Breathing.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Breathing.colors_max = 2; Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors_min = 1;
Breathing.colors_max = 2;
Breathing.colors.resize(1); Breathing.colors.resize(1);
modes.push_back(Breathing); modes.push_back(Breathing);
mode Color_Cycle; mode Color_Cycle;
Color_Cycle.name = "Spectrum Cycle"; Color_Cycle.name = "Spectrum Cycle";
Color_Cycle.value = AURA_KEYBOARD_MODE_COLOR_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.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Color_Cycle.speed_min = AURA_KEYBOARD_SPEED_MIN; Color_Cycle.speed_min = AURA_KEYBOARD_SPEED_MIN;
Color_Cycle.speed_max = AURA_KEYBOARD_SPEED_MAX; Color_Cycle.speed_max = AURA_KEYBOARD_SPEED_MAX;
Color_Cycle.speed = AURA_KEYBOARD_SPEED_DEFAULT; Color_Cycle.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Color_Cycle.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN; Color_Cycle.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Color_Cycle.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX; Color_Cycle.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Color_Cycle.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT; Color_Cycle.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Color_Cycle.color_mode = MODE_COLORS_NONE; Color_Cycle.color_mode = MODE_COLORS_NONE;
modes.push_back(Color_Cycle); modes.push_back(Color_Cycle);
mode Wave; mode Wave;
Wave.name = "Rainbow Wave"; Wave.name = "Rainbow Wave";
Wave.value = AURA_KEYBOARD_MODE_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; 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; if(controller->is_per_led_keyboard)
{
Wave.speed_min = AURA_KEYBOARD_SPEED_MIN; Wave.flags |= MODE_FLAG_HAS_DIRECTION_UD;
Wave.speed_max = AURA_KEYBOARD_SPEED_MAX; }
Wave.speed = AURA_KEYBOARD_SPEED_DEFAULT; Wave.speed_min = AURA_KEYBOARD_SPEED_MIN;
Wave.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN; Wave.speed_max = AURA_KEYBOARD_SPEED_MAX;
Wave.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX; Wave.speed = AURA_KEYBOARD_SPEED_DEFAULT;
Wave.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT; Wave.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
Wave.direction = MODE_DIRECTION_LEFT; Wave.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC; Wave.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
Wave.direction = MODE_DIRECTION_LEFT;
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
if(!controller->is_per_led_keyboard) if(!controller->is_per_led_keyboard)
{ {
@ -268,129 +276,129 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
else else
{ {
name = "ASUS ROG Claymore"; name = controller->GetName();
vendor = "ASUS"; vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD; type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Aura Keyboard Device"; description = "ASUS Aura Keyboard Device";
version = controller->GetVersion(); version = controller->GetVersion();
location = controller->GetDeviceLocation(); location = controller->GetDeviceLocation();
serial = controller->GetSerialString(); serial = controller->GetSerialString();
mode Direct; mode Direct;
Direct.name = "Direct"; Direct.name = "Direct";
Direct.value = AURA_KEYBOARD_MODE_DIRECT; Direct.value = AURA_KEYBOARD_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED; Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct); modes.push_back(Direct);
mode Static; mode Static;
Static.name = "Static"; Static.name = "Static";
Static.value = AURA_KEYBOARD_MODE_STATIC; Static.value = AURA_KEYBOARD_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE; Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC; Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_min = 1; Static.colors_min = 1;
Static.colors_max = 1; Static.colors_max = 1;
Static.colors.resize(1); Static.colors.resize(1);
modes.push_back(Static); modes.push_back(Static);
mode Breathing; mode Breathing;
Breathing.name = "Breathing"; Breathing.name = "Breathing";
Breathing.value = AURA_KEYBOARD_MODE_BREATHING; Breathing.value = AURA_KEYBOARD_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; 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_min = AURA_CLAYMORE_SPEED_MIN;
Breathing.speed_max = AURA_CLAYMORE_SPEED_MAX; Breathing.speed_max = AURA_CLAYMORE_SPEED_MAX;
Breathing.speed = AURA_CLAYMORE_SPEED_DEFAULT_BREATHING; Breathing.speed = AURA_CLAYMORE_SPEED_DEFAULT_BREATHING;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors_min = 1; Breathing.colors_min = 1;
Breathing.colors_max = 2; Breathing.colors_max = 2;
Breathing.colors.resize(2); Breathing.colors.resize(2);
modes.push_back(Breathing); modes.push_back(Breathing);
mode Color_Cycle; mode Color_Cycle;
Color_Cycle.name = "Spectrum Cycle"; Color_Cycle.name = "Spectrum Cycle";
Color_Cycle.value = AURA_KEYBOARD_MODE_COLOR_CYCLE; Color_Cycle.value = AURA_KEYBOARD_MODE_COLOR_CYCLE;
Color_Cycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE; Color_Cycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Color_Cycle.speed_min = AURA_CLAYMORE_SPEED_MIN; Color_Cycle.speed_min = AURA_CLAYMORE_SPEED_MIN;
Color_Cycle.speed_max = AURA_CLAYMORE_SPEED_MAX; Color_Cycle.speed_max = AURA_CLAYMORE_SPEED_MAX;
Color_Cycle.speed = AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE; Color_Cycle.speed = AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE;
Color_Cycle.color_mode = MODE_COLORS_NONE; Color_Cycle.color_mode = MODE_COLORS_NONE;
modes.push_back(Color_Cycle); modes.push_back(Color_Cycle);
mode Reactive; mode Reactive;
Reactive.name = "Reactive"; Reactive.name = "Reactive";
Reactive.value = AURA_KEYBOARD_MODE_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.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_min = AURA_CLAYMORE_SPEED_MIN;
Reactive.speed_max = AURA_CLAYMORE_SPEED_MAX; Reactive.speed_max = AURA_CLAYMORE_SPEED_MAX;
Reactive.speed = AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE; Reactive.speed = AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE;
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC; Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
Reactive.colors_min = 1; Reactive.colors_min = 1;
Reactive.colors_max = 2; Reactive.colors_max = 2;
Reactive.colors.resize(2); Reactive.colors.resize(2);
modes.push_back(Reactive); modes.push_back(Reactive);
mode Wave; mode Wave;
Wave.name = "Rainbow Wave"; Wave.name = "Rainbow Wave";
Wave.value = AURA_KEYBOARD_MODE_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.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_min = AURA_CLAYMORE_SPEED_MIN;
Wave.speed_max = AURA_CLAYMORE_SPEED_MAX; Wave.speed_max = AURA_CLAYMORE_SPEED_MAX;
Wave.speed = AURA_CLAYMORE_SPEED_DEFAULT_WAVE; Wave.speed = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
Wave.direction = MODE_DIRECTION_LEFT; Wave.direction = MODE_DIRECTION_LEFT;
Wave.color_mode = MODE_COLORS_NONE; Wave.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave); modes.push_back(Wave);
mode Color_Wave; mode Color_Wave;
Color_Wave.name = "Color Wave"; Color_Wave.name = "Color Wave";
Color_Wave.value = AURA_KEYBOARD_MODE_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.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_min = AURA_CLAYMORE_SPEED_MIN;
Color_Wave.speed_max = AURA_CLAYMORE_SPEED_MAX; Color_Wave.speed_max = AURA_CLAYMORE_SPEED_MAX;
Color_Wave.speed = AURA_CLAYMORE_SPEED_DEFAULT_WAVE; Color_Wave.speed = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
Color_Wave.direction = MODE_DIRECTION_LEFT; Color_Wave.direction = MODE_DIRECTION_LEFT;
Color_Wave.color_mode = MODE_COLORS_MODE_SPECIFIC; Color_Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
Color_Wave.colors_min = 1; Color_Wave.colors_min = 1;
Color_Wave.colors_max = 2; Color_Wave.colors_max = 2;
Color_Wave.colors.resize(2); Color_Wave.colors.resize(2);
modes.push_back(Color_Wave); modes.push_back(Color_Wave);
mode Ripple; mode Ripple;
Ripple.name = "Ripple"; Ripple.name = "Ripple";
Ripple.value = AURA_KEYBOARD_MODE_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.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_min = AURA_CLAYMORE_SPEED_MIN;
Ripple.speed_max = AURA_CLAYMORE_SPEED_MAX; Ripple.speed_max = AURA_CLAYMORE_SPEED_MAX;
Ripple.speed = AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE; Ripple.speed = AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE;
Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC; Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC;
Ripple.colors_min = 1; Ripple.colors_min = 1;
Ripple.colors_max = 2; Ripple.colors_max = 2;
Ripple.colors.resize(2); Ripple.colors.resize(2);
modes.push_back(Ripple); modes.push_back(Ripple);
mode Starry_Night; mode Starry_Night;
Starry_Night.name = "Starry Night"; Starry_Night.name = "Starry Night";
Starry_Night.value = AURA_KEYBOARD_MODE_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.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_min = AURA_CLAYMORE_SPEED_MIN;
Starry_Night.speed_max = AURA_CLAYMORE_SPEED_MAX; Starry_Night.speed_max = AURA_CLAYMORE_SPEED_MAX;
Starry_Night.speed = AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT; Starry_Night.speed = AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT;
Starry_Night.color_mode = MODE_COLORS_MODE_SPECIFIC; Starry_Night.color_mode = MODE_COLORS_MODE_SPECIFIC;
Starry_Night.colors_min = 1; Starry_Night.colors_min = 1;
Starry_Night.colors_max = 2; Starry_Night.colors_max = 2;
Starry_Night.colors.resize(2); Starry_Night.colors.resize(2);
modes.push_back(Starry_Night); modes.push_back(Starry_Night);
mode Quicksand; mode Quicksand;
Quicksand.name = "Quicksand"; Quicksand.name = "Quicksand";
Quicksand.value = AURA_KEYBOARD_MODE_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.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.direction = MODE_DIRECTION_DOWN;
Quicksand.speed_min = AURA_CLAYMORE_SPEED_MIN; Quicksand.speed_min = AURA_CLAYMORE_SPEED_MIN;
Quicksand.speed_max = AURA_CLAYMORE_SPEED_MAX; Quicksand.speed_max = AURA_CLAYMORE_SPEED_MAX;
Quicksand.speed = AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND; Quicksand.speed = AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND;
Quicksand.color_mode = MODE_COLORS_MODE_SPECIFIC; Quicksand.color_mode = MODE_COLORS_MODE_SPECIFIC;
Quicksand.colors_min = 6; Quicksand.colors_min = 6;
Quicksand.colors_max = 6; Quicksand.colors_max = 6;
Quicksand.colors.resize(6); Quicksand.colors.resize(6);
modes.push_back(Quicksand); modes.push_back(Quicksand);
} }

2
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraAddressableController.cpp
View file

@ -12,7 +12,7 @@
#include <cstring> #include <cstring>
#include "AsusAuraAddressableController.h" #include "AsusAuraAddressableController.h"
AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path) AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
{ {
/*-----------------------------------------------------*\ /*-----------------------------------------------------*\
| Add addressable devices | | Add addressable devices |

2
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraAddressableController.h
View file

@ -24,7 +24,7 @@ enum
class AuraAddressableController : public AuraUSBController class AuraAddressableController : public AuraUSBController
{ {
public: public:
AuraAddressableController(hid_device* dev_handle, const char* path); AuraAddressableController(hid_device* dev_handle, const char* path, std::string dev_name);
~AuraAddressableController(); ~AuraAddressableController();
void SetChannelLEDs void SetChannelLEDs

2
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraMainboardController.cpp
View file

@ -12,7 +12,7 @@
#include <cstring> #include <cstring>
#include "AsusAuraMainboardController.h" #include "AsusAuraMainboardController.h"
AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path), mode(AURA_MODE_DIRECT) 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_total_mainboard_leds = config_table[0x1B];
unsigned char num_rgb_headers = config_table[0x1D]; unsigned char num_rgb_headers = config_table[0x1D];

2
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraMainboardController.h
View file

@ -26,7 +26,7 @@ enum
class AuraMainboardController : public AuraUSBController class AuraMainboardController : public AuraUSBController
{ {
public: public:
AuraMainboardController(hid_device* dev_handle, const char* path); AuraMainboardController(hid_device* dev_handle, const char* path, std::string dev_name);
~AuraMainboardController(); ~AuraMainboardController();
void SetChannelLEDs void SetChannelLEDs

18
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraUSBController.cpp
View file

@ -14,10 +14,11 @@
#include "LogManager.h" #include "LogManager.h"
#include "StringUtils.h" #include "StringUtils.h"
AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path) AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path, std::string dev_name)
{ {
dev = dev_handle; dev = dev_handle;
location = path; location = path;
name = dev_name;
GetFirmwareVersion(); GetFirmwareVersion();
GetConfigTable(); GetConfigTable();
@ -40,7 +41,7 @@ std::string AuraUSBController::GetDeviceLocation()
std::string AuraUSBController::GetDeviceName() std::string AuraUSBController::GetDeviceName()
{ {
return(device_name); return(name);
} }
std::string AuraUSBController::GetSerialString() std::string AuraUSBController::GetSerialString()
@ -56,6 +57,11 @@ std::string AuraUSBController::GetSerialString()
return(StringUtils::wstring_to_string(serial_string)); return(StringUtils::wstring_to_string(serial_string));
} }
std::string AuraUSBController::GetDeviceVersion()
{
return(std::string(version));
}
const std::vector<AuraDeviceInfo>& AuraUSBController::GetAuraDevices() const const std::vector<AuraDeviceInfo>& AuraUSBController::GetAuraDevices() const
{ {
return(device_info); return(device_info);
@ -89,11 +95,11 @@ void AuraUSBController::GetConfigTable()
{ {
memcpy(config_table, &usb_buf[4], 60); memcpy(config_table, &usb_buf[4], 60);
LOG_DEBUG("[%s] ASUS Aura USB config table:", device_name); LOG_DEBUG("[%s] ASUS Aura USB config table:", version);
for(int i = 0; i < 60; i+=6) for(int i = 0; i < 60; i+=6)
{ {
LOG_DEBUG("[%s] %02X %02X %02X %02X %02X %02X", device_name, LOG_DEBUG("[%s] %02X %02X %02X %02X %02X %02X", version,
config_table[i + 0], config_table[i + 0],
config_table[i + 1], config_table[i + 1],
config_table[i + 2], config_table[i + 2],
@ -104,7 +110,7 @@ void AuraUSBController::GetConfigTable()
} }
else else
{ {
LOG_INFO("[%s] Could not read config table, can not add device", device_name); LOG_INFO("[%s] Could not read config table, can not add device", version);
delete this; delete this;
} }
} }
@ -135,7 +141,7 @@ void AuraUSBController::GetFirmwareVersion()
\*-----------------------------------------------------*/ \*-----------------------------------------------------*/
if(usb_buf[1] == 0x02) if(usb_buf[1] == 0x02)
{ {
memcpy(device_name, &usb_buf[2], 16); memcpy(version, &usb_buf[2], 16);
} }
} }

19
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraUSBController.h
View file

@ -54,17 +54,17 @@ enum class AuraDeviceType
struct AuraDeviceInfo struct AuraDeviceInfo
{ {
unsigned char effect_channel; unsigned char effect_channel;
unsigned char direct_channel; unsigned char direct_channel;
unsigned char num_leds; unsigned char num_leds;
unsigned char num_headers; unsigned char num_headers;
AuraDeviceType device_type; AuraDeviceType device_type;
}; };
class AuraUSBController class AuraUSBController
{ {
public: public:
AuraUSBController(hid_device* dev_handle, const char* path); AuraUSBController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~AuraUSBController(); virtual ~AuraUSBController();
unsigned int GetChannelCount(); unsigned int GetChannelCount();
@ -72,6 +72,7 @@ public:
std::string GetDeviceLocation(); std::string GetDeviceLocation();
std::string GetDeviceName(); std::string GetDeviceName();
std::string GetSerialString(); std::string GetSerialString();
std::string GetDeviceVersion();
const std::vector<AuraDeviceInfo>& GetAuraDevices() const; const std::vector<AuraDeviceInfo>& GetAuraDevices() const;
@ -96,6 +97,8 @@ protected:
unsigned char config_table[60]; unsigned char config_table[60];
std::vector<AuraDeviceInfo> device_info; std::vector<AuraDeviceInfo> device_info;
std::string location; std::string location;
std::string name;
char version[16];
void SendDirect void SendDirect
( (
@ -103,10 +106,8 @@ protected:
unsigned char led_count, unsigned char led_count,
RGBColor * colors RGBColor * colors
); );
private: private:
char device_name[16];
void GetConfigTable(); void GetConfigTable();
void GetFirmwareVersion(); void GetFirmwareVersion();
}; };

1
Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraMainboard.cpp
View file

@ -26,7 +26,6 @@
RGBController_AuraMainboard::RGBController_AuraMainboard(AuraMainboardController* controller_ptr) : RGBController_AuraMainboard::RGBController_AuraMainboard(AuraMainboardController* controller_ptr) :
RGBController_AuraUSB(controller_ptr) RGBController_AuraUSB(controller_ptr)
{ {
name = "ASUS Aura USB Mainboard";
description = "ASUS Aura USB Mainboard Device"; description = "ASUS Aura USB Mainboard Device";
/*-------------------------------------------------------*\ /*-------------------------------------------------------*\

108
Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp
View file

@ -26,91 +26,91 @@
RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr) : RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr) :
initializedMode(false) initializedMode(false)
{ {
controller = controller_ptr; controller = controller_ptr;
name = "ASUS Aura USB"; name = controller->GetDeviceName();
vendor = "ASUS"; vendor = "ASUS";
version = controller->GetDeviceName(); type = DEVICE_TYPE_MOTHERBOARD;
type = DEVICE_TYPE_MOTHERBOARD; description = "ASUS Aura USB Device";
description = "ASUS Aura USB Device"; location = controller->GetDeviceLocation();
location = controller->GetDeviceLocation(); serial = controller->GetSerialString();
serial = controller->GetSerialString(); version = controller->GetDeviceVersion();
mode Direct; mode Direct;
Direct.name = "Direct"; Direct.name = "Direct";
Direct.value = AURA_MODE_DIRECT; Direct.value = AURA_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED; Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct); modes.push_back(Direct);
mode Off; mode Off;
Off.name = "Off"; Off.name = "Off";
Off.value = AURA_MODE_OFF; Off.value = AURA_MODE_OFF;
Off.flags = 0; Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE; Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off); modes.push_back(Off);
mode Static; mode Static;
Static.name = "Static"; Static.name = "Static";
Static.value = AURA_MODE_STATIC; Static.value = AURA_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1; Static.colors_min = 1;
Static.colors_max = 1; Static.colors_max = 1;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC; Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1); Static.colors.resize(1);
modes.push_back(Static); modes.push_back(Static);
mode Breathing; mode Breathing;
Breathing.name = "Breathing"; Breathing.name = "Breathing";
Breathing.value = AURA_MODE_BREATHING; Breathing.value = AURA_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Breathing.colors_min = 1; Breathing.colors_min = 1;
Breathing.colors_max = 1; Breathing.colors_max = 1;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize(1); Breathing.colors.resize(1);
modes.push_back(Breathing); modes.push_back(Breathing);
mode Flashing; mode Flashing;
Flashing.name = "Flashing"; Flashing.name = "Flashing";
Flashing.value = AURA_MODE_FLASHING; Flashing.value = AURA_MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; Flashing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Flashing.colors_min = 1; Flashing.colors_min = 1;
Flashing.colors_max = 1; Flashing.colors_max = 1;
Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC; Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Flashing.colors.resize(1); Flashing.colors.resize(1);
modes.push_back(Flashing); modes.push_back(Flashing);
mode SpectrumCycle; mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle"; SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = AURA_MODE_SPECTRUM_CYCLE; SpectrumCycle.value = AURA_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = 0; SpectrumCycle.flags = 0;
SpectrumCycle.color_mode = MODE_COLORS_NONE; SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle); modes.push_back(SpectrumCycle);
mode Rainbow; mode Rainbow;
Rainbow.name = "Rainbow"; Rainbow.name = "Rainbow";
Rainbow.value = AURA_MODE_RAINBOW; Rainbow.value = AURA_MODE_RAINBOW;
Rainbow.flags = 0; Rainbow.flags = 0;
Rainbow.color_mode = MODE_COLORS_NONE; Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow); modes.push_back(Rainbow);
mode ChaseFade; mode ChaseFade;
ChaseFade.name = "Chase Fade"; ChaseFade.name = "Chase Fade";
ChaseFade.value = AURA_MODE_CHASE_FADE; ChaseFade.value = AURA_MODE_CHASE_FADE;
ChaseFade.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; ChaseFade.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
ChaseFade.colors_min = 1; ChaseFade.colors_min = 1;
ChaseFade.colors_max = 1; ChaseFade.colors_max = 1;
ChaseFade.color_mode = MODE_COLORS_MODE_SPECIFIC; ChaseFade.color_mode = MODE_COLORS_MODE_SPECIFIC;
ChaseFade.colors.resize(1); ChaseFade.colors.resize(1);
modes.push_back(ChaseFade); modes.push_back(ChaseFade);
mode Chase; mode Chase;
Chase.name = "Chase"; Chase.name = "Chase";
Chase.value = AURA_MODE_CHASE; Chase.value = AURA_MODE_CHASE;
Chase.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; Chase.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Chase.colors_min = 1; Chase.colors_min = 1;
Chase.colors_max = 1; Chase.colors_max = 1;
Chase.color_mode = MODE_COLORS_MODE_SPECIFIC; Chase.color_mode = MODE_COLORS_MODE_SPECIFIC;
Chase.colors.resize(1); Chase.colors.resize(1);
modes.push_back(Chase); modes.push_back(Chase);

123
Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
View file

@ -37,19 +37,19 @@
#include "RGBController_AsusAuraRyuoAIO.h" #include "RGBController_AsusAuraRyuoAIO.h"
#include "dmiinfo.h" #include "dmiinfo.h"
#define AURA_USB_VID 0x0B05 #define AURA_USB_VID 0x0B05
/*-----------------------------------------------------------------*\ /*-----------------------------------------------------------------*\
| MOTHERBOARDS | | MOTHERBOARDS |
\*-----------------------------------------------------------------*/ \*-----------------------------------------------------------------*/
#define AURA_ADDRESSABLE_1_PID 0x1867 #define AURA_ADDRESSABLE_1_PID 0x1867
#define AURA_ADDRESSABLE_2_PID 0x1872 #define AURA_ADDRESSABLE_2_PID 0x1872
#define AURA_ADDRESSABLE_3_PID 0x18A3 #define AURA_ADDRESSABLE_3_PID 0x18A3
#define AURA_ADDRESSABLE_4_PID 0x18A5 #define AURA_ADDRESSABLE_4_PID 0x18A5
#define AURA_MOTHERBOARD_1_PID 0x18F3 #define AURA_MOTHERBOARD_1_PID 0x18F3
#define AURA_MOTHERBOARD_2_PID 0x1939 #define AURA_MOTHERBOARD_2_PID 0x1939
#define AURA_MOTHERBOARD_3_PID 0x19AF #define AURA_MOTHERBOARD_3_PID 0x19AF
#define AURA_MOTHERBOARD_4_PID 0x1AA6 #define AURA_MOTHERBOARD_4_PID 0x1AA6
/*-----------------------------------------------------------------*\ /*-----------------------------------------------------------------*\
| KEYBOARDS | | KEYBOARDS |
@ -83,44 +83,41 @@
/*-----------------------------------------------------------------*\ /*-----------------------------------------------------------------*\
| MICE - defined in AsusAuraMouseDevices.h | | MICE - defined in AsusAuraMouseDevices.h |
\*-----------------------------------------------------------------*/ \*-----------------------------------------------------------------*/
#define AURA_ROG_STRIX_EVOLVE_PID 0x185B
#define AURA_ROG_STRIX_EVOLVE_PID 0x185B #define AURA_ROG_SPATHA_WIRED_PID 0x181C
#define AURA_ROG_SPATHA_WIRED_PID 0x181C #define AURA_ROG_SPATHA_WIRELESS_PID 0x1824
#define AURA_ROG_SPATHA_WIRELESS_PID 0x1824
/*-----------------------------------------------------------------*\ /*-----------------------------------------------------------------*\
| MOUSEMATS | | MOUSEMATS |
\*-----------------------------------------------------------------*/ \*-----------------------------------------------------------------*/
#define AURA_ROG_BALTEUS_PID 0x1891 #define AURA_ROG_BALTEUS_PID 0x1891
#define AURA_ROG_BALTEUS_QI_PID 0x1890 #define AURA_ROG_BALTEUS_QI_PID 0x1890
/*-----------------------------------------------------------------*\ /*-----------------------------------------------------------------*\
| MONITORS | | MONITORS |
\*-----------------------------------------------------------------*/ \*-----------------------------------------------------------------*/
#define AURA_ROG_STRIX_XG27AQ_PID 0x198C
#define AURA_ROG_STRIX_XG27AQ_PID 0x198C #define AURA_ROG_STRIX_XG27AQM_PID 0x19BB
#define AURA_ROG_STRIX_XG27AQM_PID 0x19BB #define AURA_ROG_STRIX_XG279Q_PID 0x1919
#define AURA_ROG_STRIX_XG279Q_PID 0x1919 #define AURA_ROG_STRIX_XG27W_PID 0x1933
#define AURA_ROG_STRIX_XG27W_PID 0x1933 #define AURA_ROG_STRIX_XG32VC_PID 0x1968
#define AURA_ROG_STRIX_XG32VC_PID 0x1968 #define AURA_ROG_PG32UQ_PID 0x19B9
#define AURA_ROG_PG32UQ_PID 0x19B9
/*-----------------------------------------------------------------*\ /*-----------------------------------------------------------------*\
| HEADSETSTANDS | | HEADSET STANDS |
\*-----------------------------------------------------------------*/ \*-----------------------------------------------------------------*/
#define AURA_ROG_THRONE_PID 0x18D9
#define AURA_ROG_THRONE_PID 0x18D9 #define AURA_ROG_THRONE_QI_PID 0x18C5
#define AURA_ROG_THRONE_QI_PID 0x18C5 #define AURA_ROG_THRONE_QI_GUNDAM_PID 0x1994
#define AURA_ROG_THRONE_QI_GUNDAM_PID 0x1994
/*-----------------------------------------------------------------*\ /*-----------------------------------------------------------------*\
| OTHER | | OTHER |
\*-----------------------------------------------------------------*/ \*-----------------------------------------------------------------*/
#define AURA_TERMINAL_PID 0x1889 #define AURA_TERMINAL_PID 0x1889
#define ROG_STRIX_LC120_PID 0x879E #define ROG_STRIX_LC120_PID 0x879E
#define AURA_RYUO_AIO_PID 0x1887 #define AURA_RYUO_AIO_PID 0x1887
#define ASUS_ROG_ALLY_PID 0x1ABE #define ASUS_ROG_ALLY_PID 0x1ABE
#define ASUS_ROG_ALLY_X_PID 0x1B4C #define ASUS_ROG_ALLY_X_PID 0x1B4C
AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid) AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
{ {
@ -148,9 +145,9 @@ void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
if(dev) if(dev)
{ {
AuraAddressableController* controller = new AuraAddressableController(dev, info->path); AuraAddressableController* controller = new AuraAddressableController(dev, info->path, name);
RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller); RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} }
@ -161,10 +158,10 @@ void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*na
if(dev) if(dev)
{ {
DMIInfo dmi; DMIInfo dmi;
AuraAddressableController* controller = new AuraAddressableController(dev, info->path); AuraAddressableController* controller = new AuraAddressableController(dev, info->path, "ASUS " + dmi.getMainboard() + " Addressable");
RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller); RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
rgb_controller->name = "ASUS " + dmi.getMainboard() + " Addressable";
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} }
@ -177,10 +174,10 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*n
{ {
try try
{ {
DMIInfo dmi; DMIInfo dmi;
AuraMainboardController* controller = new AuraMainboardController(dev, info->path); AuraMainboardController* controller = new AuraMainboardController(dev, info->path, "ASUS " + dmi.getMainboard());
RGBController_AuraMainboard* rgb_controller = new RGBController_AuraMainboard(controller); RGBController_AuraMainboard* rgb_controller = new RGBController_AuraMainboard(controller);
rgb_controller->name = "ASUS " + dmi.getMainboard();
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
catch(const std::runtime_error& ex) catch(const std::runtime_error& ex)
@ -197,10 +194,10 @@ void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
if(dev) if(dev)
{ {
AuraKeyboardController* controller = new AuraKeyboardController(dev, info->path); AuraKeyboardController* controller = new AuraKeyboardController(dev, info->path, name);
AuraKeyboardMappingLayoutType layout = GetKeyboardMappingLayoutType(info->product_id); AuraKeyboardMappingLayoutType layout = GetKeyboardMappingLayoutType(info->product_id);
RGBController_AuraKeyboard* rgb_controller = new RGBController_AuraKeyboard(controller, layout); RGBController_AuraKeyboard* rgb_controller = new RGBController_AuraKeyboard(controller, layout);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} }
@ -212,9 +209,9 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
if(dev) if(dev)
{ {
uint16_t pid = (name == "Asus ROG Spatha X Dock") ? AURA_ROG_SPATHA_X_DOCK_FAKE_PID : info->product_id; 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); AuraMouseController* controller = new AuraMouseController(dev, info->path, pid, name);
RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller); RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} }
@ -225,9 +222,9 @@ void DetectAsusAuraUSBMousemats(hid_device_info* info, const std::string& name)
if(dev) if(dev)
{ {
AuraMousematController* controller = new AuraMousematController(dev, info->path); AuraMousematController* controller = new AuraMousematController(dev, info->path, name);
RGBController_AuraMousemat* rgb_controller = new RGBController_AuraMousemat(controller); RGBController_AuraMousemat* rgb_controller = new RGBController_AuraMousemat(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} }
@ -238,9 +235,9 @@ void DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name)
if(dev) if(dev)
{ {
AsusROGStrixLCController* controller = new AsusROGStrixLCController(dev, info->path); AsusROGStrixLCController* controller = new AsusROGStrixLCController(dev, info->path, name);
RGBController_AsusROGStrixLC* rgb_controller = new RGBController_AsusROGStrixLC(controller); RGBController_AsusROGStrixLC* rgb_controller = new RGBController_AsusROGStrixLC(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} }
@ -251,9 +248,9 @@ void DetectAsusAuraUSBRyuoAIO(hid_device_info* info, const std::string& name)
if(dev) if(dev)
{ {
AsusAuraRyuoAIOController* controller = new AsusAuraRyuoAIOController(dev, info->path); AsusAuraRyuoAIOController* controller = new AsusAuraRyuoAIOController(dev, info->path, name);
RGBController_AsusAuraRyuoAIO* rgb_controller = new RGBController_AsusAuraRyuoAIO(controller); RGBController_AsusAuraRyuoAIO* rgb_controller = new RGBController_AsusAuraRyuoAIO(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} }
@ -264,9 +261,9 @@ void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name
if(dev) if(dev)
{ {
AsusAuraMouseGen1Controller* controller = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id); AsusAuraMouseGen1Controller* controller = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
RGBController_AsusROGStrixEvolve* rgb_controller = new RGBController_AsusROGStrixEvolve(controller); RGBController_AsusROGStrixEvolve* rgb_controller = new RGBController_AsusROGStrixEvolve(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} }
@ -277,9 +274,9 @@ void DetectAsusAuraUSBSpatha(hid_device_info* info, const std::string& name)
if(dev) if(dev)
{ {
AsusAuraMouseGen1Controller* controller = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id); AsusAuraMouseGen1Controller* controller = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
RGBController_AsusROGSpatha* rgb_controller = new RGBController_AsusROGSpatha(controller); RGBController_AsusROGSpatha* rgb_controller = new RGBController_AsusROGSpatha(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} }
@ -290,9 +287,9 @@ void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& nam
if(dev) if(dev)
{ {
AuraHeadsetStandController* controller = new AuraHeadsetStandController(dev, info->path); AuraHeadsetStandController* controller = new AuraHeadsetStandController(dev, info->path, name);
RGBController_AuraHeadsetStand* rgb_controller = new RGBController_AuraHeadsetStand(controller); RGBController_AuraHeadsetStand* rgb_controller = new RGBController_AuraHeadsetStand(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} }
@ -303,9 +300,9 @@ void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name
if(dev) if(dev)
{ {
AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number); AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number, name);
RGBController_AuraTUFKeyboard* rgb_controller = new RGBController_AuraTUFKeyboard(controller); RGBController_AuraTUFKeyboard* rgb_controller = new RGBController_AuraTUFKeyboard(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} }
@ -316,9 +313,9 @@ void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
if(dev) if(dev)
{ {
AuraMonitorController* controller = new AuraMonitorController(dev, info->path, info->product_id); AuraMonitorController* controller = new AuraMonitorController(dev, info->path, info->product_id, name);
RGBController_AuraMonitor* rgb_controller = new RGBController_AuraMonitor(controller); RGBController_AuraMonitor* rgb_controller = new RGBController_AuraMonitor(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} }
@ -329,9 +326,9 @@ void DetectAsusROGAlly(hid_device_info* info, const std::string& name)
if(dev) if(dev)
{ {
ROGAllyController* controller = new ROGAllyController(dev, info->path); ROGAllyController* controller = new ROGAllyController(dev, info->path, name);
RGBController_AsusROGAlly* rgb_controller = new RGBController_AsusROGAlly(controller); RGBController_AsusROGAlly* rgb_controller = new RGBController_AsusROGAlly(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} }

8
Controllers/AsusAuraUSBController/AsusROGAllyController/AsusROGAllyController.cpp
View file

@ -13,10 +13,11 @@
#include "AsusROGAllyController.h" #include "AsusROGAllyController.h"
#include "StringUtils.h" #include "StringUtils.h"
ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path) ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path, std::string dev_name)
{ {
dev = dev_handle; dev = dev_handle;
location = path; location = path;
name = dev_name;
SendInitialization(); SendInitialization();
} }
@ -31,6 +32,11 @@ std::string ROGAllyController::GetDeviceLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string ROGAllyController::GetName()
{
return(name);
}
std::string ROGAllyController::GetSerialString() std::string ROGAllyController::GetSerialString()
{ {
wchar_t serial_string[128]; wchar_t serial_string[128];

42
Controllers/AsusAuraUSBController/AsusROGAllyController/AsusROGAllyController.h
View file

@ -40,36 +40,38 @@ enum
class ROGAllyController class ROGAllyController
{ {
public: public:
ROGAllyController(hid_device* dev_handle, const char* path); ROGAllyController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~ROGAllyController(); virtual ~ROGAllyController();
std::string GetDeviceLocation(); std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString(); std::string GetSerialString();
std::string GetVersion(); std::string GetVersion();
void SendInitialization(); void SendInitialization();
void UpdateBrightness void UpdateBrightness
( (
unsigned char brightness unsigned char brightness
); );
void UpdateLeds void UpdateLeds
( (
std::vector<RGBColor> colors std::vector<RGBColor> colors
); );
void UpdateDevice void UpdateDevice
( (
unsigned char mode, unsigned char mode,
std::vector<RGBColor> colors, std::vector<RGBColor> colors,
unsigned char speed, unsigned char speed,
unsigned char direction unsigned char direction
); );
void SaveMode(); void SaveMode();
private: private:
hid_device* dev; hid_device* dev;
std::string location; std::string location;
std::string name;
}; };

2
Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.cpp
View file

@ -26,7 +26,7 @@ RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controll
{ {
controller = controller_ptr; controller = controller_ptr;
name = "ASUS ROG Ally"; name = controller->GetName();
vendor = "ASUS"; vendor = "ASUS";
type = DEVICE_TYPE_GAMEPAD; type = DEVICE_TYPE_GAMEPAD;
description = "ASUS ROG Ally Device"; description = "ASUS ROG Ally Device";

2
Controllers/AsusAuraUSBController/AsusROGStrixLCController/AsusROGStrixLCController.cpp
View file

@ -11,7 +11,7 @@
#include "AsusROGStrixLCController.h" #include "AsusROGStrixLCController.h"
AsusROGStrixLCController::AsusROGStrixLCController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path) AsusROGStrixLCController::AsusROGStrixLCController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
{ {
/*-----------------------------------------------------*\ /*-----------------------------------------------------*\
| Add addressable devices | | Add addressable devices |

2
Controllers/AsusAuraUSBController/AsusROGStrixLCController/AsusROGStrixLCController.h
View file

@ -58,7 +58,7 @@ enum
class AsusROGStrixLCController : public AuraUSBController class AsusROGStrixLCController : public AuraUSBController
{ {
public: public:
AsusROGStrixLCController(hid_device* dev_handle, const char* path); AsusROGStrixLCController(hid_device* dev_handle, const char* path, std::string dev_name);
~AsusROGStrixLCController(); ~AsusROGStrixLCController();
std::string GetLocation(); std::string GetLocation();

2
Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.cpp
View file

@ -28,7 +28,7 @@ RGBController_AsusROGStrixLC::RGBController_AsusROGStrixLC(AsusROGStrixLCControl
controller = controller_ptr; controller = controller_ptr;
uint8_t speed = ROGSTRIXLC_CONTROLLER_SPEED_NORMAL; uint8_t speed = ROGSTRIXLC_CONTROLLER_SPEED_NORMAL;
name = "ROG Strix LC"; name = controller->GetDeviceName();
vendor = "ASUS"; vendor = "ASUS";
type = DEVICE_TYPE_COOLER; type = DEVICE_TYPE_COOLER;
description = "ASUS Liquid Cooler including 120mm, 140mm, 240mm, 280mm and 360mm radiators."; description = "ASUS Liquid Cooler including 120mm, 140mm, 240mm, 280mm and 360mm radiators.";