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/SinowealthGMOWController/RGBController_SinowealthGMOW.cpp
+193
View File
@@ -0,0 +1,193 @@
/*---------------------------------------------------------*\
| RGBController_SinowealthGMOW.cpp |
| |
| RGBController for Glorious Model O Wireless |
| |
| Matt Silva (thesilvanator) May 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
/**------------------------------------------------------------------*\
@name Sinowealth Glorious Model O Wireless
@type USB
@save :white_check_mark:
@direct :x:
@effects :white_check_mark:
@detectors DetectSinowealthMouse
@comment
\*-------------------------------------------------------------------*/
#include "RGBController_SinowealthGMOW.h"
RGBController_GMOW::RGBController_GMOW(SinowealthGMOWController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
type = DEVICE_TYPE_MOUSE;
description = "Sinowealth Device";
location = controller->GetLocation();
serial = controller->GetSerialString();
version = controller->GetFirmwareVersion();
mode Off;
Off.name = "Off";
Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
Off.color_mode = MODE_COLORS_NONE;
Off.value = GMOW_MODE_OFF;
modes.push_back(Off);
mode RainbowWave;
RainbowWave.name = "Rainbow Wave";
RainbowWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
RainbowWave.speed_min = GMOW_SPEED1_MIN;
RainbowWave.speed = GMOW_SPEED1_MID;
RainbowWave.speed_max = GMOW_SPEED1_MAX;
RainbowWave.direction = MODE_DIRECTION_UP;
RainbowWave.color_mode = MODE_COLORS_NONE;
RainbowWave.brightness_min = GMOW_BRIGHTNESS_MIN;
RainbowWave.brightness = GMOW_BRIGHTNESS_MID;
RainbowWave.brightness_max = GMOW_BRIGHTNESS_MAX;
RainbowWave.value = GMOW_MODE_RAINBOW_WAVE;
modes.push_back(RainbowWave);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
SpectrumCycle.speed_min = GMOW_SPEED1_MIN;
SpectrumCycle.speed = GMOW_SPEED1_MID;
SpectrumCycle.speed_max = GMOW_SPEED1_MAX;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
SpectrumCycle.brightness_min = GMOW_BRIGHTNESS_MIN;
SpectrumCycle.brightness = GMOW_BRIGHTNESS_MID;
SpectrumCycle.brightness_max = GMOW_BRIGHTNESS_MAX;
SpectrumCycle.value = GMOW_MODE_SPECTRUM_CYCLE;
modes.push_back(SpectrumCycle);
mode CustomBreathing;
CustomBreathing.name = "Custom Breathing";
CustomBreathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
CustomBreathing.speed_min = GMOW_SPEED1_MIN;
CustomBreathing.speed = GMOW_SPEED1_MID;
CustomBreathing.speed_max = GMOW_SPEED1_MAX;
CustomBreathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
CustomBreathing.colors_min = 2;
CustomBreathing.colors_max = 7;
CustomBreathing.brightness_min = GMOW_BRIGHTNESS_MIN;
CustomBreathing.brightness = GMOW_BRIGHTNESS_MID;
CustomBreathing.brightness_max = GMOW_BRIGHTNESS_MAX;
CustomBreathing.value = GMOW_MODE_CUSTOM_BREATHING;
CustomBreathing.colors.resize(7);
modes.push_back(CustomBreathing);
mode Static;
Static.name = "Static";
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_min = 1;
Static.colors_max = 1;
Static.brightness_min = GMOW_BRIGHTNESS_MIN;
Static.brightness = GMOW_BRIGHTNESS_MID;
Static.brightness_max = GMOW_BRIGHTNESS_MAX;
Static.value = GMOW_MODE_STATIC;
Static.colors.resize(1);
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Breathing.speed_min = GMOW_SPEED1_MIN;
Breathing.speed = GMOW_SPEED1_MID;
Breathing.speed_max = GMOW_SPEED1_MAX;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.brightness_min = GMOW_BRIGHTNESS_MIN;
Breathing.brightness = GMOW_BRIGHTNESS_MID;
Breathing.brightness_max = GMOW_BRIGHTNESS_MAX;
Breathing.value = GMOW_MODE_BREATHING;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode Tail;
Tail.name = "Tail";
Tail.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Tail.speed_min = GMOW_SPEED1_MIN;
Tail.speed = GMOW_SPEED1_MID;
Tail.speed_max = GMOW_SPEED1_MAX;
Tail.color_mode = MODE_COLORS_NONE;
Tail.brightness_min = GMOW_BRIGHTNESS_MIN;
Tail.brightness = GMOW_BRIGHTNESS_MID;
Tail.brightness_max = GMOW_BRIGHTNESS_MAX;
Tail.value = GMOW_MODE_TAIL;
modes.push_back(Tail);
mode Rave;
Rave.name = "Rave";
Rave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Rave.speed_min = GMOW_SPEED2_MIN;
Rave.speed = GMOW_SPEED2_MID;
Rave.speed_max = GMOW_SPEED2_MAX;
Rave.color_mode = MODE_COLORS_MODE_SPECIFIC;
Rave.colors_min = 1;
Rave.colors_max = 2;
Rave.brightness_min = GMOW_BRIGHTNESS_MIN;
Rave.brightness = GMOW_BRIGHTNESS_MID;
Rave.brightness_max = GMOW_BRIGHTNESS_MAX;
Rave.value = GMOW_MODE_RAVE;
Rave.colors.resize(2);
modes.push_back(Rave);
mode Wave;
Wave.name = "Wave";
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Wave.speed_min = GMOW_SPEED2_MIN;
Wave.speed = GMOW_SPEED2_MID;
Wave.speed_max = GMOW_SPEED2_MAX;
Wave.color_mode = MODE_COLORS_NONE;
Wave.brightness_min = GMOW_BRIGHTNESS_MIN;
Wave.brightness = GMOW_BRIGHTNESS_MID;
Wave.brightness_max = GMOW_BRIGHTNESS_MAX;
Wave.value = GMOW_MODE_WAVE;
modes.push_back(Wave);
SetupZones();
}
RGBController_GMOW::~RGBController_GMOW()
{
delete controller;
}
void RGBController_GMOW::SetupZones()
{
}
void RGBController_GMOW::ResizeZone(int /*zone*/, int /*new_size*/)
{
}
void RGBController_GMOW::DeviceUpdateLEDs()
{
}
void RGBController_GMOW::UpdateZoneLEDs(int /*zone*/)
{
}
void RGBController_GMOW::UpdateSingleLED(int /*led*/)
{
}
void RGBController_GMOW::DeviceUpdateMode()
{
mode curr = modes[active_mode];
controller->SetMode(active_mode, curr.speed,curr.brightness, curr.brightness, curr.colors.data(), (unsigned char)curr.colors.size());
}
Controllers/SinowealthController/SinowealthGMOWController/RGBController_SinowealthGMOW.h
+34
View File
@@ -0,0 +1,34 @@
/*---------------------------------------------------------*\
| RGBController_SinowealthGMOW.h |
| |
| RGBController for Glorious Model O Wireless |
| |
| Matt Silva (thesilvanator) May 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "SinowealthGMOWController.h"
class RGBController_GMOW : public RGBController
{
public:
RGBController_GMOW(SinowealthGMOWController* sinowealth_ptr);
~RGBController_GMOW();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
SinowealthGMOWController* controller;
};
Controllers/SinowealthController/SinowealthGMOWController/SinowealthGMOWController.cpp
+241
View File
@@ -0,0 +1,241 @@
/*---------------------------------------------------------*\
| SinowealthGMOWController.cpp |
| |
| Driver for Glorious Model O Wireless |
| |
| Matt Silva (thesilvanator) May 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include <iostream>
#include "LogManager.h"
#include "SinowealthGMOWController.h"
#include "StringUtils.h"
SinowealthGMOWController::SinowealthGMOWController(hid_device* dev_handle, char *_path, int _type, std::string dev_name)
{
dev = dev_handle;
location = _path;
name = dev_name;
type = _type;
memset(mode_packet,0x00, GMOW_PACKET_SIZE);
mode_packet[0x03] = 0x02;
mode_packet[0x05] = 0x02;
mode_packet[0x07] = 0x01;
mode_packet[0x08] = 0xFF;
memset(wired_packet,0x00, GMOW_PACKET_SIZE);
wired_packet[0x03] = 0x02;
wired_packet[0x04] = 0x02;
wired_packet[0x05] = 0x02;
wired_packet[0x06] = 0x02;
wired_packet[0x07] = 0x01;
memcpy(less_packet, wired_packet, GMOW_PACKET_SIZE);
less_packet[0x07] = 0x00;
}
SinowealthGMOWController::~SinowealthGMOWController()
{
hid_close(dev);
}
std::string SinowealthGMOWController::GetLocation()
{
return("HID: " + location);
}
std::string SinowealthGMOWController::GetName()
{
return(name);
}
std::string SinowealthGMOWController::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 SinowealthGMOWController::GetFirmwareVersion()
{
using namespace std::chrono_literals;
unsigned char buf_send[GMOW_PACKET_SIZE] = {0};
unsigned char buf_receive[GMOW_PACKET_SIZE] = {0};
if(type == GMOW_CABLE_CONNECTED)
{
buf_send[0x03] = 0x02;
}
buf_send[0x04] = 0x03;
buf_send[0x06] = 0x81;
hid_send_feature_report(dev,buf_send, GMOW_PACKET_SIZE);
std::this_thread::sleep_for(50ms);
hid_get_feature_report(dev,buf_receive,GMOW_PACKET_SIZE);
char str[128] = {0};
snprintf(str,128,"%d.%d.%d.%d", buf_receive[7],
buf_receive[8],
buf_receive[9],
buf_receive[10]);
return std::string(str);
}
void SinowealthGMOWController::SetMode(unsigned char mode,
unsigned char speed,
unsigned char wired_brightness,
unsigned char less_brightness,
RGBColor* color_buf,
unsigned char color_count)
{
using namespace std::chrono_literals;
unsigned char mode_buff[GMOW_PACKET_SIZE];
memcpy(mode_buff, mode_packet, GMOW_PACKET_SIZE);
mode_buff[0x09] = mode;
unsigned char wired_buff[GMOW_PACKET_SIZE];
memcpy(wired_buff, wired_packet, GMOW_PACKET_SIZE);
wired_buff[0x08] = wired_brightness;
unsigned char less_buff[GMOW_PACKET_SIZE];
memcpy(less_buff, less_packet, GMOW_PACKET_SIZE);
less_buff[0x08] = less_brightness;
switch (mode)
{
case GMOW_MODE_RAINBOW_WAVE:
mode_buff[0x04] = 0x05;
mode_buff[0x0B] = speed;
break;
case GMOW_MODE_SPECTRUM_CYCLE:
mode_buff[0x04] = 0x05;
mode_buff[0x0B] = speed;
mode_buff[0x0C] = 0xFF;
break;
case GMOW_MODE_CUSTOM_BREATHING:
{
mode_buff[0x04] = color_count * 3 + 5;
mode_buff[0x0B] = speed;
for(unsigned int i = 0; i < color_count; i++)
{
unsigned char r = (char)RGBGetRValue(color_buf[i]);
unsigned char g = (char)RGBGetGValue(color_buf[i]);
unsigned char b = (char)RGBGetBValue(color_buf[i]);
if(r == 0x00 && g == 0x00 && b == 0x00)
{
r = 0x01;
}
mode_buff[0x0C + 3*i + 0] = r;
mode_buff[0x0C + 3*i + 1] = g;
mode_buff[0x0C + 3*i + 2] = b;
}
}
break;
case GMOW_MODE_STATIC:
{
mode_buff[0x04] = 0x05;
mode_buff[0x0B] = 0x09; // rate is replaced with 9
unsigned char r = (char)RGBGetRValue(color_buf[0]);
unsigned char g = (char)RGBGetGValue(color_buf[0]);
unsigned char b = (char)RGBGetBValue(color_buf[0]);
if(r == 0 && g == 0 && b == 0)
{
r = 1;
}
mode_buff[0x0C] = r;
mode_buff[0x0D] = g;
mode_buff[0x0E] = b;
}
break;
case GMOW_MODE_BREATHING:
{
mode_buff[0x04] = 0x08;
mode_buff[0x0B] = speed;
unsigned char r = (char)RGBGetRValue(color_buf[0]);
unsigned char g = (char)RGBGetGValue(color_buf[0]);
unsigned char b = (char)RGBGetBValue(color_buf[0]);
if(r == 0 && g == 0 && b == 0)
{
r = 1;
}
mode_buff[0x0C] = r;
mode_buff[0x0D] = g;
mode_buff[0x0E] = b;
}
break;
case GMOW_MODE_TAIL:
mode_buff[0x04] = 0x05;
mode_buff[0x0B] = speed;
break;
case GMOW_MODE_RAVE:
{
mode_buff[0x04] = color_count * 3 + 5;
mode_buff[0x0B] = speed;
for(unsigned int i = 0; i < color_count; i++) {
unsigned char r = (char)RGBGetRValue(color_buf[i]);
unsigned char g = (char)RGBGetGValue(color_buf[i]);
unsigned char b = (char)RGBGetBValue(color_buf[i]);
if(r == 0 && g == 0 && b == 0)
{
r = 1;
}
mode_buff[0x0C + 3*i + 0] = r;
mode_buff[0x0C + 3*i + 1] = g;
mode_buff[0x0C + 3*i + 2] = b;
}
}
break;
case GMOW_MODE_WAVE:
mode_buff[0x04] = 0x05;
mode_buff[0x0B] = speed;
break;
case GMOW_MODE_OFF:
mode_buff[0x04] = 0x05;
mode_buff[0x0B] = 0x09;
break;
default:
break;
}
std::this_thread::sleep_for(50ms);
hid_send_feature_report(dev, mode_buff, GMOW_PACKET_SIZE);
std::this_thread::sleep_for(50ms);
hid_send_feature_report(dev, wired_buff, GMOW_PACKET_SIZE);
std::this_thread::sleep_for(50ms);
hid_send_feature_report(dev, less_buff, GMOW_PACKET_SIZE);
}
Controllers/SinowealthController/SinowealthGMOWController/SinowealthGMOWController.h
+87
View File
@@ -0,0 +1,87 @@
/*---------------------------------------------------------*\
| SinowealthGMOWController.h |
| |
| Driver for Glorious Model O Wireless |
| |
| Matt Silva (thesilvanator) May 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 GMOW_PACKET_SIZE 64 + 1
enum
{
GMOW_MODE_OFF = 0x00,
GMOW_MODE_RAINBOW_WAVE = 0x01,
GMOW_MODE_SPECTRUM_CYCLE = 0x02,
GMOW_MODE_CUSTOM_BREATHING = 0x03,
GMOW_MODE_STATIC = 0x04,
GMOW_MODE_BREATHING = 0x05,
GMOW_MODE_TAIL = 0x06,
GMOW_MODE_RAVE = 0x07,
GMOW_MODE_WAVE = 0x08,
};
enum
{
GMOW_SPEED1_MIN = 0x14,
GMOW_SPEED1_MID = 0x0B,
GMOW_SPEED1_MAX = 0x01,
GMOW_SPEED2_MIN = 0xC8,
GMOW_SPEED2_MID = 0x6E,
GMOW_SPEED2_MAX = 0x0A,
};
enum
{
GMOW_BRIGHTNESS_MIN = 0x00,
GMOW_BRIGHTNESS_MID = 0x7F,
GMOW_BRIGHTNESS_MAX = 0xFF,
};
enum
{
GMOW_CABLE_CONNECTED,
GMOW_DONGLE_CONNECTED
};
class SinowealthGMOWController
{
public:
SinowealthGMOWController(hid_device* dev_handle, char *_path, int type, std::string dev_name);
~SinowealthGMOWController();
std::string GetLocation();
std::string GetName();
std::string GetSerialString();
void SetMode(unsigned char mode,
unsigned char speed,
unsigned char wired_brightness,
unsigned char less_brightness,
RGBColor* color_buf,
unsigned char color_count);
std::string GetFirmwareVersion();
private:
hid_device* dev;
unsigned char mode_packet[GMOW_PACKET_SIZE];
unsigned char wired_packet[GMOW_PACKET_SIZE];
unsigned char less_packet[GMOW_PACKET_SIZE];
std::string location;
std::string name;
int type;
};