mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-04-27 09:23:57 -04:00
Code Issues Packages Projects Releases Wiki Activity

Add ASUS ROG Gladius II Core

Browse Source
This commit is contained in:
Adam Honse
2020-10-25 01:05:20 -05:00
parent bd15eb022f
commit 62145c4548
6 changed files with 369 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
Controllers/AuraUSBController/AuraMouseController.cpp Normal file
View File

@@ -0,0 +1,62 @@
/*-----------------------------------------*\
| AuraMouseController.cpp |
| |
| Driver for ASUS Aura RGB USB |
| lighting controller |
| |
| Adam Honse (CalcProgrammer1) 10/23/2020 |
\*-----------------------------------------*/
#include "AuraMouseController.h"
AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
}
AuraMouseController::~AuraMouseController()
{
}
std::string AuraMouseController::GetDeviceLocation()
{
return(location);
}
void AuraMouseController::SendUpdate
(
unsigned char zone,
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu
)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x28;
usb_buf[0x03] = zone;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = mode;
usb_buf[0x06] = 0x04;
usb_buf[0x07] = red;
usb_buf[0x08] = grn;
usb_buf[0x09] = blu;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
}

54
Controllers/AuraUSBController/AuraMouseController.h Normal file
View File

@@ -0,0 +1,54 @@
/*-----------------------------------------*\
| AuraMouseController.h |
| |
| Definitions and types for ASUS Aura |
| USB RGB lighting controller |
| |
| Adam Honse (CalcProgrammer1) 10/23/2020 |
\*-----------------------------------------*/
#include "RGBController.h"
#include <string>
#include <vector>
#include <hidapi/hidapi.h>
#pragma once
enum
{
AURA_MOUSE_ZONE_SCROLL = 0,
AURA_MOUSE_ZONE_LOGO = 1,
AURA_MOUSE_ZONE_ALL = 3,
};
enum
{
AURA_MOUSE_MODE_STATIC = 0,
AURA_MOUSE_MODE_BREATHING = 1,
AURA_MOUSE_MODE_COLOR_CYCLE = 2,
AURA_MOUSE_MODE_REACTIVE = 3,
AURA_MOUSE_MODE_OFF = 4,
};
class AuraMouseController
{
public:
AuraMouseController(hid_device* dev_handle, const char* path);
virtual ~AuraMouseController();
std::string GetDeviceLocation();
void SendUpdate
(
unsigned char zone,
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu
);
private:
hid_device* dev;
std::string location;
};

39
Controllers/AuraUSBController/AuraUSBControllerDetect.cpp
View File

@@ -1,8 +1,10 @@
#include "Detector.h"
#include "AuraAddressableController.h"
#include "AuraMainboardController.h"
#include "AuraMouseController.h"
#include "RGBController.h"
#include "RGBController_AuraUSB.h"
#include "RGBController_AuraMouse.h"
#include <vector>
#include <stdexcept>
#include <hidapi/hidapi.h>
@@ -15,7 +17,7 @@
#define AURA_ADDRESSABLE_4_PID 0x18A5
#define AURA_MOTHERBOARD_1_PID 0x18F3
#define AURA_MOTHERBOARD_2_PID 0x1939
#define AURA_ROG_GLADIUS_II_CORE_PID 0x18DD
typedef struct
{
unsigned short usb_vid;
@@ -48,6 +50,12 @@ static const aura_device motherboard_device_list[] =
{ AURA_USB_VID, AURA_MOTHERBOARD_2_PID, "ASUS Aura Motherboard" },
};
#define MOUSE_NUM_DEVICES (sizeof(mouse_device_list) / sizeof(mouse_device_list[ 0 ]))
static const aura_device mouse_device_list[] =
{
{ AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID, "ASUS ROG Gladius II Core" },
};
void DetectAuraUSBControllers(std::vector<RGBController*>& rgb_controllers)
{
@@ -73,6 +81,7 @@ void DetectAuraUSBControllers(std::vector<RGBController*>& rgb_controllers)
{
AuraAddressableController* controller = new AuraAddressableController(dev, info->path);
RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
rgb_controller->name = addressable_device_list[pid_idx].name;
rgb_controllers.push_back(rgb_controller);
}
}
@@ -103,6 +112,7 @@ void DetectAuraUSBControllers(std::vector<RGBController*>& rgb_controllers)
{
AuraMainboardController* controller = new AuraMainboardController(dev, info->path);
RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
rgb_controller->name = motherboard_device_list[pid_idx].name;
rgb_controllers.push_back(rgb_controller);
}
catch(std::runtime_error&)
@@ -116,6 +126,33 @@ void DetectAuraUSBControllers(std::vector<RGBController*>& rgb_controllers)
}
}
/*ASUS AURA Mouse*/
for(unsigned int pid_idx = 0; pid_idx < MOUSE_NUM_DEVICES; pid_idx++)
{
info = hid_enumerate(mouse_device_list[pid_idx].usb_vid, mouse_device_list[pid_idx].usb_pid);
while(info)
{
hid_device* dev = NULL;
if((info->vendor_id == mouse_device_list[pid_idx].usb_vid)
&&(info->product_id == mouse_device_list[pid_idx].usb_pid))
{
dev = hid_open_path(info->path);
if(dev)
{
AuraMouseController* controller = new AuraMouseController(dev, info->path);
RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller);
rgb_controller->name = mouse_device_list[pid_idx].name;
rgb_controllers.push_back(rgb_controller);
}
}
info = info->next;
}
}
} /* DetectAuraUSBControllers() */
REGISTER_DETECTOR("ASUS Aura USB", DetectAuraUSBControllers);

178
Controllers/AuraUSBController/RGBController_AuraMouse.cpp Normal file
View File

