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/AsusLegacyUSBController/AsusSagarisKeyboardController/AsusSagarisKeyboardController.cpp
+201
View File
@@ -0,0 +1,201 @@
/*---------------------------------------------------------*\
| AsusSagarisKeyboardController.cpp |
| |
| Driver for ASUS Sagaris keyboard |
| |
| Mola19 20 Aug 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include <math.h>
#include <string>
#include <string.h>
#include <vector>
#include "AsusSagarisKeyboardController.h"
#include "LogManager.h"
#include "StringUtils.h"
#define ASUS_SAGARIS_KB_PACKET_SIZE 65
AsusSagarisKeyboardController::AsusSagarisKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
version = rev_version;
}
AsusSagarisKeyboardController::~AsusSagarisKeyboardController()
{
hid_close(dev);
}
std::string AsusSagarisKeyboardController::GetVersion()
{
return std::to_string((int) floor(version / 0x100)) + "." + std::to_string(version % 0x100);
}
std::string AsusSagarisKeyboardController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string AsusSagarisKeyboardController::GetDeviceName()
{
return(name);
}
std::string AsusSagarisKeyboardController::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));
}
sagaris_mode AsusSagarisKeyboardController::GetMode()
{
ClearResponses();
uint8_t usb_buf_out[ASUS_SAGARIS_KB_PACKET_SIZE];
memset(usb_buf_out, 0x00, sizeof(usb_buf_out));
usb_buf_out[0x00] = 0x06;
usb_buf_out[0x01] = 0x0B;
usb_buf_out[0x02] = 0x03;
hid_write(dev, usb_buf_out, ASUS_SAGARIS_KB_PACKET_SIZE);
unsigned char usb_buf_in[ASUS_SAGARIS_KB_PACKET_SIZE];
memset(usb_buf_in, 0x00, sizeof(usb_buf_in));
int return_length = hid_read_timeout(dev, usb_buf_in, ASUS_SAGARIS_KB_PACKET_SIZE, 100);
if(return_length == -1)
{
LOG_DEBUG("[Asus Sagaris GK1100]: Could not fetch mode");
sagaris_mode default_mode;
default_mode.mode = SAGARIS_KEYBOARD_MODE_STATIC;
default_mode.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
default_mode.speed = 0;
default_mode.colorIndex = 0;
return default_mode;
}
sagaris_mode current_mode;
current_mode.mode = usb_buf_in[3];
current_mode.brightness = usb_buf_in[4];
current_mode.speed = usb_buf_in[5];
current_mode.colorIndex = usb_buf_in[6];
return current_mode;
}
std::vector<RGBColor> AsusSagarisKeyboardController::GetColors()
{
ClearResponses();
uint8_t usb_buf_out[ASUS_SAGARIS_KB_PACKET_SIZE];
memset(usb_buf_out, 0x00, sizeof(usb_buf_out));
usb_buf_out[0x00] = 0x06;
usb_buf_out[0x01] = 0x0B;
usb_buf_out[0x02] = 0x05;
hid_write(dev, usb_buf_out, ASUS_SAGARIS_KB_PACKET_SIZE);
std::vector<RGBColor> colors;
colors.resize(7);
for(int i = 0; i < 7; i++)
{
unsigned char usb_buf_in[ASUS_SAGARIS_KB_PACKET_SIZE];
memset(usb_buf_in, 0x00, sizeof(usb_buf_in));
int return_length = hid_read_timeout(dev, usb_buf_in, ASUS_SAGARIS_KB_PACKET_SIZE, 100);
if(return_length == -1)
{
LOG_DEBUG("[Asus Sagaris GK1100]: Could not fetch color %i", i);
colors[i] = ToRGBColor(0, 0, 0);
continue;
}
colors[i] = ToRGBColor(usb_buf_in[4] * 16, usb_buf_in[5] * 16, usb_buf_in[6] * 16);
}
return colors;
}
void AsusSagarisKeyboardController::SetColor
(
uint8_t index,
uint8_t red,
uint8_t green,
uint8_t blue
)
{
uint8_t usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x06;
usb_buf[0x01] = 0x0B;
usb_buf[0x02] = 0x04;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = index;
usb_buf[0x05] = red;
usb_buf[0x06] = green;
usb_buf[0x07] = blue;
hid_write(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE);
}
void AsusSagarisKeyboardController::SetMode
(
uint8_t mode,
uint8_t brightness,
uint8_t speed,
uint8_t colorIndex
)
{
ClearResponses();
uint8_t usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x06;
usb_buf[0x01] = 0x0B;
usb_buf[0x02] = 0x01;
usb_buf[0x03] = mode;
usb_buf[0x04] = brightness;
usb_buf[0x05] = speed;
usb_buf[0x06] = colorIndex;
hid_write(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE);
AwaitResponse(20);
}
void AsusSagarisKeyboardController::AwaitResponse(int ms)
{
unsigned char usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
hid_read_timeout(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE, ms);
}
void AsusSagarisKeyboardController::ClearResponses()
{
int result = 1;
unsigned char usb_buf_flush[65];
while(result > 0)
{
result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
}
}
Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController/AsusSagarisKeyboardController.h
+79
View File
@@ -0,0 +1,79 @@
/*---------------------------------------------------------*\
| AsusSagarisKeyboardController.h |
| |
| Driver for ASUS Sagaris keyboard |
| |
| Mola19 20 Aug 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <vector>
#include <hidapi.h>
#include "RGBController.h"
enum
{
SAGARIS_KEYBOARD_MODE_OFF = 0,
SAGARIS_KEYBOARD_MODE_STATIC = 1,
SAGARIS_KEYBOARD_MODE_SPRIAL = 2,
SAGARIS_KEYBOARD_MODE_CUSTOM = 3,
SAGARIS_KEYBOARD_MODE_BREATHING = 4,
SAGARIS_KEYBOARD_MODE_REACTIVE = 5,
SAGARIS_KEYBOARD_MODE_STARRY_NIGHT = 6,
SAGARIS_KEYBOARD_MODE_LASER = 7,
};
enum
{
SAGARIS_KEYBOARD_BRIGHTNESS_MIN = 0,
SAGARIS_KEYBOARD_BRIGHTNESS_MAX = 3,
SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT = 3
};
enum
{
SAGARIS_KEYBOARD_SPEED_MIN = 0,
SAGARIS_KEYBOARD_SPEED_MAX = 3,
SAGARIS_KEYBOARD_SPEED_DEFAULT = 2
};
typedef struct
{
uint8_t mode;
uint8_t brightness;
uint8_t speed;
uint8_t colorIndex;
} sagaris_mode;
class AsusSagarisKeyboardController
{
public:
AsusSagarisKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version, std::string dev_name);
~AsusSagarisKeyboardController();
std::string GetVersion();
std::string GetDeviceLocation();
std::string GetDeviceName();
std::string GetSerialString();
sagaris_mode GetMode();
std::vector<RGBColor> GetColors();
void SetMode(uint8_t mode, uint8_t brightness, uint8_t speed, uint8_t colorIndex);
void SetColor(uint8_t index, uint8_t red, uint8_t green, uint8_t blue);
void AwaitResponse(int ms);
void ClearResponses();
private:
hid_device* dev;
std::string location;
std::string name;
unsigned short version;
};
Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController/RGBController_AsusSagarisKeyboard.cpp
+250
View File
@@ -0,0 +1,250 @@
/*---------------------------------------------------------*\
| RGBController_AsusSagarisKeyboard.cpp |
| |
| RGBController for ASUS Sagaris keyboard |
| |
| Mola19 20 Aug 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <iostream>
#include <vector>
#include "RGBController_AsusSagarisKeyboard.h"
/**------------------------------------------------------------------*\
@name Asus Sagaris Keyboard
@category Keyboard
@type USB
@save :robot:
@direct :x:
@effects :white_check_mark:
@detectors DetectAsusSagarisKeyboard
@comment Missing controls for modifier keys, as they have independent lighting
\*-------------------------------------------------------------------*/
RGBController_AsusSagarisKeyboard::RGBController_AsusSagarisKeyboard(AsusSagarisKeyboardController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Sagaris Keyboard Device";
version = controller->GetVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Off;
Off.name = "Off";
Off.value = SAGARIS_KEYBOARD_MODE_OFF;
Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Static;
Static.name = "Static";
Static.value = SAGARIS_KEYBOARD_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Static.brightness_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
Static.brightness_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
Static.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(1);
modes.push_back(Static);
mode Spiral;
Spiral.name = "Spiral";
Spiral.value = SAGARIS_KEYBOARD_MODE_SPRIAL;
Spiral.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
Spiral.brightness_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
Spiral.brightness_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
Spiral.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
Spiral.speed_min = SAGARIS_KEYBOARD_SPEED_MIN;
Spiral.speed_max = SAGARIS_KEYBOARD_SPEED_MAX;
Spiral.speed = SAGARIS_KEYBOARD_SPEED_DEFAULT;
Spiral.color_mode = MODE_COLORS_MODE_SPECIFIC;
Spiral.colors_min = 7;
Spiral.colors_max = 7;
Spiral.colors.resize(7);
modes.push_back(Spiral);
mode Custom;
Custom.name = "Custom";
Custom.value = SAGARIS_KEYBOARD_MODE_CUSTOM;
Custom.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Custom.brightness_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
Custom.brightness_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
Custom.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
Custom.color_mode = MODE_COLORS_MODE_SPECIFIC;
Custom.colors_min = 7;
Custom.colors_max = 7;
Custom.colors.resize(7);
modes.push_back(Custom);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = SAGARIS_KEYBOARD_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED;
Breathing.speed_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
Breathing.speed_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
Breathing.speed = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors_min = 7;
Breathing.colors_max = 7;
Breathing.colors.resize(7);
modes.push_back(Breathing);
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = SAGARIS_KEYBOARD_MODE_REACTIVE;
Reactive.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
Reactive.brightness_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
Reactive.brightness_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
Reactive.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
Reactive.speed_min = SAGARIS_KEYBOARD_SPEED_MIN;
Reactive.speed_max = SAGARIS_KEYBOARD_SPEED_MAX;
Reactive.speed = SAGARIS_KEYBOARD_SPEED_DEFAULT;
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
Reactive.colors_min = 1;
Reactive.colors_max = 1;
Reactive.colors.resize(1);
modes.push_back(Reactive);
mode Starry_Night;
Starry_Night.name = "Starry Night";
Starry_Night.value = SAGARIS_KEYBOARD_MODE_STARRY_NIGHT;
Starry_Night.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
Starry_Night.brightness_min = SAGARIS_KEYBOARD_SPEED_MIN;
Starry_Night.brightness_max = SAGARIS_KEYBOARD_SPEED_MAX;
Starry_Night.brightness = SAGARIS_KEYBOARD_SPEED_DEFAULT;
Starry_Night.speed_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
Starry_Night.speed_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
Starry_Night.speed = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
Starry_Night.color_mode = MODE_COLORS_MODE_SPECIFIC;
Starry_Night.colors_min = 7;
Starry_Night.colors_max = 7;
Starry_Night.colors.resize(7);
modes.push_back(Starry_Night);
mode Laser;
Laser.name = "Laser";
Laser.value = SAGARIS_KEYBOARD_MODE_LASER;
Laser.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
Laser.brightness_min = SAGARIS_KEYBOARD_SPEED_MIN;
Laser.brightness_max = SAGARIS_KEYBOARD_SPEED_MAX;
Laser.brightness = SAGARIS_KEYBOARD_SPEED_DEFAULT;
Laser.speed_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
Laser.speed_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
Laser.speed = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
Laser.color_mode = MODE_COLORS_MODE_SPECIFIC;
Laser.colors_min = 7;
Laser.colors_max = 7;
Laser.colors.resize(7);
modes.push_back(Laser);
SetupZones();
sagaris_mode current_mode = controller->GetMode();
active_mode = current_mode.mode;
last_mode = current_mode.mode;
modes[active_mode].brightness = current_mode.brightness;
modes[active_mode].speed = current_mode.speed;
current_colors = controller->GetColors();
for(unsigned int i = 0; i < modes[active_mode].colors.size(); i++)
{
modes[active_mode].colors[i] = current_colors[i];
}
}
RGBController_AsusSagarisKeyboard::~RGBController_AsusSagarisKeyboard()
{
delete controller;
}
void RGBController_AsusSagarisKeyboard::SetupZones()
{
zone keyboard;
keyboard.name = "Keyboard";
keyboard.type = ZONE_TYPE_SINGLE;
keyboard.leds_min = 1;
keyboard.leds_max = 1;
keyboard.leds_count = 1;
keyboard.matrix_map = nullptr;
SetupColors();
}
void RGBController_AsusSagarisKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
{
}
void RGBController_AsusSagarisKeyboard::DeviceUpdateLEDs()
{
}
void RGBController_AsusSagarisKeyboard::UpdateZoneLEDs(int /*zone*/)
{
}
void RGBController_AsusSagarisKeyboard::UpdateSingleLED(int /*led*/)
{
}
void RGBController_AsusSagarisKeyboard::DeviceUpdateMode()
{
if(last_mode != active_mode)
{
last_mode = active_mode;
for(unsigned int i = 0; i < modes[active_mode].colors.size(); i++)
{
modes[active_mode].colors[i] = current_colors[i];
}
}
else
{
for(unsigned int i = 0; i < modes[active_mode].colors.size(); i++)
{
current_colors[i] = modes[active_mode].colors[i];
}
for(unsigned int i = 0; i < modes[active_mode].colors.size(); i++)
{
/*-----------------------------------------*\
| This device uses 4bit colorValues (0-16) |
\*-----------------------------------------*/
uint8_t red = RGBGetRValue(modes[active_mode].colors[i]) / 16;
uint8_t green = RGBGetGValue(modes[active_mode].colors[i]) / 16;
uint8_t blue = RGBGetBValue(modes[active_mode].colors[i]) / 16;
controller->SetColor(i, red, green, blue);
}
}
/*------------------------------------------------------------------------------------------------------*\
| This device uses a global color storage for 7 colors, |
| each time a mode is selected, it is specified which color is chosen (some use all). |
| As OpenRGB doesn't support selecting the color index, color 1 is used for single color modes. |
\*------------------------------------------------------------------------------------------------------*/
uint8_t colorIndex = 0;
uint8_t mode = modes[active_mode].value;
if(mode == SAGARIS_KEYBOARD_MODE_STARRY_NIGHT)
{
colorIndex = 7;
}
controller->SetMode(mode, modes[active_mode].brightness, modes[active_mode].speed, colorIndex);
}
Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController/RGBController_AsusSagarisKeyboard.h
+37
View File
@@ -0,0 +1,37 @@
/*---------------------------------------------------------*\
| RGBController_AsusSagarisKeyboard.h |
| |
| RGBController for ASUS Sagaris keyboard |
| |
| Mola19 20 Aug 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusSagarisKeyboardController.h"
class RGBController_AsusSagarisKeyboard : public RGBController
{
public:
RGBController_AsusSagarisKeyboard(AsusSagarisKeyboardController* controller_ptr);
~RGBController_AsusSagarisKeyboard();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
AsusSagarisKeyboardController* controller;
std::vector<RGBColor> current_colors;
uint8_t last_mode;
};