mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2025-12-24 07:47:49 -05:00
Code Issues Packages Projects Releases Wiki Activity

Add support for Lian Li GAII Trinity AIO

Browse Source
This commit is contained in:
Michael Losert
2023-11-08 17:54:20 +00:00
committed by Adam Honse
parent 12e7127422
commit dbeabe613d
6 changed files with 938 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
Controllers/LianLiController/LianLiControllerDetect.cpp
View File

@@ -34,11 +34,14 @@
#include "RGBController_LianLiUniHubSLV2.h"
#include "LianLiUniHubSLInfinityController.h"
#include "RGBController_LianLiUniHubSLInfinity.h"
#include "LianLiGAIITrinityController.h"
#include "RGBController_LianLiGAIITrinity.h"
/*-----------------------------------------------------*\
| ENE USB vendor ID |
| USB vendor IDs |
\*-----------------------------------------------------*/
#define ENE_USB_VID 0x0CF2
#define NUVOTON_USB_VID 0x0416
/*-----------------------------------------------------*\
| Keyboard product IDs |
@@ -53,6 +56,7 @@
#define UNI_HUB_SLINF_PID 0xA102
#define UNI_HUB_SLV2_PID 0xA103
#define UNI_HUB_SLV2_V05_PID 0xA105
#define GAII_USB_PID 0x7373
/*----------------------------------------------------------------------------*\
| The Uni Hub is controlled by sending control transfers to various wIndex |
@@ -64,7 +68,7 @@ void DetectLianLiUniHub()
{
libusb_device** devices = nullptr;
int ret;
ssize_t ret;
ret = libusb_init(NULL);
if(ret < 0)
@@ -78,7 +82,7 @@ void DetectLianLiUniHub()
return;
}
int deviceCount = ret;
ssize_t deviceCount = ret;
for(int i = 0; i < deviceCount; i++)
{
@@ -110,7 +114,7 @@ void DetectLianLiUniHub_AL10()
{
libusb_device** devices = nullptr;
int ret;
ssize_t ret;
ret = libusb_init(NULL);
if(ret < 0)
@@ -124,7 +128,7 @@ void DetectLianLiUniHub_AL10()
return;
}
int deviceCount = ret;
ssize_t deviceCount = ret;
for(int i = 0; i < deviceCount; i++)
{
@@ -221,6 +225,18 @@ void DetectStrimerControllers(hid_device_info* info, const std::string& name)
}
}
void DetectLianLiGAIITrinity(hid_device_info* info, const std::string& /*name*/)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
LianLiGAIITrinityController* controller = new LianLiGAIITrinityController(dev);
RGBController_LianLiGAIITrinity* rgb_controller = new RGBController_LianLiGAIITrinity(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_DETECTOR("Lian Li Uni Hub", DetectLianLiUniHub);
REGISTER_HID_DETECTOR_IPU("Lian Li Uni Hub - AL", DetectLianLiUniHubAL, ENE_USB_VID, UNI_HUB_AL_PID, 0x01, 0xFF72, 0xA1);
REGISTER_HID_DETECTOR_IPU("Lian Li Uni Hub - SL V2", DetectLianLiUniHubSLV2, ENE_USB_VID, UNI_HUB_SLV2_PID, 0x01, 0xFF72, 0xA1);
@@ -233,3 +249,5 @@ REGISTER_HID_DETECTOR_IPU("Lian Li Uni Hub - SL Infinity", DetectLianLiUniHubSLI
\*---------------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_IPU("Strimer L Connect", DetectStrimerControllers, ENE_USB_VID, STRIMER_L_CONNECT_PID, 1, 0xFF72, 0xA1);
REGISTER_HID_DETECTOR_I("Lian Li GA II Trinity", DetectLianLiGAIITrinity, NUVOTON_USB_VID, GAII_USB_PID, 0x02);

298
Controllers/LianLiController/LianLiGAIITrinityController.cpp Normal file
View File

@@ -0,0 +1,298 @@
/*-----------------------------------------*\
| LianLiGAIITrinityController.cpp |
| |
| Controller for Lian Li GAII Trinity |
| |
| Michael Losert 2023-10-27 |
\*-----------------------------------------*/
#include "LianLiGAIITrinityController.h"
#include <algorithm>
#include <cstring>
#include <iomanip>
#include <sstream>
LianLiGAIITrinityController::LianLiGAIITrinityController(hid_device* dev_handle)
{
dev = dev_handle;
}
LianLiGAIITrinityController::~LianLiGAIITrinityController()
{
if(dev)
{
hid_close(dev);
}
}
LianLiGAIITrinityController::GAII_Info LianLiGAIITrinityController::GetControllerInfo()
{
GAII_Info controllerInfo;
hid_device_info* hidInfo = hid_get_device_info(dev);
// get device location
controllerInfo.location = "HID: " + std::string(hidInfo->path);
// get serial number
std::wstring serialWStr(hidInfo->serial_number);
controllerInfo.serial = std::string(serialWStr.begin(), serialWStr.end());
// get firmware version
unsigned char data[64] = "";
data[0x00] = 0x01;
data[GAII_ByteAddress::BA_PACKET_TYPE] = GAII_PacketType::PT_FIRMWARE_INFO;
hid_write(dev, data, sizeof(data));
memset(data, 0, sizeof(data));
hid_read(dev, data, sizeof(data));
data[sizeof(data) - 1] = 0;
std::string response(reinterpret_cast<char*>(&data[0x06]));
memset(data, 0, sizeof(data));
hid_read(dev, data, sizeof(data));
data[sizeof(data) - 1] = 0;
response += " (" + std::string(reinterpret_cast<char*>(&data[0x06])) + ")";
std::replace( response.begin(), response.end(), ',', ' ');
controllerInfo.version = response.substr(0, 100);
return controllerInfo;
}
unsigned char* LianLiGAIITrinityController::GetRGBControlPacketTemplate()
{
static unsigned char usb_buf[64];
memset(usb_buf, 0, sizeof(usb_buf));
usb_buf[0x00] = 0x01;
usb_buf[GAII_ByteAddress::BA_PACKET_TYPE] = GAII_PacketType::PT_RGB_CONTROL;
usb_buf[0x05] = 0x13;
return usb_buf;
}
void LianLiGAIITrinityController::SetRGB(unsigned char* usb_buf, RGBColor* rgb0, RGBColor* rgb1, RGBColor* rgb2, RGBColor* rgb3)
{
if(rgb0)
{
usb_buf[GAII_ByteAddress::BA_R0] = RGBGetRValue(*rgb0);
usb_buf[GAII_ByteAddress::BA_G0] = RGBGetGValue(*rgb0);
usb_buf[GAII_ByteAddress::BA_B0] = RGBGetBValue(*rgb0);
}
if(rgb1)
{
usb_buf[GAII_ByteAddress::BA_R1] = RGBGetRValue(*rgb1);
usb_buf[GAII_ByteAddress::BA_G1] = RGBGetGValue(*rgb1);
usb_buf[GAII_ByteAddress::BA_B1] = RGBGetBValue(*rgb1);
}
if(rgb2)
{
usb_buf[GAII_ByteAddress::BA_R2] = RGBGetRValue(*rgb2);
usb_buf[GAII_ByteAddress::BA_G2] = RGBGetGValue(*rgb2);
usb_buf[GAII_ByteAddress::BA_B2] = RGBGetBValue(*rgb2);
}
if(rgb3)
{
usb_buf[GAII_ByteAddress::BA_R3] = RGBGetRValue(*rgb3);
usb_buf[GAII_ByteAddress::BA_G3] = RGBGetGValue(*rgb3);
usb_buf[GAII_ByteAddress::BA_B3] = RGBGetBValue(*rgb3);
}
}
void LianLiGAIITrinityController::SetMode_Rainbow(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_RAINBOW;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_RainbowMorph(GAII_Brightness brightness, GAII_Speed speed)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_RAINBOW_MORPH;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_StaticColor(GAII_Brightness brightness, RGBColor rgb0, RGBColor rgb1)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_STATIC_COLOR;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
SetRGB(usb_buf, rgb0, rgb1);
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_BreathingColor(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_BREATHING_COLOR;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
SetRGB(usb_buf, rgb0, rgb1);
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_Runway(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_RUNWAY;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
SetRGB(usb_buf, rgb0, rgb1);
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_Meteor(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_METEOR;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
SetRGB(usb_buf, rgb0, rgb1, rgb2, rgb3);
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_Vortex(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_VORTEX;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
SetRGB(usb_buf, rgb0, rgb1, rgb2, rgb3);
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_CrossingOver(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_CROSSING_OVER;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
SetRGB(usb_buf, rgb0, rgb1, rgb2, rgb3);
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_TaiChi(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_TAI_CHI;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
SetRGB(usb_buf, rgb0, rgb1);
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_ColorfulStarryNight(GAII_Brightness brightness, GAII_Speed speed)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_COLORFUL_STARRY_NIGHT;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_StaticStarryNight(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_STATIC_STARRY_NIGHT;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
SetRGB(usb_buf, rgb0);
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_Voice(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_VOICE;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
SetRGB(usb_buf, rgb0, rgb1);
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_BigBang(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_BIG_BANG;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
SetRGB(usb_buf, rgb0, rgb1, rgb2, rgb3);
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_Pump(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_PUMP;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
SetRGB(usb_buf, rgb0, rgb1);
hid_write(dev, usb_buf, 64);
}
void LianLiGAIITrinityController::SetMode_ColorsMorph(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction)
{
unsigned char *usb_buf = GetRGBControlPacketTemplate();
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_COLORS_MORPH;
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
hid_write(dev, usb_buf, 64);
}

146
Controllers/LianLiController/LianLiGAIITrinityController.h Normal file
View File

@@ -0,0 +1,146 @@
/*-----------------------------------------*\
| LianLiGAIITrinityController.h |
| |
| Controller for Lian Li GAII Trinity |
| |
| Michael Losert 2023-10-27 |
\*-----------------------------------------*/
#include "RGBController.h"
#include "hidapi/hidapi.h"
#include <vector>
#ifdef __FreeBSD__
#include <libusb.h>
#else
#include <libusb-1.0/libusb.h>
#endif
#pragma once
/*----------------------------------------------------------------------------*\
| Definitions related to LED configuration. |
\*----------------------------------------------------------------------------*/
class LianLiGAIITrinityController
{
public:
struct GAII_Info
{
std::string location;
std::string serial;
std::string version;
};
enum GAII_PacketType : unsigned char
{
PT_RGB_CONTROL = 0x83,
PT_FIRMWARE_INFO = 0x86
};
enum GAII_Modes : unsigned char
{
M_RAINBOW = 0x01,
M_RAINBOW_MORPH,
M_STATIC_COLOR,
M_BREATHING_COLOR,
M_RUNWAY,
M_METEOR,
M_VORTEX,
M_CROSSING_OVER,
M_TAI_CHI,
M_COLORFUL_STARRY_NIGHT,
M_STATIC_STARRY_NIGHT,
M_VOICE,
M_BIG_BANG,
M_PUMP,
M_COLORS_MORPH,
/* M_BOUNCE, */ // TODO: requires zone-specific modes
};
enum GAII_Ring : unsigned char
{
R_INNER,
R_OUTER,
R_BOTH,
};
enum GAII_Brightness : unsigned char
{
B_OFF,
B_25,
B_50,
B_75,
B_100,
};
enum GAII_Speed : unsigned char
{
S_VERY_SLOW,
S_SLOW,
S_MODERATE,
S_FAST,
S_VERY_FAST,
};
enum GAII_Direction : unsigned char
{
D_RIGHT,
D_LEFT
};
enum GAII_ByteAddress : unsigned char
{
BA_PACKET_TYPE = 0x01,
BA_RING = 0x06,
BA_MODE,
BA_BRIGHTNESS,
BA_SPEED,
BA_R0 = 0x0A,
BA_G0,
BA_B0,
BA_R1,
BA_G1,
BA_B1,
BA_R2,
BA_G2,
BA_B2,
BA_R3,
BA_G3,
BA_B3,
BA_DIRECTION = 0x16,
};
LianLiGAIITrinityController(hid_device* dev_handle);
~LianLiGAIITrinityController();
GAII_Info GetControllerInfo();
void SetMode_Rainbow(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction);
void SetMode_RainbowMorph(GAII_Brightness brightness, GAII_Speed speed);
void SetMode_StaticColor(GAII_Brightness brightness, RGBColor rgb0, RGBColor rgb1);
void SetMode_BreathingColor(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1);
void SetMode_Runway(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1);
void SetMode_Meteor(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3);
void SetMode_Vortex(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3);
void SetMode_CrossingOver(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3);
void SetMode_TaiChi(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1);
void SetMode_ColorfulStarryNight(GAII_Brightness brightness, GAII_Speed speed);
void SetMode_StaticStarryNight(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0);
void SetMode_Voice(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1);
void SetMode_BigBang(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3);
void SetMode_Pump(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1);
void SetMode_ColorsMorph(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction);
private:
unsigned char* GetRGBControlPacketTemplate();
void SetRGB(unsigned char* usb_buf, RGBColor rgb0) { SetRGB(usb_buf, &rgb0, nullptr, nullptr, nullptr); };
void SetRGB(unsigned char* usb_buf, RGBColor rgb0, RGBColor rgb1) { SetRGB(usb_buf, &rgb0, &rgb1, nullptr, nullptr); };
void SetRGB(unsigned char* usb_buf, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2) { SetRGB(usb_buf, &rgb0, &rgb1, &rgb2, nullptr); };
void SetRGB(unsigned char* usb_buf, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3) { SetRGB(usb_buf, &rgb0, &rgb1, &rgb2, &rgb3); };
void SetRGB(unsigned char* usb_buf, RGBColor* rgb0, RGBColor* rgb1, RGBColor* rgb2, RGBColor* rgb3);
hid_device* dev;
};

422
Controllers/LianLiController/RGBController_LianLiGAIITrinity.cpp Normal file
View File

@@ -0,0 +1,422 @@
/*-----------------------------------------*\
| RGBController_LianLiGAIITrinity.cpp |
| |
| Lian Li GAII Trinity AIO LED Driver |
| |
| Michael Losert 2023-10-27 |
\*-----------------------------------------*/
#include "RGBController_LianLiGAIITrinity.h"
#include <string>
/**------------------------------------------------------------------*\
@name Lian Li GAII Trinity
@type USB
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectLianLiGAIITrinity
@comment
\*-------------------------------------------------------------------*/
RGBController_LianLiGAIITrinity::RGBController_LianLiGAIITrinity(LianLiGAIITrinityController* controller_ptr)
{
controller = controller_ptr;
name = "Lian Li GAII Trinity";
vendor = "Lian Li";
type = DEVICE_TYPE_COOLER;
description = "Lian Li Galahad II Trinity AIO";
LianLiGAIITrinityController::GAII_Info controllerInfo = controller->GetControllerInfo();
version = controllerInfo.version;
location = controllerInfo.location;
serial = controllerInfo.serial;
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = LianLiGAIITrinityController::GAII_Modes::M_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Rainbow.color_mode = MODE_COLORS_RANDOM;
Rainbow.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
Rainbow.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
Rainbow.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
Rainbow.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
Rainbow.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
Rainbow.speed = LianLiGAIITrinityController::GAII_Speed::S_FAST;
Rainbow.direction = MODE_DIRECTION_RIGHT;
modes.push_back(Rainbow);
mode RainbowMorph;
RainbowMorph.name = "Rainbow Morph";
RainbowMorph.value = LianLiGAIITrinityController::GAII_Modes::M_RAINBOW_MORPH;
RainbowMorph.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
RainbowMorph.color_mode = MODE_COLORS_RANDOM;
RainbowMorph.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
RainbowMorph.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
RainbowMorph.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
RainbowMorph.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
RainbowMorph.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
RainbowMorph.speed = LianLiGAIITrinityController::GAII_Speed::S_SLOW;
modes.push_back(RainbowMorph);
mode Direct;
Direct.name = "Direct";
Direct.value = LianLiGAIITrinityController::GAII_Modes::M_STATIC_COLOR;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Direct.color_mode = MODE_COLORS_PER_LED;
Direct.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
Direct.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
Direct.brightness = LianLiGAIITrinityController::GAII_Brightness::B_50;
modes.push_back(Direct);
mode BreathingColor;
BreathingColor.name = "Breathing Color";
BreathingColor.value = LianLiGAIITrinityController::GAII_Modes::M_BREATHING_COLOR;
BreathingColor.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
BreathingColor.color_mode = MODE_COLORS_MODE_SPECIFIC;
BreathingColor.colors.resize(2);
BreathingColor.colors[0] = ToRGBColor(255, 255, 255);
BreathingColor.colors[1] = ToRGBColor(255, 0, 0);
BreathingColor.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
BreathingColor.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
BreathingColor.brightness = LianLiGAIITrinityController::GAII_Brightness::B_100;
BreathingColor.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
BreathingColor.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
BreathingColor.speed = LianLiGAIITrinityController::GAII_Speed::S_MODERATE;
modes.push_back(BreathingColor);
mode Runway;
Runway.name = "Runway";
Runway.value = LianLiGAIITrinityController::GAII_Modes::M_RUNWAY;
Runway.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
Runway.color_mode = MODE_COLORS_MODE_SPECIFIC;
Runway.colors.resize(2);
Runway.colors[0] = ToRGBColor(0, 0, 0);
Runway.colors[1] = ToRGBColor(255, 255, 255);
Runway.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
Runway.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
Runway.brightness = LianLiGAIITrinityController::GAII_Brightness::B_50;
Runway.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
Runway.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
Runway.speed = LianLiGAIITrinityController::GAII_Speed::S_FAST;
modes.push_back(Runway);
mode Meteor;
Meteor.name = "Meteor";
Meteor.value = LianLiGAIITrinityController::GAII_Modes::M_METEOR;
Meteor.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Meteor.color_mode = MODE_COLORS_MODE_SPECIFIC;
Meteor.colors.resize(4);
Meteor.colors[0] = ToRGBColor(50, 50, 50);
Meteor.colors[1] = ToRGBColor(100, 100, 100);
Meteor.colors[2] = ToRGBColor(180, 180, 180);
Meteor.colors[3] = ToRGBColor(255, 0, 0);
Meteor.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
Meteor.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
Meteor.brightness = LianLiGAIITrinityController::GAII_Brightness::B_100;
Meteor.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
Meteor.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
Meteor.speed = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
Meteor.direction = MODE_DIRECTION_RIGHT;
modes.push_back(Meteor);
mode Vortex;
Vortex.name = "Vortex";
Vortex.value = LianLiGAIITrinityController::GAII_Modes::M_VORTEX;
Vortex.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Vortex.color_mode = MODE_COLORS_MODE_SPECIFIC;
Vortex.colors.resize(4);
Vortex.colors[0] = ToRGBColor(100, 100, 100);
Vortex.colors[1] = ToRGBColor(0, 100, 0);
Vortex.colors[2] = ToRGBColor(255, 255, 255);
Vortex.colors[3] = ToRGBColor(255, 0, 0);
Vortex.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
Vortex.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
Vortex.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
Vortex.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
Vortex.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
Vortex.speed = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
Vortex.direction = MODE_DIRECTION_RIGHT;
modes.push_back(Vortex);
mode CrossingOver;
CrossingOver.name = "Crossing Over";
CrossingOver.value = LianLiGAIITrinityController::GAII_Modes::M_CROSSING_OVER;
CrossingOver.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
CrossingOver.color_mode = MODE_COLORS_MODE_SPECIFIC;
CrossingOver.colors.resize(4);
CrossingOver.colors[0] = ToRGBColor(255, 0, 0);
CrossingOver.colors[1] = ToRGBColor(0, 255, 0);
CrossingOver.colors[2] = ToRGBColor(0, 0, 255);
CrossingOver.colors[3] = ToRGBColor(255, 255, 0);
CrossingOver.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
CrossingOver.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
CrossingOver.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
CrossingOver.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
CrossingOver.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
CrossingOver.speed = LianLiGAIITrinityController::GAII_Speed::S_FAST;
CrossingOver.direction = MODE_DIRECTION_RIGHT;
modes.push_back(CrossingOver);
mode TaiChi;
TaiChi.name = "Tai Chi";
TaiChi.value = LianLiGAIITrinityController::GAII_Modes::M_TAI_CHI;
TaiChi.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
TaiChi.color_mode = MODE_COLORS_MODE_SPECIFIC;
TaiChi.colors.resize(2);
TaiChi.colors[0] = ToRGBColor(255, 0, 0);
TaiChi.colors[1] = ToRGBColor(0, 255, 0);
TaiChi.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
TaiChi.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
TaiChi.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
TaiChi.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
TaiChi.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
TaiChi.speed = LianLiGAIITrinityController::GAII_Speed::S_MODERATE;
TaiChi.direction = MODE_DIRECTION_RIGHT;
modes.push_back(TaiChi);
mode ColorfulStarryNight;
ColorfulStarryNight.name = "Colorful Starry Night";
ColorfulStarryNight.value = LianLiGAIITrinityController::GAII_Modes::M_COLORFUL_STARRY_NIGHT;
ColorfulStarryNight.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
ColorfulStarryNight.color_mode = MODE_COLORS_RANDOM;
ColorfulStarryNight.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
ColorfulStarryNight.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
ColorfulStarryNight.brightness = LianLiGAIITrinityController::GAII_Brightness::B_50;
ColorfulStarryNight.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
ColorfulStarryNight.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
ColorfulStarryNight.speed = LianLiGAIITrinityController::GAII_Speed::S_SLOW;
modes.push_back(ColorfulStarryNight);
mode StaticStarryNight;
StaticStarryNight.name = "Static Starry Night";
StaticStarryNight.value = LianLiGAIITrinityController::GAII_Modes::M_STATIC_STARRY_NIGHT;
StaticStarryNight.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
StaticStarryNight.color_mode = MODE_COLORS_MODE_SPECIFIC;
StaticStarryNight.colors.resize(1);
StaticStarryNight.colors[0] = ToRGBColor(255, 255, 0);
StaticStarryNight.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
StaticStarryNight.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
StaticStarryNight.brightness = LianLiGAIITrinityController::GAII_Brightness::B_50;
StaticStarryNight.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
StaticStarryNight.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
StaticStarryNight.speed = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
modes.push_back(StaticStarryNight);
mode Voice;
Voice.name = "Voice";
Voice.value = LianLiGAIITrinityController::GAII_Modes::M_VOICE;
Voice.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
Voice.color_mode = MODE_COLORS_MODE_SPECIFIC;
Voice.colors.resize(2);
Voice.colors[0] = ToRGBColor(255, 255, 255);
Voice.colors[1] = ToRGBColor(130, 130, 130);
Voice.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
Voice.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
Voice.brightness = LianLiGAIITrinityController::GAII_Brightness::B_100;
Voice.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
Voice.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
Voice.speed = LianLiGAIITrinityController::GAII_Speed::S_SLOW;
modes.push_back(Voice);
mode BigBang;
BigBang.name = "Big Bang";
BigBang.value = LianLiGAIITrinityController::GAII_Modes::M_BIG_BANG;
BigBang.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
BigBang.color_mode = MODE_COLORS_MODE_SPECIFIC;
BigBang.colors.resize(4);
BigBang.colors[0] = ToRGBColor(255, 255, 255);
BigBang.colors[1] = ToRGBColor(255, 0, 0);
BigBang.colors[2] = ToRGBColor(255, 255, 255);
BigBang.colors[3] = ToRGBColor(0, 255, 0);
BigBang.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
BigBang.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
BigBang.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
BigBang.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
BigBang.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
BigBang.speed = LianLiGAIITrinityController::GAII_Speed::S_FAST;
modes.push_back(BigBang);
mode Pump;
Pump.name = "Pump";
Pump.value = LianLiGAIITrinityController::GAII_Modes::M_PUMP;
Pump.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Pump.color_mode = MODE_COLORS_MODE_SPECIFIC;
Pump.colors.resize(2);
Pump.colors[0] = ToRGBColor(0, 255, 0);
Pump.colors[1] = ToRGBColor(150, 150, 150);
Pump.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
Pump.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
Pump.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
Pump.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
Pump.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
Pump.speed = LianLiGAIITrinityController::GAII_Speed::S_FAST;
Pump.direction = MODE_DIRECTION_RIGHT;
modes.push_back(Pump);
mode ColorsMorph;
ColorsMorph.name = "Colors Morph";
ColorsMorph.value = LianLiGAIITrinityController::GAII_Modes::M_COLORS_MORPH;
ColorsMorph.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
ColorsMorph.color_mode = MODE_COLORS_RANDOM;
ColorsMorph.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
ColorsMorph.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
ColorsMorph.brightness = LianLiGAIITrinityController::GAII_Brightness::B_100;
ColorsMorph.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
ColorsMorph.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
ColorsMorph.speed = LianLiGAIITrinityController::GAII_Speed::S_MODERATE;
ColorsMorph.direction = MODE_DIRECTION_RIGHT;
modes.push_back(ColorsMorph);
SetupZones();
}
RGBController_LianLiGAIITrinity::~RGBController_LianLiGAIITrinity()
{
delete controller;
}
void RGBController_LianLiGAIITrinity::SetupZones()
{
/*-------------------------------------------------*\
| Set zones and leds |
\*-------------------------------------------------*/
zone gaii_trinity;
gaii_trinity.name = "GAII Trinity";
gaii_trinity.type = ZONE_TYPE_SINGLE;
gaii_trinity.leds_min = 2;
gaii_trinity.leds_max = 2;
gaii_trinity.leds_count = 2;
gaii_trinity.matrix_map = NULL;
zones.push_back(gaii_trinity);
led inner_led;
inner_led.name = "Inner Ring LEDs";
leds.push_back(inner_led);
led outer_led;
outer_led.name = "Outer Ring LEDs";
leds.push_back(outer_led);
SetupColors();
// set default color values
zones[0].colors[0] = ToRGBColor(255, 255, 255);
zones[0].colors[1] = ToRGBColor(0, 0, 255);
}
void RGBController_LianLiGAIITrinity::ResizeZone(int /* zone */, int /* new_size */)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_LianLiGAIITrinity::DeviceUpdateLEDs()
{
switch(modes[active_mode].value)
{
case LianLiGAIITrinityController::GAII_Modes::M_RAINBOW:
controller->SetMode_Rainbow(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
OpenRGBDirection2GAIIDirection(modes[active_mode].direction));
break;
case LianLiGAIITrinityController::GAII_Modes::M_RAINBOW_MORPH:
controller->SetMode_RainbowMorph(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed));
break;
case LianLiGAIITrinityController::GAII_Modes::M_STATIC_COLOR:
controller->SetMode_StaticColor(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
zones[0].colors[0], zones[0].colors[1]);
break;
case LianLiGAIITrinityController::GAII_Modes::M_BREATHING_COLOR:
controller->SetMode_BreathingColor(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
modes[active_mode].colors[0], modes[active_mode].colors[1]);
break;
case LianLiGAIITrinityController::GAII_Modes::M_RUNWAY:
controller->SetMode_Runway(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
modes[active_mode].colors[0], modes[active_mode].colors[1]);
break;
case LianLiGAIITrinityController::GAII_Modes::M_METEOR:
controller->SetMode_Meteor(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
OpenRGBDirection2GAIIDirection(modes[active_mode].direction),
modes[active_mode].colors[0], modes[active_mode].colors[1], modes[active_mode].colors[2], modes[active_mode].colors[3]);
break;
case LianLiGAIITrinityController::GAII_Modes::M_VORTEX:
controller->SetMode_Vortex(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
OpenRGBDirection2GAIIDirection(modes[active_mode].direction),
modes[active_mode].colors[0], modes[active_mode].colors[1], modes[active_mode].colors[2], modes[active_mode].colors[3]);
break;
case LianLiGAIITrinityController::GAII_Modes::M_CROSSING_OVER:
controller->SetMode_CrossingOver(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
OpenRGBDirection2GAIIDirection(modes[active_mode].direction),
modes[active_mode].colors[0], modes[active_mode].colors[1], modes[active_mode].colors[2], modes[active_mode].colors[3]);
break;
case LianLiGAIITrinityController::GAII_Modes::M_TAI_CHI:
controller->SetMode_TaiChi(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
OpenRGBDirection2GAIIDirection(modes[active_mode].direction),
modes[active_mode].colors[0], modes[active_mode].colors[1]);
break;
case LianLiGAIITrinityController::GAII_Modes::M_COLORFUL_STARRY_NIGHT:
controller->SetMode_ColorfulStarryNight(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed));
break;
case LianLiGAIITrinityController::GAII_Modes::M_STATIC_STARRY_NIGHT:
controller->SetMode_StaticStarryNight(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
modes[active_mode].colors[0]);
break;
case LianLiGAIITrinityController::GAII_Modes::M_VOICE:
controller->SetMode_Voice(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
modes[active_mode].colors[0], modes[active_mode].colors[1]);
break;
case LianLiGAIITrinityController::GAII_Modes::M_BIG_BANG:
controller->SetMode_BigBang(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
modes[active_mode].colors[0], modes[active_mode].colors[1], modes[active_mode].colors[2], modes[active_mode].colors[3]);
break;
case LianLiGAIITrinityController::GAII_Modes::M_PUMP:
controller->SetMode_Pump(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
OpenRGBDirection2GAIIDirection(modes[active_mode].direction),
modes[active_mode].colors[0], modes[active_mode].colors[1]);
break;
case LianLiGAIITrinityController::GAII_Modes::M_COLORS_MORPH:
controller->SetMode_ColorsMorph(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
OpenRGBDirection2GAIIDirection(modes[active_mode].direction));
break;
}
}
void RGBController_LianLiGAIITrinity::UpdateZoneLEDs(int /* zone */)
{
DeviceUpdateLEDs();
}
void RGBController_LianLiGAIITrinity::UpdateSingleLED(int /* led */)
{
DeviceUpdateLEDs();
}
void RGBController_LianLiGAIITrinity::DeviceUpdateMode()
{
DeviceUpdateLEDs();
}
void RGBController_LianLiGAIITrinity::SetCustomMode()
{
}

45
Controllers/LianLiController/RGBController_LianLiGAIITrinity.h Normal file
View File

@@ -0,0 +1,45 @@
/*-----------------------------------------*\
| RGBController_LianLiGAIITrinity.h |
| |
| Lian Li GAII Trinity AIO LED Driver |
| |
| Michael Losert 2023-10-27 |
\*-----------------------------------------*/
#pragma once
#include <cstdint>
#include <vector>
#include "LianLiGAIITrinityController.h"
#include "RGBController.h"
class RGBController_LianLiGAIITrinity : public RGBController
{
public:
RGBController_LianLiGAIITrinity(LianLiGAIITrinityController* controller_ptr);
~RGBController_LianLiGAIITrinity();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void SetCustomMode();
LianLiGAIITrinityController::GAII_Direction OpenRGBDirection2GAIIDirection(unsigned int openrgb_direction)
{
if(openrgb_direction == MODE_DIRECTION_LEFT)
return LianLiGAIITrinityController::GAII_Direction::D_LEFT;
return LianLiGAIITrinityController::GAII_Direction::D_RIGHT;
}
private:
LianLiGAIITrinityController* controller;
};

4
OpenRGB.pro
View File

@@ -604,6 +604,8 @@ HEADERS +=
Controllers/LianLiController/RGBController_LianLiUniHubSLInfinity.h \
Controllers/LianLiController/LianLiUniHubSLV2Controller.h \
Controllers/LianLiController/RGBController_LianLiUniHubSLV2.h \
Controllers/LianLiController/LianLiGAIITrinityController.h \
Controllers/LianLiController/RGBController_LianLiGAIITrinity.h \
Controllers/LogitechController/LogitechProtocolCommon.h \
Controllers/LogitechController/LogitechG203LController.h \
Controllers/LogitechController/LogitechG213Controller.h \
@@ -1291,6 +1293,8 @@ SOURCES +=
Controllers/LianLiController/RGBController_LianLiUniHubSLInfinity.cpp \
Controllers/LianLiController/LianLiUniHubSLV2Controller.cpp \
Controllers/LianLiController/RGBController_LianLiUniHubSLV2.cpp \
Controllers/LianLiController/LianLiGAIITrinityController.cpp \
Controllers/LianLiController/RGBController_LianLiGAIITrinity.cpp \
Controllers/LogitechController/LogitechControllerDetect.cpp \
Controllers/LogitechController/LogitechProtocolCommon.cpp \
Controllers/LogitechController/LogitechG203LController.cpp \