Jens/LumaOps-Public
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Publish LumaOps source

Browse Source
This commit is contained in:
LumaOps release export
2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.cpp
+242
View File
@@ -0,0 +1,242 @@
/*---------------------------------------------------------*\
| CryorigH7QuadLumiController.cpp |
| |
| Driver for Cryorig H7 Quad Lumi |
| |
| Adam Honse (calcprogrammer1@gmail.com) 15 Apr 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include <fstream>
#include <iostream>
#include <string>
#include "CryorigH7QuadLumiController.h"
#include "LogManager.h"
#include "StringUtils.h"
CryorigH7QuadLumiController::CryorigH7QuadLumiController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
SendFirmwareRequest();
}
CryorigH7QuadLumiController::~CryorigH7QuadLumiController()
{
hid_close(dev);
}
std::string CryorigH7QuadLumiController::GetLocation()
{
return("HID: " + location);
}
std::string CryorigH7QuadLumiController::GetName()
{
return(name);
}
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("");
}
return(StringUtils::wstring_to_string(serial_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(unsigned int color_idx = 0; color_idx < num_colors; color_idx++)
{
/*-----------------------------------------------------*\
| Fill in color data (5 entries per color) |
\*-----------------------------------------------------*/
for(int 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, (unsigned char)color_idx, speed, 5, &color_data[0]);
}
}
/*-----------------------------------------------------*\
| If mode requires per-LED colors, fill colors array |
\*-----------------------------------------------------*/
else
{
/*-----------------------------------------------------*\
| Fill in color data (up to 40 colors) |
\*-----------------------------------------------------*/
for(unsigned int idx = 0; idx < num_colors; idx++)
{
unsigned 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(unsigned int idx = 0; idx < num_colors; idx++)
{
unsigned 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 RGB packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x02;
usb_buf[0x01] = 0x4C;
/*-----------------------------------------------------*\
| Set channel and direction in RGB packet |
\*-----------------------------------------------------*/
usb_buf[0x02] = (channel + 1) | (direction ? (1 << 4) : 0);
/*-----------------------------------------------------*\
| Set mode in RGB packet |
\*-----------------------------------------------------*/
usb_buf[0x03] = mode;
/*-----------------------------------------------------*\
| Set color index and speed in RGB packet |
\*-----------------------------------------------------*/
usb_buf[0x04] = ( color_idx << 5 ) | speed;
/*-----------------------------------------------------*\
| 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]);
}
Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.h
+95
View File
@@ -0,0 +1,95 @@
/*---------------------------------------------------------*\
| CryorigH7QuadLumiController.h |
| |
| Driver for Cryorig H7 Quad Lumi |
| |
| Adam Honse (calcprogrammer1@gmail.com) 15 Apr 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <vector>
#include <hidapi.h>
#include "RGBController.h"
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_MARQUEE = 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, std::string dev_name);
~CryorigH7QuadLumiController();
std::string GetFirmwareVersion();
std::string GetLocation();
std::string GetName();
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;
std::string name;
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();
};
Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiControllerDetect.cpp
+36
View File
@@ -0,0 +1,36 @@
/*---------------------------------------------------------*\
| CryorigH7QuadLumiControllerDetect.cpp |
| |
| Detector for Cryorig H7 Quad Lumi |
| |
| Adam Honse (calcprogrammer1@gmail.com) 15 Apr 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "Detector.h"
#include "CryorigH7QuadLumiController.h"
#include "RGBController_CryorigH7QuadLumi.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, name);
RGBController_CryorigH7QuadLumi* rgb_controller = new RGBController_CryorigH7QuadLumi(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR("CRYORIG H7 Quad Lumi", DetectCryorigH7QuadLumi, NZXT_VID, CRYORIG_H7_QUAD_LUMI_PID);
Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.cpp
+244
View File
@@ -0,0 +1,244 @@
/*---------------------------------------------------------*\
| RGBController_CryorigH7QuadLumi.cpp |
| |
| RGBController for Cryorig H7 Quad Lumi |
| |
| Adam Honse (CalcProgrammer1) 15 Apr 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_CryorigH7QuadLumi.h"
/**------------------------------------------------------------------*\
@name Cryorig H7 Quad Lumi
@category Cooler
@type USB
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectCryorigH7QuadLumi
@comment
\*-------------------------------------------------------------------*/
RGBController_CryorigH7QuadLumi::RGBController_CryorigH7QuadLumi(CryorigH7QuadLumiController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
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 = "Rainbow Wave";
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 Marquee;
Marquee.name = "Marquee";
Marquee.value = CRYORIG_H7_QUAD_LUMI_MODE_MARQUEE;
Marquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Marquee.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
Marquee.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
Marquee.colors_min = 1;
Marquee.colors_max = 1;
Marquee.speed = CRYORIG_H7_QUAD_LUMI_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 = CRYORIG_H7_QUAD_LUMI_MODE_COVER_MARQUEE;
CoverMarquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
CoverMarquee.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
CoverMarquee.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
CoverMarquee.colors_min = 1;
CoverMarquee.colors_max = 8;
CoverMarquee.speed = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
CoverMarquee.direction = MODE_DIRECTION_RIGHT;
CoverMarquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
CoverMarquee.colors.resize(2);
modes.push_back(CoverMarquee);
mode Alternating;
Alternating.name = "Alternating";
Alternating.value = CRYORIG_H7_QUAD_LUMI_MODE_ALTERNATING;
Alternating.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Alternating.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
Alternating.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
Alternating.colors_min = 1;
Alternating.colors_max = 2;
Alternating.speed = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
Alternating.direction = MODE_DIRECTION_RIGHT;
Alternating.color_mode = MODE_COLORS_MODE_SPECIFIC;
Alternating.colors.resize(2);
modes.push_back(Alternating);
mode Pulsing;
Pulsing.name = "Pulsing";
Pulsing.value = CRYORIG_H7_QUAD_LUMI_MODE_PULSING;
Pulsing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Pulsing.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
Pulsing.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
Pulsing.colors_min = 1;
Pulsing.colors_max = 8;
Pulsing.speed = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
Pulsing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Pulsing.colors.resize(2) ;
modes.push_back(Pulsing);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = CRYORIG_H7_QUAD_LUMI_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
Breathing.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
Breathing.colors_min = 1;
Breathing.colors_max = 8;
Breathing.speed = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize(2);
modes.push_back(Breathing);
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(unsigned char zone_idx = 0; zone_idx < (unsigned char)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::DeviceUpdateMode()
{
if(modes[active_mode].value == CRYORIG_H7_QUAD_LUMI_MODE_FIXED)
{
DeviceUpdateLEDs();
}
else
{
for(unsigned char zone_idx = 0; zone_idx < (unsigned char)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,
(unsigned int)modes[active_mode].colors.size()
);
}
}
}
Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.h
+37
View File
@@ -0,0 +1,37 @@
/*---------------------------------------------------------*\
| RGBController_CryorigH7QuadLumi.h |
| |
| RGBController for Cryorig H7 Quad Lumi |
| |
| Adam Honse (CalcProgrammer1) 15 Apr 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#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 DeviceUpdateMode();
private:
CryorigH7QuadLumiController* controller;
std::vector<unsigned int> leds_channel;
std::vector<unsigned int> zones_channel;
};