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/AsusAuraMousematController/AsusAuraMousematController.cpp
+140
View File
@@ -0,0 +1,140 @@
/*---------------------------------------------------------*\
| AsusAuraMousematController.cpp |
| |
| Driver for ASUS Aura mousemat |
| |
| Adam Honse (CalcProgrammer1) 10 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "AsusAuraMousematController.h"
#include "StringUtils.h"
AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
}
AuraMousematController::~AuraMousematController()
{
hid_close(dev);
}
std::string AuraMousematController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string AuraMousematController::GetName()
{
return(name);
}
std::string AuraMousematController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string AuraMousematController::GetVersion()
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0xEE;
usb_buf[0x01] = 0x12;
usb_buf[0x02] = 0x00;
hid_write(dev, usb_buf, 65);
unsigned char usb_buf_out[65];
hid_read(dev, usb_buf_out, 65);
char version[9];
snprintf(version, 9, "%X.%02X.%02X", usb_buf_out[6], usb_buf_out[7], usb_buf_out[8]);
return std::string(version);
}
void AuraMousematController::UpdateLeds
(
std::vector<RGBColor> colors
)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0xEE;
usb_buf[0x01] = 0xC0;
usb_buf[0x02] = 0x81;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = 0x00;
for(unsigned int i = 0; i < 60; i += 4)
{
usb_buf[5 + i] = 0x00;
usb_buf[6 + i] = RGBGetRValue(colors[i / 4]);
usb_buf[7 + i] = RGBGetGValue(colors[i / 4]);
usb_buf[8 + i] = RGBGetBValue(colors[i / 4]);
}
hid_write(dev, usb_buf, 65);
}
void AuraMousematController::UpdateDevice
(
unsigned char mode,
std::vector<RGBColor> colors,
unsigned char speed,
unsigned char brightness,
unsigned char pattern
)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0xEE;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x28;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = mode;
usb_buf[0x06] = speed;
usb_buf[0x07] = brightness;
usb_buf[0x08] = pattern;
usb_buf[0x09] = 0x00;
for(unsigned int i = 0; i < colors.size(); i++)
{
usb_buf[0x0a + i * 3] = RGBGetRValue(colors[i]);
usb_buf[0x0b + i * 3] = RGBGetGValue(colors[i]);
usb_buf[0x0c + i * 3] = RGBGetBValue(colors[i]);
}
hid_write(dev, usb_buf, 65);
}
void AuraMousematController::SaveMode()
{
unsigned char usb_save_buf[65];
memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
usb_save_buf[0x00] = 0xEE;
usb_save_buf[0x01] = 0x50;
usb_save_buf[0x02] = 0x03;
hid_write(dev, usb_save_buf, 65);
}
Controllers/AsusAuraUSBController/AsusAuraMousematController/AsusAuraMousematController.h
+62
View File
@@ -0,0 +1,62 @@
/*---------------------------------------------------------*\
| AsusAuraMousematController.h |
| |
| Driver for ASUS Aura mousemat |
| |
| Adam Honse (CalcProgrammer1) 10 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <hidapi.h>
#include "RGBController.h"
enum
{
AURA_MOUSEMAT_MODE_STATIC = 0,
AURA_MOUSEMAT_MODE_BREATHING = 1,
AURA_MOUSEMAT_MODE_COLOR_CYCLE = 2,
AURA_MOUSEMAT_MODE_WAVE = 3,
AURA_MOUSEMAT_MODE_WAVE_PLANE = 4,
AURA_MOUSEMAT_MODE_COMET = 5,
AURA_MOUSEMAT_MODE_GLOWING_YOYO = 6,
AURA_MOUSEMAT_MODE_CROSS = 7,
AURA_MOUSEMAT_MODE_STARRY_NIGHT = 8,
AURA_MOUSEMAT_MODE_DIRECT = 0xFF,
};
class AuraMousematController
{
public:
AuraMousematController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~AuraMousematController();
std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString();
std::string GetVersion();
void UpdateLeds
(
std::vector<RGBColor> colors
);
void UpdateDevice
(
unsigned char mode,
std::vector<RGBColor> colors,
unsigned char speed,
unsigned char brightness,
unsigned char pattern
);
void SaveMode();
private:
hid_device* dev;
std::string location;
std::string name;
};
Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.cpp
+300
View File
@@ -0,0 +1,300 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraMousemat.cpp |
| |
| RGBController for ASUS Aura mousemat |
| |
| Adam Honse (CalcProgrammer1) 10 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_AsusAuraMousemat.h"
/**------------------------------------------------------------------*\
@name Asus Aura Mousemat
@category Mousemat
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraUSBMousemats
@comment
\*-------------------------------------------------------------------*/
RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_MOUSEMAT;
description = "ASUS Aura Mousemat Device";
version = controller->GetVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = AURA_MOUSEMAT_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Static;
Static.name = "Static";
Static.value = AURA_MOUSEMAT_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
Static.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
Static.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(1);
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = AURA_MOUSEMAT_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC | MODE_COLORS_RANDOM;
Breathing.speed_min = AURA_MOUSEMAT_SPEED_MIN;
Breathing.speed_max = AURA_MOUSEMAT_SPEED_MAX;
Breathing.speed = AURA_MOUSEMAT_SPEED_DEFAULT_BREATHING;
Breathing.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
Breathing.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
Breathing.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
Breathing.colors_min = 1;
Breathing.colors_max = 2;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode ColorCycle;
ColorCycle.name = "Color Cycle";
ColorCycle.value = AURA_MOUSEMAT_MODE_COLOR_CYCLE;
ColorCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
ColorCycle.color_mode = MODE_COLORS_NONE;
ColorCycle.speed_min = AURA_MOUSEMAT_SPEED_MIN;
ColorCycle.speed_max = AURA_MOUSEMAT_SPEED_MAX;
ColorCycle.speed = AURA_MOUSEMAT_SPEED_DEFAULT_COLOR_CYCLE;
ColorCycle.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
ColorCycle.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
ColorCycle.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
modes.push_back(ColorCycle);
mode Wave;
Wave.name = "Wave";
Wave.value = AURA_MOUSEMAT_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
Wave.speed_min = AURA_MOUSEMAT_SPEED_MIN;
Wave.speed_max = AURA_MOUSEMAT_SPEED_MAX;
Wave.speed = AURA_MOUSEMAT_SPEED_DEFAULT_WAVE;
Wave.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
Wave.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
Wave.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
Wave.direction = MODE_DIRECTION_LEFT;
Wave.colors_min = 7;
Wave.colors_max = 7;
Wave.colors.resize(7);
modes.push_back(Wave);
mode WavePlane;
WavePlane.name = "Wave Plane";
WavePlane.value = AURA_MOUSEMAT_MODE_WAVE_PLANE;
WavePlane.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE;
WavePlane.color_mode = MODE_COLORS_NONE;
WavePlane.speed_min = AURA_MOUSEMAT_SPEED_MIN;
WavePlane.speed_max = AURA_MOUSEMAT_SPEED_MAX;
WavePlane.speed = AURA_MOUSEMAT_SPEED_DEFAULT_WAVE_PLANE;
WavePlane.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
WavePlane.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
WavePlane.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
WavePlane.direction = MODE_DIRECTION_LEFT;
modes.push_back(WavePlane);
mode Comet;
Comet.name = "Comet";
Comet.value = AURA_MOUSEMAT_MODE_COMET;
Comet.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE;
Comet.color_mode = MODE_COLORS_MODE_SPECIFIC;
Comet.speed_min = AURA_MOUSEMAT_SPEED_MIN;
Comet.speed_max = AURA_MOUSEMAT_SPEED_MAX;
Comet.speed = AURA_MOUSEMAT_SPEED_DEFAULT_COMET;
Comet.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
Comet.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
Comet.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
Comet.direction = MODE_DIRECTION_LEFT;
Comet.colors_min = 1;
Comet.colors_max = 1;
Comet.colors.resize(1);
modes.push_back(Comet);
mode GlowingYoyo;
GlowingYoyo.name = "Glowing Yoyo";
GlowingYoyo.value = AURA_MOUSEMAT_MODE_GLOWING_YOYO;
GlowingYoyo.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
GlowingYoyo.color_mode = MODE_COLORS_NONE;
GlowingYoyo.speed_min = AURA_MOUSEMAT_SPEED_MIN;
GlowingYoyo.speed_max = AURA_MOUSEMAT_SPEED_MAX;
GlowingYoyo.speed = AURA_MOUSEMAT_SPEED_DEFAULT_GLOWING_YOYO;
GlowingYoyo.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
GlowingYoyo.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
GlowingYoyo.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
GlowingYoyo.direction = MODE_DIRECTION_LEFT;
modes.push_back(GlowingYoyo);
mode Cross;
Cross.name = "Cross";
Cross.value = AURA_MOUSEMAT_MODE_CROSS;
Cross.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Cross.color_mode = MODE_COLORS_MODE_SPECIFIC;
Cross.speed_min = AURA_MOUSEMAT_SPEED_MIN;
Cross.speed_max = AURA_MOUSEMAT_SPEED_MAX;
Cross.speed = AURA_MOUSEMAT_SPEED_DEFAULT_CROSS;
Cross.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
Cross.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
Cross.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
Cross.colors_min = 2;
Cross.colors_max = 2;
Cross.colors.resize(2);
modes.push_back(Cross);
mode StarryNight;
StarryNight.name = "Starry Night";
StarryNight.value = AURA_MOUSEMAT_MODE_STARRY_NIGHT;
StarryNight.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
StarryNight.color_mode = MODE_COLORS_MODE_SPECIFIC | MODE_COLORS_RANDOM;
StarryNight.speed_min = AURA_MOUSEMAT_SPEED_MIN;
StarryNight.speed_max = AURA_MOUSEMAT_SPEED_MAX;
StarryNight.speed = AURA_MOUSEMAT_SPEED_DEFAULT_STARRY_NIGHT;
StarryNight.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
StarryNight.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
StarryNight.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
StarryNight.colors_min = 2;
StarryNight.colors_max = 2;
StarryNight.colors.resize(2);
modes.push_back(StarryNight);
SetupZones();
}
RGBController_AuraMousemat::~RGBController_AuraMousemat()
{
delete controller;
}
void RGBController_AuraMousemat::SetupZones()
{
zone mousemat_zone;
mousemat_zone.name = "Mousemat";
mousemat_zone.type = ZONE_TYPE_LINEAR;
mousemat_zone.leds_min = 15;
mousemat_zone.leds_max = 15;
mousemat_zone.leds_count = 15;
mousemat_zone.matrix_map = NULL;
zones.push_back(mousemat_zone);
for(unsigned int i = 0; i < 15; i++)
{
led mousemat_led;
mousemat_led.name = "Mousemat LED " + std::to_string(i);
leds.push_back(mousemat_led);
}
SetupColors();
}
void RGBController_AuraMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AuraMousemat::DeviceUpdateLEDs()
{
controller->UpdateLeds(std::vector<RGBColor>(colors));
}
void RGBController_AuraMousemat::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraMousemat::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraMousemat::DeviceUpdateMode()
{
if(modes[active_mode].value == AURA_MOUSEMAT_MODE_DIRECT)
{
DeviceUpdateLEDs();
}
else
{
int pattern = 0;
switch(modes[active_mode].value)
{
case AURA_MOUSEMAT_MODE_BREATHING:
if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
{
pattern = 2;
}
else
{
pattern = (int)modes[active_mode].colors.size() - 1;
}
break;
case AURA_MOUSEMAT_MODE_WAVE:
pattern = (int)modes[active_mode].colors.size() * 16 + modes[active_mode].direction;
break;
case AURA_MOUSEMAT_MODE_WAVE_PLANE:
switch(modes[active_mode].direction)
{
case MODE_DIRECTION_LEFT:
pattern = 2;
break;
case MODE_DIRECTION_RIGHT:
pattern = 3;
break;
case MODE_DIRECTION_UP:
pattern = 0;
break;
case MODE_DIRECTION_DOWN:
pattern = 1;
break;
}
break;
case AURA_MOUSEMAT_MODE_COMET:
pattern = modes[active_mode].direction;
if(pattern == MODE_DIRECTION_HORIZONTAL || pattern == MODE_DIRECTION_VERTICAL) pattern = 2;
break;
case AURA_MOUSEMAT_MODE_GLOWING_YOYO:
pattern = modes[active_mode].direction;
break;
case AURA_MOUSEMAT_MODE_STARRY_NIGHT:
pattern = 16 + (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
break;
default:
pattern = 255;
break;
}
controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), modes[active_mode].speed, modes[active_mode].brightness, pattern);
}
}
void RGBController_AuraMousemat::DeviceSaveMode()
{
DeviceUpdateMode();
controller->SaveMode();
}
Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.h
+54
View File
@@ -0,0 +1,54 @@
/*---------------------------------------------------------*\
| RGBController_AsusAuraMousemat.h |
| |
| RGBController for ASUS Aura mousemat |
| |
| Mola19 06 Apr 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusAuraMousematController.h"
enum
{
AURA_MOUSEMAT_BRIGHTNESS_MIN = 0,
AURA_MOUSEMAT_BRIGHTNESS_MAX = 4,
AURA_MOUSEMAT_BRIGHTNESS_DEFAULT = 4,
AURA_MOUSEMAT_SPEED_MIN = 127,
AURA_MOUSEMAT_SPEED_MAX = 0,
AURA_MOUSEMAT_SPEED_DEFAULT_STATIC = 0,
AURA_MOUSEMAT_SPEED_DEFAULT_BREATHING = 1,
AURA_MOUSEMAT_SPEED_DEFAULT_COLOR_CYCLE = 1,
AURA_MOUSEMAT_SPEED_DEFAULT_WAVE = 14,
AURA_MOUSEMAT_SPEED_DEFAULT_WAVE_PLANE = 2,
AURA_MOUSEMAT_SPEED_DEFAULT_COMET = 2,
AURA_MOUSEMAT_SPEED_DEFAULT_GLOWING_YOYO = 4,
AURA_MOUSEMAT_SPEED_DEFAULT_CROSS = 12,
AURA_MOUSEMAT_SPEED_DEFAULT_STARRY_NIGHT = 2,
};
class RGBController_AuraMousemat : public RGBController
{
public:
RGBController_AuraMousemat(AuraMousematController* controller_ptr);
~RGBController_AuraMousemat();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
AuraMousematController* controller;
};