@@ -0,0 +1,178 @@
/*-----------------------------------------*\
| RGBController_AuraMouse.cpp |
| |
| Generic RGB Interface for Asus Aura |
| USB controller driver |
| |
| Adam Honse (CalcProgrammer1) 10/25/2020 |
\*-----------------------------------------*/
#include "RGBController_AuraMouse.h"
RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
{
aura = aura_ptr;
name = "ASUS Aura Mouse";
type = DEVICE_TYPE_MOUSE;
description = "ASUS Aura Mouse Device";
location = aura->GetDeviceLocation();
mode Direct;
Direct.name = "Direct";
Direct.value = AURA_MOUSE_MODE_STATIC;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = AURA_MOUSE_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = AURA_MOUSE_MODE_COLOR_CYCLE;
SpectrumCycle.flags = 0;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = AURA_MOUSE_MODE_REACTIVE;
Reactive.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Reactive.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Reactive);
mode Off;
Off.name = "Off";
Off.value = AURA_MOUSE_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
SetupZones();
}
RGBController_AuraMouse::~RGBController_AuraMouse()
{
}
void RGBController_AuraMouse::SetupZones()
{
zone logo_zone;
logo_zone.name = "Logo";
logo_zone.type = ZONE_TYPE_SINGLE;
logo_zone.leds_min = 1;
logo_zone.leds_max = 1;
logo_zone.leds_count = 1;
logo_zone.matrix_map = NULL;
zones.push_back(logo_zone);
led logo_led;
logo_led.name = "Logo";
leds.push_back(logo_led);
zone scroll_zone;
scroll_zone.name = "Scroll Wheel";
scroll_zone.type = ZONE_TYPE_SINGLE;
scroll_zone.leds_min = 1;
scroll_zone.leds_max = 1;
scroll_zone.leds_count = 1;
scroll_zone.matrix_map = NULL;
zones.push_back(scroll_zone);
led scroll_led;
scroll_led.name = "Scroll Wheel";
leds.push_back(scroll_led);
SetupColors();
}
void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)
{
}
void RGBController_AuraMouse::DeviceUpdateLEDs()
{
DeviceUpdateMode();
}
void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
{
UpdateSingleLED(zone);
}
void RGBController_AuraMouse::UpdateSingleLED(int led)
{
unsigned char red = 0;
unsigned char grn = 0;
unsigned char blu = 0;
if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
{
if(led == 0)
{
red = RGBGetRValue(modes[active_mode].colors[led]);
grn = RGBGetGValue(modes[active_mode].colors[led]);
blu = RGBGetBValue(modes[active_mode].colors[led]);
aura->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu);
}
else
{
red = RGBGetRValue(modes[active_mode].colors[led]);
grn = RGBGetGValue(modes[active_mode].colors[led]);
blu = RGBGetBValue(modes[active_mode].colors[led]);
aura->SendUpdate(AURA_MOUSE_ZONE_SCROLL, modes[active_mode].value, red, grn, blu);
}
}
else
{
aura->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu);
}
}
void RGBController_AuraMouse::SetCustomMode()
{
}
void RGBController_AuraMouse::DeviceUpdateMode()
{
unsigned char red = 0;
unsigned char grn = 0;
unsigned char blu = 0;
if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
{
red = RGBGetRValue(modes[active_mode].colors[0]);
grn = RGBGetGValue(modes[active_mode].colors[0]);
blu = RGBGetBValue(modes[active_mode].colors[0]);
aura->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu);
red = RGBGetRValue(modes[active_mode].colors[1]);
grn = RGBGetGValue(modes[active_mode].colors[1]);
blu = RGBGetBValue(modes[active_mode].colors[1]);
aura->SendUpdate(AURA_MOUSE_ZONE_SCROLL, modes[active_mode].value, red, grn, blu);
}
else
{
aura->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu);
}
}

33
Controllers/AuraUSBController/RGBController_AuraMouse.h Normal file
View File

@@ -0,0 +1,33 @@
/*-----------------------------------------*\
| RGBController_AuraMouse.h |
| |
| Generic RGB Interface for Asus Aura |
| USB controller driver |
| |
| Adam Honse (CalcProgrammer1) 10/25/2020 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AuraMouseController.h"
class RGBController_AuraMouse : public RGBController
{
public:
RGBController_AuraMouse(AuraMouseController* aura_ptr);
~RGBController_AuraMouse();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
AuraMouseController* aura;
};

4
OpenRGB.pro
View File

@@ -136,6 +136,8 @@ HEADERS +=
Controllers/AuraUSBController/AuraUSBController.h \
Controllers/AuraUSBController/AuraAddressableController.h \
Controllers/AuraUSBController/AuraMainboardController.h \
Controllers/AuraUSBController/AuraMouseController.h \
Controllers/AuraUSBController/RGBController_AuraMouse.h \
Controllers/AuraUSBController/RGBController_AuraUSB.h \
Controllers/AuraCoreController/AuraCoreController.h \
Controllers/AuraCoreController/RGBController_AuraCore.h \
@@ -292,7 +294,9 @@ SOURCES +=
Controllers/AuraUSBController/AuraUSBController.cpp \
Controllers/AuraUSBController/AuraAddressableController.cpp \
Controllers/AuraUSBController/AuraMainboardController.cpp \
Controllers/AuraUSBController/AuraMouseController.cpp \
Controllers/AuraUSBController/AuraUSBControllerDetect.cpp \
Controllers/AuraUSBController/RGBController_AuraMouse.cpp \
Controllers/AuraUSBController/RGBController_AuraUSB.cpp \
Controllers/AuraCoreController/AuraCoreController.cpp \
Controllers/AuraCoreController/AuraCoreControllerDetect.cpp \