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/SteelSeriesController/SteelSeriesSenseiController/RGBController_SteelSeriesSensei.cpp
+152
View File
@@ -0,0 +1,152 @@
/*---------------------------------------------------------*\
| RGBController_SteelSeriesSensei.cpp |
| |
| RGBController for SteelSeries Sensei |
| |
| Based on SteelSeries Rival controller |
| B Horn (bahorn) 13 May 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_SteelSeriesSensei.h"
/**------------------------------------------------------------------*\
@name Steel Series Sensei
@category Mouse
@type USB
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectSteelSeriesSensei
@comment
\*-------------------------------------------------------------------*/
RGBController_SteelSeriesSensei::RGBController_SteelSeriesSensei(SteelSeriesSenseiController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "SteelSeries";
type = DEVICE_TYPE_MOUSE;
description = "SteelSeries Sensei Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = STEELSERIES_SENSEI_MODE_DIRECT;
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 = STEELSERIES_SENSEI_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.speed_min = STEELSERIES_SENSEI_EFFECT_BREATHING_MIN;
Breathing.speed_max = STEELSERIES_SENSEI_EFFECT_BREATHING_MAX;
Breathing.speed = STEELSERIES_SENSEI_EFFECT_BREATHING_MID;
modes.push_back(Breathing);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = STEELSERIES_SENSEI_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.speed_min = STEELSERIES_SENSEI_EFFECT_RAINBOW_MIN;
Rainbow.speed_max = STEELSERIES_SENSEI_EFFECT_RAINBOW_MAX;
Rainbow.speed = STEELSERIES_SENSEI_EFFECT_RAINBOW_MID;
modes.push_back(Rainbow);
SetupZones();
}
RGBController_SteelSeriesSensei::~RGBController_SteelSeriesSensei()
{
delete controller;
}
void RGBController_SteelSeriesSensei::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 wheel_zone;
wheel_zone.name = "Scroll Wheel";
wheel_zone.type = ZONE_TYPE_SINGLE;
wheel_zone.leds_min = 1;
wheel_zone.leds_max = 1;
wheel_zone.leds_count = 1;
wheel_zone.matrix_map = NULL;
zones.push_back(wheel_zone);
led wheel_led;
wheel_led.name = "Scroll Wheel";
leds.push_back(wheel_led);
SetupColors();
}
void RGBController_SteelSeriesSensei::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_SteelSeriesSensei::DeviceUpdateLEDs()
{
UpdateZoneLEDs(0);
UpdateZoneLEDs(1);
}
void RGBController_SteelSeriesSensei::UpdateZoneLEDs(int zone)
{
RGBColor color = colors[zone];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
switch(modes[active_mode].value)
{
case STEELSERIES_SENSEI_MODE_DIRECT:
controller->SetColor(zone, red, grn, blu);
break;
case STEELSERIES_SENSEI_MODE_BREATHING:
case STEELSERIES_SENSEI_MODE_RAINBOW:
controller->SetLightEffect(zone, modes[active_mode].value, modes[active_mode].speed, red, grn, blu);
break;
}
}
void RGBController_SteelSeriesSensei::UpdateSingleLED(int led)
{
/*---------------------------------------------------------*\
| Each zone only has a single LED, so we can use the LED ID |
| to reference the existing zone code. |
\*---------------------------------------------------------*/
UpdateZoneLEDs(led);
}
void RGBController_SteelSeriesSensei::DeviceUpdateMode()
{
/*---------------------------------------------------------*\
| Strictly, the device actually does support different modes|
| for the different zones, but we don't support that. |
\*---------------------------------------------------------*/
DeviceUpdateLEDs();
}
Controllers/SteelSeriesController/SteelSeriesSenseiController/RGBController_SteelSeriesSensei.h
+35
View File
@@ -0,0 +1,35 @@
/*---------------------------------------------------------*\
| RGBController_SteelSeriesSensei.h |
| |
| RGBController for SteelSeries Sensei |
| |
| Based on SteelSeries Rival controller |
| B Horn (bahorn) 13 May 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "SteelSeriesSenseiController.h"
class RGBController_SteelSeriesSensei : public RGBController
{
public:
RGBController_SteelSeriesSensei(SteelSeriesSenseiController* controller_ptr);
~RGBController_SteelSeriesSensei();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
SteelSeriesSenseiController* controller;
};
Controllers/SteelSeriesController/SteelSeriesSenseiController/SteelSeriesSenseiController.cpp
+297
View File
@@ -0,0 +1,297 @@
/*---------------------------------------------------------*\
| SteelSeriesSenseiController.cpp |
| |
| Driver for SteelSeries Sensei |
| |
| Based on SteelSeries Rival controller |
| B Horn (bahorn) 13 May 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include <stdio.h>
#include <stdlib.h>
#include "SteelSeriesSenseiController.h"
#include "StringUtils.h"
static void send_usb_msg(hid_device* dev, unsigned char * data_pkt, unsigned int size)
{
unsigned char* usb_pkt = new unsigned char[size + 1];
usb_pkt[0] = 0x00;
for(unsigned int i = 1; i < size + 1; i++)
{
usb_pkt[i] = data_pkt[i-1];
}
hid_write(dev, usb_pkt, size + 1);
delete[] usb_pkt;
}
SteelSeriesSenseiController::SteelSeriesSenseiController
(
hid_device* dev_handle,
steelseries_type proto_type,
const char* path,
std::string dev_name
)
{
dev = dev_handle;
location = path;
name = dev_name;
proto = proto_type;
}
SteelSeriesSenseiController::~SteelSeriesSenseiController()
{
hid_close(dev);
}
std::string SteelSeriesSenseiController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string SteelSeriesSenseiController::GetDeviceName()
{
return(name);
}
std::string SteelSeriesSenseiController::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));
}
steelseries_type SteelSeriesSenseiController::GetMouseType()
{
return proto;
}
/* Saves to the internal configuration */
void SteelSeriesSenseiController::Save()
{
/*-----------------------------------------------------*\
| Saves to the internal configuration |
\*-----------------------------------------------------*/
unsigned char usb_buf[9];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Save packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x59;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
send_usb_msg(dev, usb_buf, 9);
}
void SteelSeriesSenseiController::SetLightEffect
(
unsigned char zone_id,
unsigned char effect,
unsigned char speed,
unsigned char red,
unsigned char green,
unsigned char blue
)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Light Effect packet |
\*-----------------------------------------------------*/
unsigned char dur1 = 0x27;
unsigned char dur2 = 0x10; //10 sec cycle
switch(effect)
{
case STEELSERIES_SENSEI_MODE_BREATHING:
switch(speed)
{
case STEELSERIES_SENSEI_EFFECT_BREATHING_MIN:
dur1 = 0x27;
dur2 = 0x10; //10 sec cycle
break;
case STEELSERIES_SENSEI_EFFECT_BREATHING_MID:
dur1 = 0x13;
dur2 = 0x88; //5 sec cycle
break;
case STEELSERIES_SENSEI_EFFECT_BREATHING_MAX:
dur1 = 0x09;
dur2 = 0xc4; //2.5 sec cycle
break;
}
usb_buf[0x00] = 0x5B; //command byte
usb_buf[0x02] = zone_id;
usb_buf[0x04] = dur1; //duration in ms 1st byte
usb_buf[0x03] = dur2; //duration in ms 2nd byte
usb_buf[0x1B] = 0x03; //Number of colors
/*---------------------------------------------*\
| Original software duplicates these RGB bytes, |
| but seems unnecessary |
\*---------------------------------------------*/
usb_buf[0x1C] = red;
usb_buf[0x1D] = green;
usb_buf[0x1E] = blue;
usb_buf[0x1F] = red;
usb_buf[0x20] = green;
usb_buf[0x21] = blue;
usb_buf[0x26] = 0x7F; //percent of duration out of 0xFF
usb_buf[0x27] = red;
usb_buf[0x28] = green;
usb_buf[0x29] = blue;
usb_buf[0x2A] = 0x7F; //percent of duration out of 0xFF
break;
case STEELSERIES_SENSEI_MODE_RAINBOW:
switch(speed)
{
case STEELSERIES_SENSEI_EFFECT_RAINBOW_MIN:
dur1 = 0x4E;
dur2 = 0x20; //20 sec cycle
break;
case STEELSERIES_SENSEI_EFFECT_RAINBOW_MID:
dur1 = 0x27;
dur2 = 0x10; //10 sec cycle
break;
case STEELSERIES_SENSEI_EFFECT_RAINBOW_MAX:
dur1 = 0x13;
dur2 = 0x88; //5 sec cycle
break;
}
usb_buf[0x00] = 0x5B; //command byte
usb_buf[0x02] = zone_id;
usb_buf[0x04] = dur1; //duration in ms 1st byte
usb_buf[0x03] = dur2; //duration in ms 2nd byte
usb_buf[0x1B] = 0x07; //Number of colors
/*---------------------------------------------*\
| Original software duplicates these RGB bytes, |
| but seems unnecessary |
\*---------------------------------------------*/
usb_buf[0x1C] = red;
usb_buf[0x1D] = green;
usb_buf[0x1E] = blue;
usb_buf[0x1C] = 0xFF;
usb_buf[0x1F] = 0xFF;
usb_buf[0x22] = 0x14;
usb_buf[0x23] = 0xFF;
usb_buf[0x24] = 0xFF;
usb_buf[0x26] = 0x2B; //percent of duration out of 0xFF
usb_buf[0x28] = 0xFF;
usb_buf[0x2A] = 0x2B;
usb_buf[0x2C] = 0xFF;
usb_buf[0x2D] = 0xFF; //percent of duration out of 0xFF
usb_buf[0x2E] = 0x28;
usb_buf[0x31] = 0xFF;
usb_buf[0x32] = 0x2B;
usb_buf[0x33] = 0xFF;
usb_buf[0x35] = 0xFF;
usb_buf[0x36] = 0x2B;
usb_buf[0x37] = 0xFF;
usb_buf[0x3A] = 0x14;
break;
}
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
send_usb_msg(dev, usb_buf, sizeof(usb_buf));
}
void SteelSeriesSenseiController::SetLightEffectAll
(
unsigned char effect,
unsigned char speed,
unsigned char red,
unsigned char green,
unsigned char blue
)
{
SetLightEffect(0, effect, speed, red, green, blue);
SetLightEffect(1, effect, speed, red, green, blue);
}
void SteelSeriesSenseiController::SetColor
(
unsigned char zone_id,
unsigned char red,
unsigned char green,
unsigned char blue
)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Set Color packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x5B; //command byte
usb_buf[0x02] = zone_id;
/*-----------------------------------------------------*\
| Original software duplicates these RGB bytes, |
| but seems unnecessary |
\*-----------------------------------------------------*/
usb_buf[0x1C] = red;
usb_buf[0x1D] = green;
usb_buf[0x1E] = blue;
usb_buf[0x1F] = red;
usb_buf[0x20] = green;
usb_buf[0x21] = blue;
usb_buf[0x13] = 0x01; //Static color flag
usb_buf[0x1B] = 0x01; //Number of colors
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
send_usb_msg(dev, usb_buf, sizeof(usb_buf));
}
void SteelSeriesSenseiController::SetColorAll
(
unsigned char red,
unsigned char green,
unsigned char blue
)
{
SetColor(0, red, green, blue);
SetColor(1, red, green, blue);
}
Controllers/SteelSeriesController/SteelSeriesSenseiController/SteelSeriesSenseiController.h
+103
View File
@@ -0,0 +1,103 @@
/*---------------------------------------------------------*\
| SteelSeriesSenseiController.h |
| |
| Driver for SteelSeries Sensei |
| |
| Based on SteelSeries Rival controller |
| B Horn (bahorn) 13 May 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <hidapi.h>
#include "SteelSeriesGeneric.h"
/*-------------------------------------------------------------*\
| Mode, we then use these to set actual effect based on speed. |
\*-------------------------------------------------------------*/
enum
{
STEELSERIES_SENSEI_MODE_DIRECT = 0x00,
STEELSERIES_SENSEI_MODE_BREATHING = 0x01,
STEELSERIES_SENSEI_MODE_RAINBOW = 0x02
};
/*-------------------------------------------------------------*\
| Effects |
\*-------------------------------------------------------------*/
enum
{
STEELSERIES_SENSEI_EFFECT_DIRECT = 0x01,
STEELSERIES_SENSEI_EFFECT_BREATHING_MIN = 0x02,
STEELSERIES_SENSEI_EFFECT_BREATHING_MID = 0x03,
STEELSERIES_SENSEI_EFFECT_BREATHING_MAX = 0x04,
STEELSERIES_SENSEI_EFFECT_RAINBOW_MIN = 0x05,
STEELSERIES_SENSEI_EFFECT_RAINBOW_MID = 0x06,
STEELSERIES_SENSEI_EFFECT_RAINBOW_MAX = 0x07
};
class SteelSeriesSenseiController
{
public:
SteelSeriesSenseiController
(
hid_device* dev_handle,
steelseries_type proto_type,
const char* path,
std::string dev_name
);
~SteelSeriesSenseiController();
std::string GetDeviceLocation();
std::string GetDeviceName();
std::string GetSerialString();
steelseries_type GetMouseType();
void Save();
void SetLightEffect
(
unsigned char zone_id,
unsigned char effect,
unsigned char speed,
unsigned char red,
unsigned char green,
unsigned char blue
);
void SetLightEffectAll
(
unsigned char effect,
unsigned char speed,
unsigned char red,
unsigned char green,
unsigned char blue
);
void SetColor
(
unsigned char zone_id,
unsigned char red,
unsigned char green,
unsigned char blue
);
void SetColorAll
(
unsigned char red,
unsigned char green,
unsigned char blue
);
private:
hid_device* dev;
std::string location;
std::string name;
steelseries_type proto;
};