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/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;
};