mirror of
https://github.com/CalcProgrammer1/OpenRGB.git
synced 2026-02-14 09:11:14 -05:00
383 lines
16 KiB
C++
383 lines
16 KiB
C++
/*---------------------------------------------------------*\
|
|
| RGBController_LianLiUniHubSL.cpp |
|
|
| |
|
|
| RGBController for Lian Li Uni Hub - SL |
|
|
| |
|
|
| Muhamad Visat 26 Jul 2025 |
|
|
| Original work by Luca Lovisa & Oliver P |
|
|
| |
|
|
| This file is part of the OpenRGB project |
|
|
| SPDX-License-Identifier: GPL-2.0-only |
|
|
\*---------------------------------------------------------*/
|
|
|
|
#include "RGBController_LianLiUniHubSL.h"
|
|
|
|
/**------------------------------------------------------------------*\
|
|
@name Lian Li Uni Hub - SL
|
|
@category Cooler
|
|
@type USB
|
|
@save :x:
|
|
@direct :rotating_light:
|
|
@effects :white_check_mark:
|
|
@detectors DetectLianLiUniHubSL
|
|
@comment
|
|
\*-------------------------------------------------------------------*/
|
|
|
|
RGBController_LianLiUniHubSL::RGBController_LianLiUniHubSL(LianLiUniHubSLController *controller, std::string name)
|
|
{
|
|
this->controller = controller;
|
|
this->name = name;
|
|
this->vendor = "Lian Li";
|
|
this->description = "Lian Li Uni Hub - SL";
|
|
this->version = controller->ReadVersion();
|
|
this->serial = controller->ReadSerial();
|
|
this->location = controller->GetLocation();
|
|
this->type = DEVICE_TYPE_COOLER;
|
|
|
|
initialized = false;
|
|
|
|
mode Custom;
|
|
Custom.name = "Custom";
|
|
Custom.value = UNIHUB_SL_LED_MODE_STATIC;
|
|
Custom.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
|
|
Custom.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
Custom.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
Custom.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
Custom.color_mode = MODE_COLORS_PER_LED;
|
|
modes.push_back(Custom);
|
|
|
|
mode Rainbow;
|
|
Rainbow.name = "Rainbow";
|
|
Rainbow.value = UNIHUB_SL_LED_MODE_RAINBOW;
|
|
Rainbow.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
|
Rainbow.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
Rainbow.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
Rainbow.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
Rainbow.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
Rainbow.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
Rainbow.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
Rainbow.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
|
Rainbow.color_mode = MODE_COLORS_NONE;
|
|
modes.push_back(Rainbow);
|
|
|
|
mode RainbowMorph;
|
|
RainbowMorph.name = "Rainbow Morph";
|
|
RainbowMorph.value = UNIHUB_SL_LED_MODE_RAINBOW_MORPH;
|
|
RainbowMorph.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
|
RainbowMorph.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
RainbowMorph.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
RainbowMorph.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
RainbowMorph.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
RainbowMorph.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
RainbowMorph.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
RainbowMorph.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
|
RainbowMorph.color_mode = MODE_COLORS_NONE;
|
|
modes.push_back(RainbowMorph);
|
|
|
|
mode Static;
|
|
Static.name = "Static";
|
|
Static.value = UNIHUB_SL_LED_MODE_STATIC;
|
|
Static.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
|
|
Static.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
Static.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
Static.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
Static.color_mode = MODE_COLORS_PER_LED;
|
|
modes.push_back(Static);
|
|
|
|
mode Breathing;
|
|
Breathing.name = "Breathing";
|
|
Breathing.value = UNIHUB_SL_LED_MODE_BREATHING;
|
|
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
|
|
Breathing.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
Breathing.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
Breathing.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
Breathing.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
Breathing.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
Breathing.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
Breathing.color_mode = MODE_COLORS_PER_LED;
|
|
modes.push_back(Breathing);
|
|
|
|
mode ColorCycle;
|
|
ColorCycle.name = "Color Cycle";
|
|
ColorCycle.value = UNIHUB_SL_LED_MODE_COLOR_CYCLE;
|
|
ColorCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
|
ColorCycle.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
ColorCycle.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
ColorCycle.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
ColorCycle.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
ColorCycle.colors_min = 3;
|
|
ColorCycle.colors_max = 3;
|
|
ColorCycle.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
ColorCycle.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
ColorCycle.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
|
ColorCycle.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
|
modes.push_back(ColorCycle);
|
|
|
|
mode Runway;
|
|
Runway.name = "Runway";
|
|
Runway.value = UNIHUB_SL_LED_MODE_RUNWAY;
|
|
Runway.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
|
Runway.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
Runway.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
Runway.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
Runway.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
Runway.colors_min = 2;
|
|
Runway.colors_max = 2;
|
|
Runway.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
Runway.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
Runway.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
|
modes.push_back(Runway);
|
|
|
|
mode RunwayMerged;
|
|
RunwayMerged.name = "Runway Merged";
|
|
RunwayMerged.value = UNIHUB_SL_LED_MODE_RUNWAY;
|
|
RunwayMerged.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
|
RunwayMerged.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
RunwayMerged.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
RunwayMerged.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
RunwayMerged.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
RunwayMerged.colors_min = 2;
|
|
RunwayMerged.colors_max = 2;
|
|
RunwayMerged.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
RunwayMerged.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
RunwayMerged.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
|
modes.push_back(RunwayMerged);
|
|
|
|
mode Staggered;
|
|
Staggered.name = "Staggered";
|
|
Staggered.value = UNIHUB_SL_LED_MODE_STAGGERED;
|
|
Staggered.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
|
Staggered.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
Staggered.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
Staggered.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
Staggered.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
Staggered.colors_min = 2;
|
|
Staggered.colors_max = 2;
|
|
Staggered.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
Staggered.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
Staggered.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
|
modes.push_back(Staggered);
|
|
|
|
mode Tide;
|
|
Tide.name = "Tide";
|
|
Tide.value = UNIHUB_SL_LED_MODE_TIDE;
|
|
Tide.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
|
Tide.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
Tide.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
Tide.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
Tide.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
Tide.colors_min = 2;
|
|
Tide.colors_max = 2;
|
|
Tide.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
Tide.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
Tide.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
|
modes.push_back(Tide);
|
|
|
|
mode Meteor;
|
|
Meteor.name = "Meteor";
|
|
Meteor.value = UNIHUB_SL_LED_MODE_METEOR;
|
|
Meteor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
|
Meteor.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
Meteor.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
Meteor.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
Meteor.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
Meteor.colors_min = 2;
|
|
Meteor.colors_max = 2;
|
|
Meteor.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
Meteor.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
Meteor.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
|
Meteor.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
|
modes.push_back(Meteor);
|
|
|
|
mode MeteorMerged;
|
|
MeteorMerged.name = "Meteor Merged";
|
|
MeteorMerged.value = UNIHUB_SL_LED_MODE_METEOR_MERGED;
|
|
MeteorMerged.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
|
MeteorMerged.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
MeteorMerged.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
MeteorMerged.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
MeteorMerged.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
MeteorMerged.colors_min = 2;
|
|
MeteorMerged.colors_max = 2;
|
|
MeteorMerged.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
MeteorMerged.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
MeteorMerged.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
|
MeteorMerged.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
|
modes.push_back(MeteorMerged);
|
|
|
|
mode Mixing;
|
|
Mixing.name = "Mixing";
|
|
Mixing.value = UNIHUB_SL_LED_MODE_MIXING;
|
|
Mixing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
|
Mixing.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
Mixing.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
Mixing.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
Mixing.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
Mixing.colors_min = 2;
|
|
Mixing.colors_max = 2;
|
|
Mixing.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
Mixing.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
Mixing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
|
modes.push_back(Mixing);
|
|
|
|
mode Stack;
|
|
Stack.name = "Stack";
|
|
Stack.value = UNIHUB_SL_LED_MODE_STACK;
|
|
Stack.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
|
Stack.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
Stack.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
Stack.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
Stack.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
Stack.colors_min = 1;
|
|
Stack.colors_max = 1;
|
|
Stack.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
Stack.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
Stack.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
|
Stack.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
|
modes.push_back(Stack);
|
|
|
|
mode StackMultiColor;
|
|
StackMultiColor.name = "Stack Multi Color";
|
|
StackMultiColor.value = UNIHUB_SL_LED_MODE_STACK_MULTI_COLOR;
|
|
StackMultiColor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
|
StackMultiColor.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
StackMultiColor.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
StackMultiColor.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
StackMultiColor.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
StackMultiColor.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
StackMultiColor.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
StackMultiColor.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
|
StackMultiColor.color_mode = MODE_COLORS_NONE;
|
|
modes.push_back(StackMultiColor);
|
|
|
|
mode Neon;
|
|
Neon.name = "Neon";
|
|
Neon.value = UNIHUB_SL_LED_MODE_NEON;
|
|
Neon.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
|
Neon.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
|
Neon.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
|
Neon.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
|
Neon.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
|
Neon.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
|
Neon.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
|
Neon.color_mode = MODE_COLORS_NONE;
|
|
modes.push_back(Neon);
|
|
|
|
RGBColor default_colors[] =
|
|
{
|
|
ToRGBColor(255, 0, 0), // Red
|
|
ToRGBColor(0, 255, 0), // Green
|
|
ToRGBColor(0, 0, 255), // Blue
|
|
ToRGBColor(255, 255, 255), // White
|
|
};
|
|
|
|
for(size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
|
|
{
|
|
mode &m = modes[mode_idx];
|
|
m.colors.resize(m.colors_max);
|
|
for (unsigned int color_idx = 0; color_idx < m.colors_max; color_idx++)
|
|
{
|
|
m.colors[color_idx] = default_colors[color_idx % sizeof(default_colors)];
|
|
}
|
|
}
|
|
|
|
RGBController_LianLiUniHubSL::SetupZones();
|
|
}
|
|
|
|
RGBController_LianLiUniHubSL::~RGBController_LianLiUniHubSL()
|
|
{
|
|
Shutdown();
|
|
|
|
delete this->controller;
|
|
}
|
|
|
|
void RGBController_LianLiUniHubSL::SetupZones()
|
|
{
|
|
bool first_run = zones.size() == 0;
|
|
|
|
leds.clear();
|
|
colors.clear();
|
|
if(first_run)
|
|
{
|
|
zones.resize(UNIHUB_SL_MAX_CHANNEL);
|
|
}
|
|
|
|
for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
|
{
|
|
zones[zone_idx].name = "Channel ";
|
|
zones[zone_idx].name.append(std::to_string(zone_idx + 1));
|
|
zones[zone_idx].type = ZONE_TYPE_LINEAR;
|
|
|
|
zones[zone_idx].leds_min = 0;
|
|
zones[zone_idx].leds_max = UNIHUB_SL_MAX_FAN_PER_CHANNEL;
|
|
|
|
if(first_run)
|
|
{
|
|
zones[zone_idx].leds_count = zones[zone_idx].leds_min;
|
|
}
|
|
|
|
for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
|
|
{
|
|
led new_led;
|
|
new_led.name = zones[zone_idx].name;
|
|
new_led.name.append(", Fan ");
|
|
new_led.name.append(std::to_string(led_idx + 1));
|
|
new_led.value = zone_idx;
|
|
|
|
leds.push_back(new_led);
|
|
}
|
|
}
|
|
|
|
SetupColors();
|
|
}
|
|
|
|
void RGBController_LianLiUniHubSL::DeviceResizeZone(int zone, int new_size)
|
|
{
|
|
if((size_t)zone >= zones.size())
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
|
|
{
|
|
zones[zone].leds_count = new_size;
|
|
|
|
SetupZones();
|
|
}
|
|
}
|
|
|
|
void RGBController_LianLiUniHubSL::DeviceUpdateLEDs()
|
|
{
|
|
DeviceUpdateMode();
|
|
}
|
|
|
|
void RGBController_LianLiUniHubSL::DeviceUpdateZoneLEDs(int zone)
|
|
{
|
|
if(!initialized)
|
|
{
|
|
return DeviceUpdateMode();
|
|
}
|
|
controller->DeviceUpdateZoneLEDs(zone, zones[zone], modes[active_mode]);
|
|
}
|
|
|
|
void RGBController_LianLiUniHubSL::DeviceUpdateSingleLED(int /* led */)
|
|
{
|
|
DeviceUpdateMode();
|
|
}
|
|
|
|
void RGBController_LianLiUniHubSL::DeviceUpdateMode()
|
|
{
|
|
if(active_mode == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
controller->UpdateMode(zones, modes[active_mode]);
|
|
initialized = true;
|
|
}
|
|
|
|
void RGBController_LianLiUniHubSL::SetCustomMode()
|
|
{
|
|
active_mode = 0;
|
|
}
|