From f907b2f5c5ba4219c1ee405869313e0cc8151147 Mon Sep 17 00:00:00 2001 From: Adam Honse Date: Sun, 16 Apr 2023 20:19:52 +0000 Subject: [PATCH] Initial Cryorig H7 Quad Lumi control --- .../CryorigH7QuadLumiController.cpp | 235 +++++++++++++ .../CryorigH7QuadLumiController.h | 88 +++++ .../CryorigH7QuadLumiControllerDetect.cpp | 27 ++ .../RGBController_CryorigH7QuadLumi.cpp | 320 ++++++++++++++++++ .../RGBController_CryorigH7QuadLumi.h | 35 ++ OpenRGB.pro | 6 + 6 files changed, 711 insertions(+) create mode 100644 Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.cpp create mode 100644 Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.h create mode 100644 Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiControllerDetect.cpp create mode 100644 Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.cpp create mode 100644 Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.h diff --git a/Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.cpp b/Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.cpp new file mode 100644 index 00000000..a3c20449 --- /dev/null +++ b/Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.cpp @@ -0,0 +1,235 @@ +/*---------------------------------------------------------*\ +| Processing Code for Cryorig H7 Quad Lumi | +| | +| Adam Honse (calcprogrammer1@gmail.com), 4/15/2023 | +\*---------------------------------------------------------*/ + +#include "CryorigH7QuadLumiController.h" +#include "LogManager.h" + +#include +#include +#include +#include + +CryorigH7QuadLumiController::CryorigH7QuadLumiController(hid_device* dev_handle, const char* path) +{ + dev = dev_handle; + location = path; + + SendFirmwareRequest(); +} + +CryorigH7QuadLumiController::~CryorigH7QuadLumiController() +{ + hid_close(dev); +} + +std::string CryorigH7QuadLumiController::GetLocation() +{ + return("HID: " + location); +} + +std::string CryorigH7QuadLumiController::GetFirmwareVersion() +{ + return(firmware_version); +} + +std::string CryorigH7QuadLumiController::GetSerialString() +{ + wchar_t serial_string[128]; + int ret = hid_get_serial_number_string(dev, serial_string, 128); + + if(ret != 0) + { + return(""); + } + + std::wstring return_wstring = serial_string; + std::string return_string(return_wstring.begin(), return_wstring.end()); + + return(return_string); +} + +void CryorigH7QuadLumiController::SetChannelEffect + ( + unsigned char channel, + unsigned char mode, + unsigned char speed, + bool direction, + RGBColor * colors, + unsigned int num_colors + ) +{ + unsigned char color_data[120]; + + /*-----------------------------------------------------*\ + | If mode requires no colors, send packet | + \*-----------------------------------------------------*/ + if(num_colors == 0) + { + /*-----------------------------------------------------*\ + | Send mode without color data | + \*-----------------------------------------------------*/ + SendPacket(channel, mode, direction, 0, speed, 0, NULL); + } + /*-----------------------------------------------------*\ + | If mode requires indexed colors, send color index | + | packets for each mode color | + \*-----------------------------------------------------*/ + else if(num_colors <= 8) + { + for(std::size_t color_idx = 0; color_idx < num_colors; color_idx++) + { + /*-----------------------------------------------------*\ + | Fill in color data (40 entries per color) | + \*-----------------------------------------------------*/ + for (std::size_t idx = 0; idx < 40; idx++) + { + int pixel_idx = idx * 3; + RGBColor color = colors[color_idx]; + color_data[pixel_idx + 0x00] = RGBGetGValue(color); + color_data[pixel_idx + 0x01] = RGBGetRValue(color); + color_data[pixel_idx + 0x02] = RGBGetBValue(color); + } + + /*-----------------------------------------------------*\ + | Send mode and color data | + \*-----------------------------------------------------*/ + SendPacket(channel, mode, direction, color_idx, speed, 40, &color_data[0]); + } + } + /*-----------------------------------------------------*\ + | If mode requires per-LED colors, fill colors array | + \*-----------------------------------------------------*/ + else + { + /*-----------------------------------------------------*\ + | Fill in color data (up to 40 colors) | + \*-----------------------------------------------------*/ + for (std::size_t idx = 0; idx < num_colors; idx++) + { + int pixel_idx = idx * 3; + RGBColor color = colors[idx]; + color_data[pixel_idx + 0x00] = RGBGetGValue(color); + color_data[pixel_idx + 0x01] = RGBGetRValue(color); + color_data[pixel_idx + 0x02] = RGBGetBValue(color); + } + + /*-----------------------------------------------------*\ + | Send mode and color data | + \*-----------------------------------------------------*/ + SendPacket(channel, mode, direction, 0, speed, num_colors, &color_data[0]); + } +} + +void CryorigH7QuadLumiController::SetChannelLEDs + ( + unsigned char channel, + RGBColor * colors, + unsigned int num_colors + ) +{ + unsigned char color_data[120]; + + /*-----------------------------------------------------*\ + | Fill in color data (up to 40 colors) | + \*-----------------------------------------------------*/ + for (std::size_t idx = 0; idx < num_colors; idx++) + { + int pixel_idx = idx * 3; + RGBColor color = colors[idx]; + color_data[pixel_idx + 0x00] = RGBGetGValue(color); + color_data[pixel_idx + 0x01] = RGBGetRValue(color); + color_data[pixel_idx + 0x02] = RGBGetBValue(color); + } + + /*-----------------------------------------------------*\ + | Send color data | + \*-----------------------------------------------------*/ + SendPacket(channel, CRYORIG_H7_QUAD_LUMI_MODE_FIXED, false, 0, 0, num_colors, &color_data[0]); +} + +/*-------------------------------------------------------------------------------------------------*\ +| Private packet sending functions. | +\*-------------------------------------------------------------------------------------------------*/ + +void CryorigH7QuadLumiController::SendPacket + ( + unsigned char channel, + unsigned char mode, + bool direction, + unsigned char color_idx, + unsigned char speed, + unsigned char color_count, + unsigned char* color_data + ) +{ + unsigned char usb_buf[65]; + + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x02; + usb_buf[0x01] = 0x4C; + + /*-----------------------------------------------------*\ + | Set channel in serial packet | + \*-----------------------------------------------------*/ + usb_buf[0x02] = channel + 1; + + /*-----------------------------------------------------*\ + | Set mode in serial packet | + \*-----------------------------------------------------*/ + usb_buf[0x03] = mode; + + /*-----------------------------------------------------*\ + | Set options bitfield in serial packet | + \*-----------------------------------------------------*/ + usb_buf[0x04] = 0; + usb_buf[0x04] |= direction ? ( 1 << 4 ) : 0; + + /*-----------------------------------------------------*\ + | Copy in color data bytes | + \*-----------------------------------------------------*/ + memcpy(&usb_buf[0x05 + (channel * 15)], color_data, color_count * 3); + + /*-----------------------------------------------------*\ + | Send packet | + \*-----------------------------------------------------*/ + hid_write(dev, usb_buf, 65); +} + +void CryorigH7QuadLumiController::SendFirmwareRequest() +{ + unsigned char usb_buf[17]; + unsigned int ret_val = 0; + + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up Firmware Request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x02; + usb_buf[0x01] = 0x5C; + + hid_write(dev, usb_buf, 65); + + /*-----------------------------------------------------*\ + | Receive packets until 0x11 0x01 is received | + \*-----------------------------------------------------*/ + do + { + ret_val = hid_read(dev, usb_buf, sizeof(usb_buf)); + } while( (ret_val != 17) ); + + snprintf(firmware_version, 16, "%u.%u", usb_buf[0x0D], usb_buf[0x0E]); +} diff --git a/Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.h b/Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.h new file mode 100644 index 00000000..22cfd8e3 --- /dev/null +++ b/Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.h @@ -0,0 +1,88 @@ +/*---------------------------------------------------------*\ +| Definitions for Cryorig H7 Quad Lumi | +| | +| Adam Honse (calcprogrammer1@gmail.com), 4/15/2023 | +\*---------------------------------------------------------*/ + +#include "RGBController.h" +#include +#include +#include + +#pragma once + +enum +{ + CRYORIG_H7_QUAD_LUMI_CHANNEL_ALL = 0x00, /* All channels */ + CRYORIG_H7_QUAD_LUMI_CHANNEL_1 = 0x01, /* Channel 1 */ + CRYORIG_H7_QUAD_LUMI_CHANNEL_2 = 0x02, /* Channel 2 */ + CRYORIG_H7_QUAD_LUMI_NUM_CHANNELS = 0x02 /* Number of channels */ +}; + +enum +{ + CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST = 0x00, /* Slowest speed */ + CRYORIG_H7_QUAD_LUMI_SPEED_SLOW = 0x01, /* Slow speed */ + CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL = 0x02, /* Normal speed */ + CRYORIG_H7_QUAD_LUMI_SPEED_FAST = 0x03, /* Fast speed */ + CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST = 0x04, /* Fastest speed */ +}; + +enum +{ + CRYORIG_H7_QUAD_LUMI_MODE_FIXED = 0x00, /* Fixed colors mode */ + CRYORIG_H7_QUAD_LUMI_MODE_FADING = 0x01, /* Fading mode */ + CRYORIG_H7_QUAD_LUMI_MODE_SPECTRUM = 0x02, /* Spectrum cycle mode */ + CRYORIG_H7_QUAD_LUMI_MODE_MARQUEE = 0x03, /* Marquee mode */ + CRYORIG_H7_QUAD_LUMI_MODE_COVER_MARQUE = 0x04, /* Cover marquee mode */ + CRYORIG_H7_QUAD_LUMI_MODE_ALTERNATING = 0x05, /* Alternating mode */ + CRYORIG_H7_QUAD_LUMI_MODE_BREATHING = 0x06, /* Breathing mode */ + CRYORIG_H7_QUAD_LUMI_MODE_PULSING = 0x07, /* Pulsing mode */ +}; + +class CryorigH7QuadLumiController +{ +public: + CryorigH7QuadLumiController(hid_device* dev_handle, const char* path); + ~CryorigH7QuadLumiController(); + + std::string GetFirmwareVersion(); + std::string GetLocation(); + std::string GetSerialString(); + + void SetChannelEffect + ( + unsigned char channel, + unsigned char mode, + unsigned char speed, + bool direction, + RGBColor * colors, + unsigned int num_colors + ); + + void SetChannelLEDs + ( + unsigned char channel, + RGBColor * colors, + unsigned int num_colors + ); + +private: + hid_device* dev; + + char firmware_version[16]; + std::string location; + + void SendPacket + ( + unsigned char channel, + unsigned char mode, + bool direction, + unsigned char color_idx, + unsigned char speed, + unsigned char color_count, + unsigned char* color_data + ); + + void SendFirmwareRequest(); +}; diff --git a/Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiControllerDetect.cpp b/Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiControllerDetect.cpp new file mode 100644 index 00000000..24ca3519 --- /dev/null +++ b/Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiControllerDetect.cpp @@ -0,0 +1,27 @@ +#include "Detector.h" +#include "CryorigH7QuadLumiController.h" +#include "RGBController.h" +#include "RGBController_CryorigH7QuadLumi.h" +#include + +/*-----------------------------------------------------*\ +| CRYORIG/NZXT USB IDs | +\*-----------------------------------------------------*/ +#define NZXT_VID 0x1E71 +#define CRYORIG_H7_QUAD_LUMI_PID 0x1712 + +static void DetectCryorigH7QuadLumi(hid_device_info* info, const std::string& name) +{ + hid_device* dev = hid_open_path(info->path); + + if(dev) + { + CryorigH7QuadLumiController* controller = new CryorigH7QuadLumiController(dev, info->path); + RGBController_CryorigH7QuadLumi* rgb_controller = new RGBController_CryorigH7QuadLumi(controller); + rgb_controller->name = name; + + ResourceManager::get()->RegisterRGBController(rgb_controller); + } +} + +REGISTER_HID_DETECTOR("CRYORIG H7 Quad Lumi", DetectCryorigH7QuadLumi, NZXT_VID, CRYORIG_H7_QUAD_LUMI_PID); diff --git a/Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.cpp b/Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.cpp new file mode 100644 index 00000000..0234dfdc --- /dev/null +++ b/Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.cpp @@ -0,0 +1,320 @@ +/*-----------------------------------------*\ +| RGBController_CryorigH7QuadLumi.cpp | +| | +| Generic RGB Interface for Cryorig H7 | +| Quad Lumi | +| | +| Adam Honse (CalcProgrammer1) 4/15/2023 | +\*-----------------------------------------*/ + +#include "RGBController_CryorigH7QuadLumi.h" + + +RGBController_CryorigH7QuadLumi::RGBController_CryorigH7QuadLumi(CryorigH7QuadLumiController* controller_ptr) +{ + controller = controller_ptr; + + name = "CRYORIG H7 Quad Lumi"; + vendor = "CRYORIG"; + type = DEVICE_TYPE_COOLER; + description = "CRYORIG H7 Quad Lumi Device"; + version = controller->GetFirmwareVersion(); + location = controller->GetLocation(); + serial = controller->GetSerialString(); + + mode Direct; + Direct.name = "Direct"; + Direct.value = CRYORIG_H7_QUAD_LUMI_MODE_FIXED; + Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; + Direct.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Direct); + + // mode Fading; + // Fading.name = "Fading"; + // Fading.value = CRYORIG_H7_QUAD_LUMI_MODE_FADING; + // Fading.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + // Fading.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST; + // Fading.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST; + // Fading.colors_min = 1; + // Fading.colors_max = 8; + // Fading.speed = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL; + // Fading.color_mode = MODE_COLORS_MODE_SPECIFIC; + // Fading.colors.resize(2); + // modes.push_back(Fading); + + // mode SpectrumCycle; + // SpectrumCycle.name = "Spectrum Cycle"; + // SpectrumCycle.value = CRYORIG_H7_QUAD_LUMI_MODE_SPECTRUM; + // SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR; + // SpectrumCycle.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST; + // SpectrumCycle.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST; + // SpectrumCycle.speed = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL; + // SpectrumCycle.direction = MODE_DIRECTION_RIGHT; + // SpectrumCycle.color_mode = MODE_COLORS_NONE; + // modes.push_back(SpectrumCycle); + + // mode Fading; + // Fading.name = "Fading"; + // Fading.value = HUE_1_MODE_FADING; + // Fading.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + // Fading.speed_min = HUE_1_SPEED_SLOWEST; + // Fading.speed_max = HUE_1_SPEED_FASTEST; + // Fading.colors_min = 1; + // Fading.colors_max = 8; + // Fading.speed = HUE_1_SPEED_NORMAL; + // Fading.color_mode = MODE_COLORS_MODE_SPECIFIC; + // Fading.colors.resize(1); + // modes.push_back(Fading); + + // mode SpectrumCycle; + // SpectrumCycle.name = "Spectrum Cycle"; + // SpectrumCycle.value = HUE_1_MODE_SPECTRUM; + // SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR; + // SpectrumCycle.speed_min = HUE_1_SPEED_SLOWEST; + // SpectrumCycle.speed_max = HUE_1_SPEED_FASTEST; + // SpectrumCycle.speed = HUE_1_SPEED_NORMAL; + // SpectrumCycle.direction = MODE_DIRECTION_RIGHT; + // SpectrumCycle.color_mode = MODE_COLORS_NONE; + // modes.push_back(SpectrumCycle); + + // mode Marquee; + // Marquee.name = "Marquee"; + // Marquee.value = HUE_1_MODE_MARQUEE; + // Marquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + // Marquee.speed_min = HUE_1_SPEED_SLOWEST; + // Marquee.speed_max = HUE_1_SPEED_FASTEST; + // Marquee.colors_min = 1; + // Marquee.colors_max = 1; + // Marquee.speed = HUE_2_SPEED_NORMAL; + // Marquee.direction = MODE_DIRECTION_RIGHT; + // Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC; + // Marquee.colors.resize(1); + // modes.push_back(Marquee); + + // mode CoverMarquee; + // CoverMarquee.name = "Cover Marquee"; + // CoverMarquee.value = HUE_1_MODE_COVER_MARQUEE; + // CoverMarquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + // CoverMarquee.speed_min = HUE_1_SPEED_SLOWEST; + // CoverMarquee.speed_max = HUE_1_SPEED_FASTEST; + // CoverMarquee.colors_min = 1; + // CoverMarquee.colors_max = 8; + // CoverMarquee.speed = HUE_2_SPEED_NORMAL; + // CoverMarquee.direction = MODE_DIRECTION_RIGHT; + // CoverMarquee.color_mode = MODE_COLORS_MODE_SPECIFIC; + // CoverMarquee.colors.resize(1); + // modes.push_back(CoverMarquee); + + // mode Alternating; + // Alternating.name = "Alternating"; + // Alternating.value = HUE_1_MODE_ALTERNATING; + // Alternating.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + // Alternating.speed_min = HUE_1_SPEED_SLOWEST; + // Alternating.speed_max = HUE_1_SPEED_FASTEST; + // Alternating.colors_min = 1; + // Alternating.colors_max = 2; + // Alternating.speed = HUE_1_SPEED_NORMAL; + // Alternating.direction = MODE_DIRECTION_RIGHT; + // Alternating.color_mode = MODE_COLORS_MODE_SPECIFIC; + // Alternating.colors.resize(1); + // modes.push_back(Alternating); + + // mode Pulsing; + // Pulsing.name = "Pulsing"; + // Pulsing.value = HUE_1_MODE_PULSING; + // Pulsing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + // Pulsing.speed_min = HUE_1_SPEED_SLOWEST; + // Pulsing.speed_max = HUE_1_SPEED_FASTEST; + // Pulsing.colors_min = 1; + // Pulsing.colors_max = 8; + // Pulsing.speed = HUE_1_SPEED_NORMAL; + // Pulsing.color_mode = MODE_COLORS_MODE_SPECIFIC; + // Pulsing.colors.resize(1) ; + // modes.push_back(Pulsing); + + // mode Breathing; + // Breathing.name = "Breathing"; + // Breathing.value = HUE_1_MODE_BREATHING; + // Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR; + // Breathing.speed_min = HUE_1_SPEED_SLOWEST; + // Breathing.speed_max = HUE_1_SPEED_FASTEST; + // Breathing.colors_min = 1; + // Breathing.colors_max = 8; + // Breathing.speed = HUE_2_SPEED_NORMAL; + // Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; + // Breathing.colors.resize( 1); + // modes.push_back(Breathing); + + // mode Candle; + // Candle.name = "Candle"; + // Candle.value = HUE_1_MODE_CANDLE; + // Candle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + // Candle.speed_min = HUE_1_SPEED_SLOWEST; + // Candle.speed_max = HUE_1_SPEED_FASTEST; + // Candle.colors_min = 1; + // Candle.colors_max = 8; + // Candle.speed = HUE_1_SPEED_NORMAL; + // Candle.color_mode = MODE_COLORS_MODE_SPECIFIC; + // Candle.colors.resize(1) ; + // modes.push_back(Candle); + + // mode StarryNight; + // StarryNight.name = "Starry Night"; + // StarryNight.value = HUE_1_MODE_STARRY_NIGHT; + // StarryNight.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + // StarryNight.speed_min = HUE_1_SPEED_SLOWEST; + // StarryNight.speed_max = HUE_1_SPEED_FASTEST; + // StarryNight.colors_min = 1; + // StarryNight.colors_max = 1; + // StarryNight.speed = HUE_2_SPEED_NORMAL; + // StarryNight.color_mode = MODE_COLORS_MODE_SPECIFIC; + // StarryNight.colors.resize(1); + // modes.push_back(StarryNight); + + // mode SuperRainbow; + // SuperRainbow.name = "Super Rainbow"; + // SuperRainbow.value = HUE_1_MODE_SUPER_RAINBOW; + // SuperRainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR; + // SuperRainbow.speed_min = HUE_1_SPEED_SLOWEST; + // SuperRainbow.speed_max = HUE_1_SPEED_FASTEST; + // SuperRainbow.speed = HUE_1_SPEED_NORMAL; + // SuperRainbow.direction = MODE_DIRECTION_RIGHT; + // SuperRainbow.color_mode = MODE_COLORS_NONE; + // modes.push_back(SuperRainbow); + + // mode RainbowPulse; + // RainbowPulse.name = "Rainbow Pulse"; + // RainbowPulse.value = HUE_1_MODE_RAINBOW_PULSE; + // RainbowPulse.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR; + // RainbowPulse.speed_min = HUE_1_SPEED_SLOWEST; + // RainbowPulse.speed_max = HUE_1_SPEED_FASTEST; + // RainbowPulse.speed = HUE_1_SPEED_NORMAL; + // RainbowPulse.direction = MODE_DIRECTION_RIGHT; + // RainbowPulse.color_mode = MODE_COLORS_NONE; + // modes.push_back(RainbowPulse); + + // mode RainbowFlow; + // RainbowFlow.name = "Rainbow Flow"; + // RainbowFlow.value = HUE_1_MODE_RAINBOW_FLOW; + // RainbowFlow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR; + // RainbowFlow.speed_min = HUE_1_SPEED_SLOWEST; + // RainbowFlow.speed_max = HUE_1_SPEED_FASTEST; + // RainbowFlow.speed = HUE_1_SPEED_NORMAL; + // RainbowFlow.direction = MODE_DIRECTION_RIGHT; + // RainbowFlow.color_mode = MODE_COLORS_NONE; + // modes.push_back(RainbowFlow); + + SetupZones(); +} + +RGBController_CryorigH7QuadLumi::~RGBController_CryorigH7QuadLumi() +{ + delete controller; +} + +void RGBController_CryorigH7QuadLumi::SetupZones() +{ + const char* zone_names[] = { "Logo", "Underglow" }; + + /*-------------------------------------------------*\ + | Set up zones | + \*-------------------------------------------------*/ + for(unsigned int zone_idx = 0; zone_idx < 2; zone_idx++) + { + zone* new_zone = new zone; + + new_zone->name = zone_names[zone_idx]; + new_zone->type = ZONE_TYPE_LINEAR; + new_zone->leds_min = 5; + new_zone->leds_max = 5; + new_zone->leds_count = 5; + new_zone->matrix_map = NULL; + + zones.push_back(*new_zone); + } + + /*-------------------------------------------------*\ + | Set up LEDs | + \*-------------------------------------------------*/ + for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++) + { + for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++) + { + led new_led; + new_led.name = zone_names[zone_idx]; + new_led.name.append(", LED "); + new_led.name.append(std::to_string(led_idx + 1)); + new_led.value = zone_idx; + + leds.push_back(new_led); + } + } + + SetupColors(); +} + +void RGBController_CryorigH7QuadLumi::ResizeZone(int /*zone*/, int /*new_size*/) +{ + +} + +void RGBController_CryorigH7QuadLumi::DeviceUpdateLEDs() +{ + for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++) + { + controller->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count); + } +} + +void RGBController_CryorigH7QuadLumi::UpdateZoneLEDs(int zone) +{ + controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count); +} + +void RGBController_CryorigH7QuadLumi::UpdateSingleLED(int led) +{ + unsigned int zone_idx = leds[led].value; + + controller->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count); +} + +void RGBController_CryorigH7QuadLumi::SetCustomMode() +{ + active_mode = 0; +} + +void RGBController_CryorigH7QuadLumi::DeviceUpdateMode() +{ + if(modes[active_mode].value == CRYORIG_H7_QUAD_LUMI_MODE_FIXED) + { + DeviceUpdateLEDs(); + } + else + { + for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++) + { + RGBColor* colors = NULL; + bool direction = false; + + if(modes[active_mode].direction == MODE_DIRECTION_LEFT) + { + direction = true; + } + + if(modes[active_mode].colors.size() > 0) + { + colors = &modes[active_mode].colors[0]; + } + + controller->SetChannelEffect + ( + zone_idx, + modes[active_mode].value, + modes[active_mode].speed, + direction, + colors, + modes[active_mode].colors.size() + ); + } + } +} diff --git a/Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.h b/Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.h new file mode 100644 index 00000000..5b924bf2 --- /dev/null +++ b/Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.h @@ -0,0 +1,35 @@ +/*-----------------------------------------*\ +| RGBController_CryorigH7QuadLumi.h | +| | +| Generic RGB Interface for Cryorig H7 | +| Quad Lumi | +| | +| Adam Honse (CalcProgrammer1) 4/15/2023 | +\*-----------------------------------------*/ + +#pragma once +#include "RGBController.h" +#include "CryorigH7QuadLumiController.h" + +class RGBController_CryorigH7QuadLumi : public RGBController +{ +public: + RGBController_CryorigH7QuadLumi(CryorigH7QuadLumiController* controller_ptr); + ~RGBController_CryorigH7QuadLumi(); + + void SetupZones(); + + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void SetCustomMode(); + void DeviceUpdateMode(); + +private: + CryorigH7QuadLumiController* controller; + std::vector leds_channel; + std::vector zones_channel; +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index f1445bf0..3fe41c0c 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -102,6 +102,7 @@ INCLUDEPATH += Controllers/CorsairWirelessController/ \ Controllers/CreativeController/ \ Controllers/CrucialController/ \ + Controllers/CryorigH7QuadLumiController/ \ Controllers/DasKeyboardController/ \ Controllers/DebugController/ \ Controllers/DuckyKeyboardController/ \ @@ -376,6 +377,8 @@ HEADERS += Controllers/CreativeController/RGBController_CreativeSoundBlasterXG6.h \ Controllers/CrucialController/CrucialController.h \ Controllers/CrucialController/RGBController_Crucial.h \ + Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.h \ + Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.h \ Controllers/DarkProject/DarkProjectKeyboardController.h \ Controllers/DarkProject/RGBController_DarkProjectKeyboard.h \ Controllers/DasKeyboardController/DasKeyboardController.h \ @@ -945,6 +948,9 @@ SOURCES += Controllers/CrucialController/CrucialController.cpp \ Controllers/CrucialController/CrucialControllerDetect.cpp \ Controllers/CrucialController/RGBController_Crucial.cpp \ + Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.cpp \ + Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiControllerDetect.cpp \ + Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.cpp \ Controllers/DebugController/DebugControllerDetect.cpp \ Controllers/DarkProject/DarkProjectControllerDetect.cpp \ Controllers/DarkProject/DarkProjectKeyboardController.cpp \