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/SinowealthController/Sinowealth1007Controller/RGBController_Sinowealth1007.cpp
+253
View File
@@ -0,0 +1,253 @@
/*---------------------------------------------------------*\
| RGBController_Sinowealth1007.cpp |
| |
| RGBController for Sinowealth mice with PID 1007 |
| |
| Moon_darker (Vaker) 02 Feb 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_Sinowealth1007.h"
static const char *led_names[] =
{
"Top Left",
"Middle Left",
"Bottom Left",
"Bottom Middle",
"Bottom Right",
"Middle Right",
"Top Right"
};
/**------------------------------------------------------------------*\
@name Sinowealth 1007 Mouse
@category Mouse
@type USB
@save :x:
@direct :x:
@effects :white_check_mark:
@detectors DetectSinowealthMouse
@comment
\*-------------------------------------------------------------------*/
RGBController_Sinowealth1007::RGBController_Sinowealth1007(SinowealthController1007* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
vendor = "ZET";
type = DEVICE_TYPE_MOUSE;
description = "ZET Fury Pro Mouse Device";
location = controller->GetLocation();
serial = controller->GetSerialString();
mode Custom;
Custom.name = "Custom";
Custom.value = ZET_FURY_PRO_MODE_CUSTOM;
Custom.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_PER_LED_COLOR;
Custom.color_mode = MODE_COLORS_PER_LED;
Custom.speed = ZET_FURY_PRO_SPEED_DEF;
modes.push_back(Custom);
mode Off;
Off.name = "Off";
Off.value = ZET_FURY_PRO_MODE_OFF;
Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
Off.color_mode = MODE_COLORS_NONE;
Off.speed = ZET_FURY_PRO_SPEED_DEF;
Off.brightness = ZET_FURY_PRO_BRIGHTNESS_DEF;
modes.push_back(Off);
mode Rainbow;
Rainbow.name = "Rainbow Wave";
Rainbow.value = ZET_FURY_PRO_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.speed_min = ZET_FURY_PRO_SPEED_MIN;
Rainbow.speed_max = ZET_FURY_PRO_SPEED_MAX;
Rainbow.speed = ZET_FURY_PRO_SPEED_DEF;
Rainbow.direction = MODE_DIRECTION_RIGHT;
modes.push_back(Rainbow);
mode Static;
Static.name = "Static";
Static.value = ZET_FURY_PRO_MODE_STATIC;
Static.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.brightness_min = ZET_FURY_PRO_BRIGHTNESS_MIN;
Static.brightness_max = ZET_FURY_PRO_BRIGHTNESS_MAX;
Static.brightness = ZET_FURY_PRO_BRIGHTNESS_DEF;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(Static.colors_max);
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = ZET_FURY_PRO_MODE_BREATHING;
Breathing.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed_min = ZET_FURY_PRO_SPEED_MIN;
Breathing.speed_max = ZET_FURY_PRO_SPEED_MAX;
Breathing.speed = ZET_FURY_PRO_SPEED_DEF;
Breathing.colors_min = 7;
Breathing.colors_max = 7;
Breathing.colors.resize(Breathing.colors_max);
modes.push_back(Breathing);
mode Pendulum;
Pendulum.name = "Pendulum";
Pendulum.value = ZET_FURY_PRO_MODE_PENDULUM;
Pendulum.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED;
Pendulum.color_mode = MODE_COLORS_NONE;
Pendulum.speed_min = ZET_FURY_PRO_SPEED_MIN;
Pendulum.speed_max = ZET_FURY_PRO_SPEED_MAX;
Pendulum.speed = ZET_FURY_PRO_SPEED_DEF;
modes.push_back(Pendulum);
mode Spectrum;
Spectrum.name = "Spectrum Cycle";
Spectrum.value = ZET_FURY_PRO_MODE_SPECTRUM;
Spectrum.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED;
Spectrum.color_mode = MODE_COLORS_NONE;
Spectrum.speed_min = ZET_FURY_PRO_SPEED_MIN;
Spectrum.speed_max = ZET_FURY_PRO_SPEED_MAX;
Spectrum.speed = ZET_FURY_PRO_SPEED_DEF;
modes.push_back(Spectrum);
mode TwoColors;
TwoColors.name = "Two Colors"; // Should this be called "Flashing Two Colors" or smth like that maybe? Rapidly changes between 2 colors
TwoColors.value = ZET_FURY_PRO_MODE_TWO_COLORS;
TwoColors.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
TwoColors.color_mode = MODE_COLORS_MODE_SPECIFIC;
TwoColors.colors_min = 2;
TwoColors.colors_max = 2;
TwoColors.colors.resize(TwoColors.colors_max);
modes.push_back(TwoColors);
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = ZET_FURY_PRO_MODE_REACTIVE;
Reactive.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
Reactive.color_mode = MODE_COLORS_RANDOM;
Reactive.speed_min = ZET_FURY_PRO_SPEED_MIN;
Reactive.speed_max = ZET_FURY_PRO_SPEED_MAX;
Reactive.speed = ZET_FURY_PRO_SPEED_DEF;
Reactive.colors_min = 7;
Reactive.colors_max = 7;
Reactive.colors.resize(Reactive.colors_max);
modes.push_back(Reactive);
mode Flicker;
Flicker.name = "Flicker"; // One color fluctuates around max brightness for some time, then changes to another
Flicker.value = ZET_FURY_PRO_MODE_FLICKER;
Flicker.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Flicker.color_mode = MODE_COLORS_NONE;
Flicker.speed_min = ZET_FURY_PRO_SPEED_MIN;
Flicker.speed_max = ZET_FURY_PRO_SPEED_MAX;
Flicker.speed = ZET_FURY_PRO_SPEED_DEF;
Flicker.direction = MODE_DIRECTION_RIGHT;
modes.push_back(Flicker);
mode Rain;
Rain.name = "Rain"; // More like bad LSD trip
Rain.value = ZET_FURY_PRO_MODE_RAIN;
Rain.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED;
Rain.color_mode = MODE_COLORS_NONE;
Rain.speed_min = ZET_FURY_PRO_SPEED_MIN;
Rain.speed_max = ZET_FURY_PRO_SPEED_MAX;
Rain.speed = ZET_FURY_PRO_SPEED_DEF;
modes.push_back(Rain);
mode Snake;
Snake.name = "Snake";
Snake.value = ZET_FURY_PRO_MODE_SNAKE;
Snake.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED;
Snake.color_mode = MODE_COLORS_NONE;
Snake.speed_min = ZET_FURY_PRO_SPEED_MIN;
Snake.speed_max = ZET_FURY_PRO_SPEED_MAX;
Snake.speed = ZET_FURY_PRO_SPEED_DEF;
modes.push_back(Snake);
SetupZones();
}
RGBController_Sinowealth1007::~RGBController_Sinowealth1007()
{
delete controller;
}
void RGBController_Sinowealth1007::SetupZones()
{
/*---------------------------------------------------------*\
| Create a single zone |
\*---------------------------------------------------------*/
zone new_zone;
new_zone.name = "Mouse";
new_zone.type = ZONE_TYPE_LINEAR;
new_zone.leds_min = controller->GetLEDCount();
new_zone.leds_max = controller->GetLEDCount();
new_zone.leds_count = controller->GetLEDCount();
new_zone.matrix_map = NULL;
zones.push_back(new_zone);
/*---------------------------------------------------------*\
| Set up LEDs |
\*---------------------------------------------------------*/
for (unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
{
led new_led;
new_led.name = led_names[led_idx];
leds.push_back(new_led);
}
SetupColors();
}
void RGBController_Sinowealth1007::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_Sinowealth1007::DeviceUpdateLEDs()
{
controller->SetLEDColors(colors);
}
void RGBController_Sinowealth1007::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_Sinowealth1007::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_Sinowealth1007::DeviceUpdateMode()
{
unsigned char random = (modes[active_mode].flags & MODE_FLAG_HAS_RANDOM_COLOR) ? (unsigned char)ZET_FURY_PRO_SUBMODE_SET_COLOR : 0x00;
random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM) ? (unsigned char)ZET_FURY_PRO_SUBMODE_RANDOM : random;
if (modes[active_mode].value == ZET_FURY_PRO_MODE_BREATHING)
{
random = ZET_FURY_PRO_SUBMODE_SET_COLOR; // An unfortunate exception that has no random option but requires this
}
if (!(modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR))
{
modes[active_mode].direction = MODE_DIRECTION_RIGHT; // Left and right are backwards, and we don't want to always append 0x80
}
controller->SetMode(modes[active_mode].value,
(modes[active_mode].speed ? modes[active_mode].speed : modes[active_mode].brightness),
modes[active_mode].direction ? ZET_FURY_PRO_DIR_RIGHT : ZET_FURY_PRO_DIR_LEFT,
modes[active_mode].colors,
random,
(modes[active_mode].color_mode == MODE_COLORS_PER_LED));
}
Controllers/SinowealthController/Sinowealth1007Controller/RGBController_Sinowealth1007.h
+34
View File
@@ -0,0 +1,34 @@
/*---------------------------------------------------------*\
| RGBController_Sinowealth1007.h |
| |
| RGBController for Sinowealth mice with PID 1007 |
| |
| Moon_darker (Vaker) 25 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "SinowealthController1007.h"
class RGBController_Sinowealth1007 : public RGBController
{
public:
RGBController_Sinowealth1007(SinowealthController1007* controller_ptr);
~RGBController_Sinowealth1007();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
SinowealthController1007* controller;
};
Controllers/SinowealthController/Sinowealth1007Controller/SinowealthController1007.cpp
+128
View File
@@ -0,0 +1,128 @@
/*---------------------------------------------------------*\
| SinowealthController1007.cpp |
| |
| Driver for Sinowealth mice with PID 1007 |
| |
| Moon_darker (Vaker) 02 Feb 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "LogManager.h"
#include "SinowealthController1007.h"
#include "StringUtils.h"
SinowealthController1007::SinowealthController1007(hid_device* dev, char *_path, std::string dev_name)
{
this->dev = dev;
this->location = _path;
this->name = dev_name;
this->led_count = 7;
this->current_mode = ZET_FURY_PRO_MODE_CUSTOM + ZET_FURY_PRO_SPEED_DEF;
this->current_direction = ZET_FURY_PRO_DIR_RIGHT;
memset(device_colors, 0x00, sizeof(device_colors));
}
SinowealthController1007::~SinowealthController1007()
{
hid_close(dev);
}
std::string SinowealthController1007::GetLocation()
{
return("HID: " + location);
}
std::string SinowealthController1007::GetName()
{
return(name);
}
unsigned int SinowealthController1007::GetLEDCount()
{
return(led_count);
}
std::string SinowealthController1007::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));
}
void SinowealthController1007::SetLEDColors(const std::vector<RGBColor>& colors)
{
memset(device_colors, 0x00, sizeof(device_colors));
unsigned int color_counter = 0;
for (RGBColor color: colors)
{
unsigned int pkt_pointer = (color_counter * 3); // 3 bytes per color
device_colors[pkt_pointer] = RGBGetRValue(color);
device_colors[pkt_pointer + 1] = RGBGetGValue(color);
device_colors[pkt_pointer + 2] = RGBGetBValue(color);
if (++color_counter == 7) break;
}
SendPacket();
}
void SinowealthController1007::SetMode(
unsigned char mode,
unsigned char spd_or_lum,
unsigned char direction,
const std::vector<RGBColor>& colors,
unsigned char random,
bool has_per_led_colors)
{
current_mode = mode + (spd_or_lum ? spd_or_lum : ZET_FURY_PRO_SPEED_DEF);
current_direction = random ? random : direction;
if (!has_per_led_colors)
{
memset(device_colors, 0x00, sizeof(device_colors));
SetLEDColors(colors);
}
}
void SinowealthController1007::SendPacket()
{
if (GetProfile() < 0) return;
unsigned char usb_buf[ZET_FURY_PRO_STATE_BUFFER_LENGTH];
memcpy(usb_buf, device_configuration, sizeof(usb_buf));
memcpy(usb_buf + 23, device_colors, sizeof(device_colors)); // colors are bytes 23-43 in RGB format counting from 0
usb_buf[21] = current_mode;
usb_buf[22] = current_direction;
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
}
int SinowealthController1007::GetProfile()
{
int bytesReceived;
memset(device_configuration, 0x00, ZET_FURY_PRO_STATE_BUFFER_LENGTH);
device_configuration[0] = 0x04;
bytesReceived = hid_get_feature_report(dev, device_configuration, ZET_FURY_PRO_STATE_BUFFER_LENGTH);
if (bytesReceived < 0)
{
LOG_ERROR("[ZET Fury Pro] Error reading device configuration!");
}
return bytesReceived;
}
Controllers/SinowealthController/Sinowealth1007Controller/SinowealthController1007.h
+84
View File
@@ -0,0 +1,84 @@
/*---------------------------------------------------------*\
| SinowealthController1007.h |
| |
| Driver for Sinowealth mice with PID 1007 |
| |
| Moon_darker (Vaker) 25 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <vector>
#include <hidapi.h>
#include "RGBController.h"
#define ZET_FURY_PRO_STATE_BUFFER_LENGTH 59
#define ZET_FURY_PRO_COLOR_BUFFER_LENGTH 21
#define ZET_FURY_PRO_BRIGHTNESS_MIN 1
#define ZET_FURY_PRO_BRIGHTNESS_MAX 9
#define ZET_FURY_PRO_BRIGHTNESS_DEF 9
#define ZET_FURY_PRO_SPEED_MIN 1
#define ZET_FURY_PRO_SPEED_MAX 3
#define ZET_FURY_PRO_SPEED_DEF 2
enum
{
ZET_FURY_PRO_MODE_OFF = 0x00,
ZET_FURY_PRO_MODE_RAINBOW = 0x10,
ZET_FURY_PRO_MODE_STATIC = 0x20,
ZET_FURY_PRO_MODE_BREATHING = 0x30,
ZET_FURY_PRO_MODE_PENDULUM = 0x40,
ZET_FURY_PRO_MODE_SPECTRUM = 0x50,
ZET_FURY_PRO_MODE_CUSTOM = 0x60,
ZET_FURY_PRO_MODE_TWO_COLORS = 0x70,
ZET_FURY_PRO_MODE_REACTIVE = 0x80,
ZET_FURY_PRO_MODE_FLICKER = 0x90,
ZET_FURY_PRO_MODE_RAIN = 0xA0,
ZET_FURY_PRO_MODE_SNAKE = 0xB0,
};
enum
{
ZET_FURY_PRO_SUBMODE_SET_COLOR = 0x07,
ZET_FURY_PRO_SUBMODE_RANDOM = 0x80,
};
enum
{
ZET_FURY_PRO_DIR_LEFT = 0x80,
ZET_FURY_PRO_DIR_RIGHT = 0x00,
};
class SinowealthController1007
{
public:
SinowealthController1007(hid_device* dev, char *_path, std::string dev_name);
~SinowealthController1007();
unsigned int GetLEDCount();
std::string GetLocation();
std::string GetName();
std::string GetSerialString();
void SetLEDColors(const std::vector<RGBColor>& colors);
void SetMode(unsigned char mode, unsigned char spd_or_lum, unsigned char direction, const std::vector<RGBColor>& colors, unsigned char random, bool has_per_led_colors);
int GetProfile();
void SendPacket();
private:
hid_device* dev;
unsigned int led_count;
unsigned char current_mode;
unsigned char current_direction;
unsigned char device_configuration[ZET_FURY_PRO_STATE_BUFFER_LENGTH];
unsigned char device_colors[ZET_FURY_PRO_COLOR_BUFFER_LENGTH];
std::string location;
std::string name;
};