jalr/OpenRGB
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial Cryorig H7 Quad Lumi control

Browse source
This commit is contained in:
Adam Honse 2023-04-16 20:19:52 +00:00
parent 2e764ccfb0
commit f907b2f5c5
6 changed files with 711 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

235
Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.cpp Normal file
View file

@ -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 <fstream>
#include <iostream>
#include <string>
#include <cstring>
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]);
}

88
Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.h Normal file
View file

@ -0,0 +1,88 @@
/*---------------------------------------------------------*\
| Definitions for Cryorig H7 Quad Lumi |
| |
| Adam Honse (calcprogrammer1@gmail.com), 4/15/2023 |
\*---------------------------------------------------------*/
#include "RGBController.h"
#include <string>
#include <vector>
#include <hidapi/hidapi.h>
#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();
};

27
Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiControllerDetect.cpp Normal file
View file

@ -0,0 +1,27 @@
#include "Detector.h"
#include "CryorigH7QuadLumiController.h"
#include "RGBController.h"
#include "RGBController_CryorigH7QuadLumi.h"
#include <hidapi/hidapi.h>
/*-----------------------------------------------------*\
| 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);

320
Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.cpp Normal file
View file

@ -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()
);
}
}
}

35
Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.h Normal file
View file

@ -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<unsigned int> leds_channel;
std::vector<unsigned int> zones_channel;
};