From dbeabe613d169d0f56f9892180cf6246aea0be39 Mon Sep 17 00:00:00 2001 From: Michael Losert Date: Wed, 8 Nov 2023 17:54:20 +0000 Subject: [PATCH] Add support for Lian Li GAII Trinity AIO --- .../LianLiControllerDetect.cpp | 28 +- .../LianLiGAIITrinityController.cpp | 298 +++++++++++++ .../LianLiGAIITrinityController.h | 146 ++++++ .../RGBController_LianLiGAIITrinity.cpp | 422 ++++++++++++++++++ .../RGBController_LianLiGAIITrinity.h | 45 ++ OpenRGB.pro | 4 + 6 files changed, 938 insertions(+), 5 deletions(-) create mode 100644 Controllers/LianLiController/LianLiGAIITrinityController.cpp create mode 100644 Controllers/LianLiController/LianLiGAIITrinityController.h create mode 100644 Controllers/LianLiController/RGBController_LianLiGAIITrinity.cpp create mode 100644 Controllers/LianLiController/RGBController_LianLiGAIITrinity.h diff --git a/Controllers/LianLiController/LianLiControllerDetect.cpp b/Controllers/LianLiController/LianLiControllerDetect.cpp index f4c97c33..853053c7 100644 --- a/Controllers/LianLiController/LianLiControllerDetect.cpp +++ b/Controllers/LianLiController/LianLiControllerDetect.cpp @@ -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); diff --git a/Controllers/LianLiController/LianLiGAIITrinityController.cpp b/Controllers/LianLiController/LianLiGAIITrinityController.cpp new file mode 100644 index 00000000..659dab48 --- /dev/null +++ b/Controllers/LianLiController/LianLiGAIITrinityController.cpp @@ -0,0 +1,298 @@ +/*-----------------------------------------*\ +| LianLiGAIITrinityController.cpp | +| | +| Controller for Lian Li GAII Trinity | +| | +| Michael Losert 2023-10-27 | +\*-----------------------------------------*/ + +#include "LianLiGAIITrinityController.h" +#include +#include +#include +#include + +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(&data[0x06])); + memset(data, 0, sizeof(data)); + hid_read(dev, data, sizeof(data)); + data[sizeof(data) - 1] = 0; + response += " (" + std::string(reinterpret_cast(&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); +} diff --git a/Controllers/LianLiController/LianLiGAIITrinityController.h b/Controllers/LianLiController/LianLiGAIITrinityController.h new file mode 100644 index 00000000..2aa1e13b --- /dev/null +++ b/Controllers/LianLiController/LianLiGAIITrinityController.h @@ -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 +#ifdef __FreeBSD__ +#include +#else +#include +#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; +}; diff --git a/Controllers/LianLiController/RGBController_LianLiGAIITrinity.cpp b/Controllers/LianLiController/RGBController_LianLiGAIITrinity.cpp new file mode 100644 index 00000000..f3fa2d3f --- /dev/null +++ b/Controllers/LianLiController/RGBController_LianLiGAIITrinity.cpp @@ -0,0 +1,422 @@ +/*-----------------------------------------*\ +| RGBController_LianLiGAIITrinity.cpp | +| | +| Lian Li GAII Trinity AIO LED Driver | +| | +| Michael Losert 2023-10-27 | +\*-----------------------------------------*/ + +#include "RGBController_LianLiGAIITrinity.h" + +#include + +/**------------------------------------------------------------------*\ + @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(modes[active_mode].brightness), + static_cast(modes[active_mode].speed), + OpenRGBDirection2GAIIDirection(modes[active_mode].direction)); + break; + case LianLiGAIITrinityController::GAII_Modes::M_RAINBOW_MORPH: + controller->SetMode_RainbowMorph(static_cast(modes[active_mode].brightness), + static_cast(modes[active_mode].speed)); + break; + case LianLiGAIITrinityController::GAII_Modes::M_STATIC_COLOR: + controller->SetMode_StaticColor(static_cast(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(modes[active_mode].brightness), + static_cast(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(modes[active_mode].brightness), + static_cast(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(modes[active_mode].brightness), + static_cast(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(modes[active_mode].brightness), + static_cast(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(modes[active_mode].brightness), + static_cast(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(modes[active_mode].brightness), + static_cast(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(modes[active_mode].brightness), + static_cast(modes[active_mode].speed)); + break; + case LianLiGAIITrinityController::GAII_Modes::M_STATIC_STARRY_NIGHT: + controller->SetMode_StaticStarryNight(static_cast(modes[active_mode].brightness), + static_cast(modes[active_mode].speed), + modes[active_mode].colors[0]); + break; + case LianLiGAIITrinityController::GAII_Modes::M_VOICE: + controller->SetMode_Voice(static_cast(modes[active_mode].brightness), + static_cast(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(modes[active_mode].brightness), + static_cast(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(modes[active_mode].brightness), + static_cast(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(modes[active_mode].brightness), + static_cast(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() +{ + +} + diff --git a/Controllers/LianLiController/RGBController_LianLiGAIITrinity.h b/Controllers/LianLiController/RGBController_LianLiGAIITrinity.h new file mode 100644 index 00000000..ff5fadc2 --- /dev/null +++ b/Controllers/LianLiController/RGBController_LianLiGAIITrinity.h @@ -0,0 +1,45 @@ +/*-----------------------------------------*\ +| RGBController_LianLiGAIITrinity.h | +| | +| Lian Li GAII Trinity AIO LED Driver | +| | +| Michael Losert 2023-10-27 | +\*-----------------------------------------*/ + +#pragma once + +#include +#include + +#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; +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index fa9053ec..5b1598d0 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -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 \