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/NZXTKrakenController/NZXTKrakenController.cpp
+204
View File
@@ -0,0 +1,204 @@
/*---------------------------------------------------------*\
| NZXTKrakenController.cpp |
| |
| Driver for NZXT Kraken |
| |
| Martin Hartl (inlart) 04 Apr 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include <string>
#include <sstream>
#include "NZXTKrakenController.h"
#include "StringUtils.h"
static void SetColor(const std::vector<RGBColor>& colors, unsigned char* color_data)
{
for(std::size_t idx = 0; idx < colors.size(); idx++)
{
int pixel_idx = (int)idx * 3;
RGBColor color = colors[idx];
color_data[pixel_idx + 0x00] = RGBGetRValue(color);
color_data[pixel_idx + 0x01] = RGBGetGValue(color);
color_data[pixel_idx + 0x02] = RGBGetBValue(color);
}
}
static RGBColor ToLogoColor(RGBColor rgb)
{
return ToRGBColor(RGBGetGValue(rgb), RGBGetRValue(rgb), RGBGetBValue(rgb));
}
NZXTKrakenController::NZXTKrakenController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
/*-----------------------------------------------------*\
| Get the firmware version |
\*-----------------------------------------------------*/
UpdateStatus();
}
NZXTKrakenController::~NZXTKrakenController()
{
hid_close(dev);
}
std::string NZXTKrakenController::GetFirmwareVersion()
{
return firmware_version;
}
std::string NZXTKrakenController::GetLocation()
{
return("HID: " + location);
}
std::string NZXTKrakenController::GetName()
{
return(name);
}
std::string NZXTKrakenController::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 NZXTKrakenController::UpdateStatus()
{
unsigned char usb_buf[64];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Read packet |
\*-----------------------------------------------------*/
hid_read(dev, usb_buf, 64);
/*-----------------------------------------------------*\
| Extract cooler information |
\*-----------------------------------------------------*/
liquid_temperature = usb_buf[0x1] + (usb_buf[0x2] * 0.1);
fan_speed = usb_buf[0x3] << 8 | usb_buf[0x4];
pump_speed = usb_buf[0x5] << 8 | usb_buf[0x6];
/*-----------------------------------------------------*\
| Extract firmware version |
\*-----------------------------------------------------*/
int major = usb_buf[0xb];
int minor = usb_buf[0xc] << 8 | usb_buf[0xd];
int patch = usb_buf[0xe];
std::stringstream ss;
ss << major << '.' << minor << '.' << patch;
firmware_version = ss.str();
}
void NZXTKrakenController::UpdateEffect
(
NZXTKrakenChannel_t channel,
unsigned char mode,
bool direction,
unsigned char speed,
int seq,
std::vector<RGBColor> colors
)
{
unsigned char color_data[9 * 3];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(color_data, 0, sizeof(color_data));
/*-----------------------------------------------------*\
| Fill in color data |
\*-----------------------------------------------------*/
if(!colors.empty() && channel != NZXT_KRAKEN_CHANNEL_RING)
{
colors[0] = ToLogoColor(colors[0]);
}
/*-----------------------------------------------------*\
| Update color data |
\*-----------------------------------------------------*/
SetColor(colors, color_data);
/*-----------------------------------------------------*\
| Send update packet |
\*-----------------------------------------------------*/
SendEffect(channel, mode, direction, color_data, speed, false, seq);
}
void NZXTKrakenController::SendEffect
(
unsigned char channel,
unsigned char mode,
bool direction,
unsigned char* color_data,
unsigned char speed /* = 0x02 */,
bool movement /* = false */,
int cis /* = 0 */,
int size /* = 0 */
)
{
unsigned char usb_buf[64];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set effect mode |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x02;
usb_buf[0x01] = 0x4c;
/*-----------------------------------------------------*\
| Set effect channel, movement and direction |
\*-----------------------------------------------------*/
usb_buf[0x02] = channel;
usb_buf[0x02] |= movement ? ( 1 << 3 ) : 0;
usb_buf[0x02] |= direction ? ( 1 << 4 ) : 0;
/*-----------------------------------------------------*\
| Set mode |
\*-----------------------------------------------------*/
usb_buf[0x03] = mode;
/*-----------------------------------------------------*\
| Set effect speed, size and color in set |
\*-----------------------------------------------------*/
usb_buf[0x04] = speed;
usb_buf[0x04] |= size << 3;
usb_buf[0x04] |= cis << 5;
/*-----------------------------------------------------*\
| Copy color data bytes |
\*-----------------------------------------------------*/
if(color_data)
{
memcpy(usb_buf + 0x05, color_data, 9 * 3);
}
/*-----------------------------------------------------*\
| Send effect |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 64);
}
Controllers/NZXTKrakenController/NZXTKrakenController.h
+96
View File
@@ -0,0 +1,96 @@
/*---------------------------------------------------------*\
| NZXTKrakenController.h |
| |
| Driver for NZXT Kraken |
| |
| Martin Hartl (inlart) 04 Apr 2020 |
| |
| 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 NZXTKrakenChannel_t
{
NZXT_KRAKEN_CHANNEL_SYNC = 0x00, /* Sync Channel */
NZXT_KRAKEN_CHANNEL_LOGO = 0x01, /* Logo Channel */
NZXT_KRAKEN_CHANNEL_RING = 0x02, /* Ring Channel */
};
enum
{
NZXT_KRAKEN_MODE_FIXED = 0x00, /* Fixed colors mode */
NZXT_KRAKEN_MODE_FADING = 0x01, /* Fading mode */
NZXT_KRAKEN_MODE_SPECTRUM = 0x02, /* Spectrum cycle mode */
NZXT_KRAKEN_MODE_MARQUEE = 0x03, /* Marquee mode */
NZXT_KRAKEN_MODE_COVER_MARQUEE = 0x04, /* Cover marquee mode */
NZXT_KRAKEN_MODE_ALTERNATING = 0x05, /* Alternating mode */
NZXT_KRAKEN_MODE_BREATHING = 0x06, /* Breathing mode */
NZXT_KRAKEN_MODE_PULSE = 0x07, /* Pulse mode */
NZXT_KRAKEN_MODE_TAI_CHI = 0x08, /* Tai Chi mode */
NZXT_KRAKEN_MODE_WATER_COOLER = 0x09, /* Water color mode */
NZXT_KRAKEN_MODE_LOADING = 0x0a, /* Loading mode */
NZXT_KRAKEN_MODE_WINGS = 0x0c, /* Wings mode */
};
enum
{
NZXT_KRAKEN_SPEED_SLOWEST = 0x00, /* Slowest speed */
NZXT_KRAKEN_SPEED_SLOW = 0x01, /* Slow speed */
NZXT_KRAKEN_SPEED_NORMAL = 0x02, /* Normal speed */
NZXT_KRAKEN_SPEED_FAST = 0x03, /* Fast speed */
NZXT_KRAKEN_SPEED_FASTEST = 0x04, /* Fastest speed */
};
class NZXTKrakenController
{
public:
NZXTKrakenController(hid_device* dev_handle, const char* path, std::string dev_name);
~NZXTKrakenController();
std::string GetFirmwareVersion();
std::string GetLocation();
std::string GetName();
std::string GetSerialString();
void UpdateEffect
(
NZXTKrakenChannel_t channel,
unsigned char mode,
bool direction,
unsigned char speed,
int seq,
std::vector<RGBColor> colors
);
private:
void UpdateStatus();
void SendEffect
(
unsigned char channel,
unsigned char mode,
bool direction,
unsigned char* color_data,
unsigned char speed = 0x02,
bool movement = false,
int cis = 0 ,
int size = 0
);
hid_device* dev;
// -- status
std::string firmware_version;
double liquid_temperature;
std::string location;
std::string name;
unsigned int fan_speed;
unsigned int pump_speed;
};
Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp
+43
View File
@@ -0,0 +1,43 @@
/*---------------------------------------------------------*\
| NZXTKrakenControllerDetect.cpp |
| |
| Detector for NZXT Kraken |
| |
| Martin Hartl (inlart) 04 Apr 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "Detector.h"
#include "NZXTKrakenController.h"
#include "RGBController_NZXTKraken.h"
#define NZXT_KRAKEN_VID 0x1E71
#define NZXT_KRAKEN_X2_PID 0x170E
#define NZXT_KRAKEN_M2_PID 0x1715
/******************************************************************************************\
* *
* DetectNZXTKrakenControllers *
* *
* Detect devices supported by the NZXTKraken driver *
* *
\******************************************************************************************/
void DetectNZXTKrakenControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
NZXTKrakenController* controller = new NZXTKrakenController(dev, info->path, name);
RGBController_NZXTKraken* rgb_controller = new RGBController_NZXTKraken(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
} /* DetectNZXTKrakenControllers() */
REGISTER_HID_DETECTOR("NZXT Kraken X2", DetectNZXTKrakenControllers, NZXT_KRAKEN_VID, NZXT_KRAKEN_X2_PID);
REGISTER_HID_DETECTOR("NZXT Kraken M2", DetectNZXTKrakenControllers, NZXT_KRAKEN_VID, NZXT_KRAKEN_M2_PID);
Controllers/NZXTKrakenController/RGBController_NZXTKraken.cpp
+362
View File
@@ -0,0 +1,362 @@
/*---------------------------------------------------------*\
| RGBController_NZXTKraken.cpp |
| |
| RGBController for NZXT Kraken |
| |
| Martin Hartl (inlart) 04 Apr 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <iostream>
#include "RGBController_NZXTKraken.h"
/**------------------------------------------------------------------*\
@name NZXT Kraken
@category Cooler
@type USB
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectNZXTKrakenControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_NZXTKraken::RGBController_NZXTKraken(NZXTKrakenController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
vendor = "NZXT";
type = DEVICE_TYPE_COOLER;
description = "NZXT Kraken X42/X52/X62/X72/M22";
version = controller->GetFirmwareVersion();
location = controller->GetLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = NZXT_KRAKEN_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 = NZXT_KRAKEN_MODE_FADING;
Fading.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Fading.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
Fading.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
Fading.colors_min = 2;
Fading.colors_max = 8;
Fading.speed = NZXT_KRAKEN_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 = NZXT_KRAKEN_MODE_SPECTRUM;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
SpectrumCycle.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
SpectrumCycle.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
SpectrumCycle.speed = NZXT_KRAKEN_SPEED_NORMAL;
SpectrumCycle.direction = MODE_DIRECTION_RIGHT;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
mode Marquee;
Marquee.name = "Marquee";
Marquee.value = NZXT_KRAKEN_MODE_MARQUEE;
Marquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Marquee.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
Marquee.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
Marquee.colors_min = 1;
Marquee.colors_max = 1;
Marquee.speed = NZXT_KRAKEN_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 = NZXT_KRAKEN_MODE_COVER_MARQUEE;
CoverMarquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
CoverMarquee.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
CoverMarquee.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
CoverMarquee.colors_min = 1;
CoverMarquee.colors_max = 8;
CoverMarquee.speed = NZXT_KRAKEN_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 = NZXT_KRAKEN_MODE_ALTERNATING;
Alternating.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Alternating.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
Alternating.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
Alternating.colors_min = 2;
Alternating.colors_max = 2;
Alternating.speed = NZXT_KRAKEN_SPEED_NORMAL;
Alternating.direction = MODE_DIRECTION_RIGHT;
Alternating.color_mode = MODE_COLORS_MODE_SPECIFIC;
Alternating.colors.resize(2);
modes.push_back(Alternating);
mode Pulse;
Pulse.name = "Pulse";
Pulse.value = NZXT_KRAKEN_MODE_PULSE;
Pulse.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Pulse.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
Pulse.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
Pulse.colors_min = 1;
Pulse.colors_max = 8;
Pulse.speed = NZXT_KRAKEN_SPEED_NORMAL;
Pulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
Pulse.colors.resize(1);
modes.push_back(Pulse);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = NZXT_KRAKEN_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
Breathing.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
Breathing.colors_min = 1;
Breathing.colors_max = 8;
Breathing.speed = NZXT_KRAKEN_SPEED_NORMAL;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode ThaiChi;
ThaiChi.name = "Thai Chi";
ThaiChi.value = NZXT_KRAKEN_MODE_TAI_CHI;
ThaiChi.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
ThaiChi.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
ThaiChi.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
ThaiChi.speed = NZXT_KRAKEN_SPEED_NORMAL;
ThaiChi.colors_min = 2;
ThaiChi.colors_max = 2;
ThaiChi.color_mode = MODE_COLORS_MODE_SPECIFIC;
ThaiChi.colors.resize(2);
modes.push_back(ThaiChi);
mode WaterCooler;
WaterCooler.name = "Water Cooler";
WaterCooler.value = NZXT_KRAKEN_MODE_WATER_COOLER;
WaterCooler.flags = MODE_FLAG_HAS_SPEED;
WaterCooler.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
WaterCooler.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
WaterCooler.speed = NZXT_KRAKEN_SPEED_NORMAL;
WaterCooler.color_mode = MODE_COLORS_NONE;
modes.push_back(WaterCooler);
mode Loading;
Loading.name = "Loading";
Loading.value = NZXT_KRAKEN_MODE_LOADING;
Loading.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Loading.colors_min = 1;
Loading.colors_max = 1;
Loading.color_mode = MODE_COLORS_MODE_SPECIFIC;
Loading.colors.resize(1);
modes.push_back(Loading);
mode Wings;
Wings.name = "Wings";
Wings.value = NZXT_KRAKEN_MODE_WINGS;
Wings.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Wings.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
Wings.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
Wings.speed = NZXT_KRAKEN_SPEED_NORMAL;
Wings.colors_min = 1;
Wings.colors_max = 1;
Wings.color_mode = MODE_COLORS_MODE_SPECIFIC;
Wings.colors.resize(1);
modes.push_back(Wings);
/*---------------------------------------------------------*\
| Fixed is the default mode |
\*---------------------------------------------------------*/
default_mode = 0;
/*---------------------------------------------------------*\
| Modes supported by the LOGO LED |
\*---------------------------------------------------------*/
logo_modes =
{
NZXT_KRAKEN_MODE_FIXED,
NZXT_KRAKEN_MODE_FADING,
NZXT_KRAKEN_MODE_SPECTRUM,
NZXT_KRAKEN_MODE_BREATHING,
NZXT_KRAKEN_MODE_PULSE
};
SetupZones();
}
RGBController_NZXTKraken::~RGBController_NZXTKraken()
{
delete controller;
}
void RGBController_NZXTKraken::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
zone logo_zone;
logo_zone.name = "Logo";
logo_zone.type = ZONE_TYPE_SINGLE;
logo_zone.leds_min = 1;
logo_zone.leds_max = 1;
logo_zone.leds_count = 1;
logo_zone.matrix_map = NULL;
zones.push_back(logo_zone);
zone ring_zone;
ring_zone.name = "Ring";
ring_zone.type = ZONE_TYPE_LINEAR;
ring_zone.leds_min = 8;
ring_zone.leds_max = 8;
ring_zone.leds_count = 8;
ring_zone.matrix_map = NULL;
zones.push_back(ring_zone);
/*---------------------------------------------------------*\
| Set up LEDs |
\*---------------------------------------------------------*/
led logo_led;
logo_led.name = "Logo LED";
leds.push_back(logo_led);
led ring_led;
for(int i = 1; i < 9; i++)
{
ring_led.name = std::string("Ring LED ") + std::to_string(i);
leds.push_back(ring_led);
}
SetupColors();
}
void RGBController_NZXTKraken::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
std::vector<std::vector<RGBColor>> RGBController_NZXTKraken::GetColors(int zone, const mode& channel_mode)
{
std::vector<std::vector<RGBColor>> result;
int length = zone < 0 ? (int)leds.size() : (int)zones[zone].leds_count;
if(channel_mode.color_mode == MODE_COLORS_NONE)
{
result.push_back(std::vector<RGBColor>());
}
else if(channel_mode.color_mode == MODE_COLORS_PER_LED)
{
if(zone < 0)
{
result.push_back(colors);
}
else
{
std::vector<RGBColor> led_colors;
for(std::size_t idx = 0; idx < zones[zone].leds_count; ++idx)
{
led_colors.push_back(zones[zone].colors[idx]);
}
result.push_back(led_colors);
}
}
else if(channel_mode.color_mode == MODE_COLORS_MODE_SPECIFIC)
{
for(std::size_t idx = 0; idx < channel_mode.colors.size(); ++idx)
{
result.push_back(std::vector<RGBColor>(length, channel_mode.colors[idx]));
}
}
return result;
}
void RGBController_NZXTKraken::UpdateChannel(NZXTKrakenChannel_t channel, int zone, const mode& channel_mode)
{
bool direction = false;
if((channel_mode.flags & MODE_FLAG_HAS_DIRECTION_LR)
&&(channel_mode.direction == MODE_DIRECTION_LEFT ))
{
direction = true;
}
unsigned char speed = NZXT_KRAKEN_SPEED_NORMAL;
if(channel_mode.flags & MODE_FLAG_HAS_SPEED)
{
speed = channel_mode.speed;
}
std::vector<std::vector<RGBColor>> update_colors = GetColors(zone, channel_mode);
for(std::size_t idx = 0; idx < update_colors.size(); ++idx)
{
controller->UpdateEffect(
channel,
channel_mode.value,
direction,
speed,
(int)idx,
update_colors[idx]
);
}
}
void RGBController_NZXTKraken::DeviceUpdateLEDs()
{
if(logo_modes.find(modes[active_mode].value) == logo_modes.end())
{
UpdateChannel(NZXT_KRAKEN_CHANNEL_LOGO, 0, modes[default_mode]);
UpdateChannel(NZXT_KRAKEN_CHANNEL_RING, 1, modes[active_mode]);
}
else
{
UpdateChannel(NZXT_KRAKEN_CHANNEL_SYNC, -1, modes[active_mode]);
}
}
void RGBController_NZXTKraken::UpdateZoneLEDs(int zone)
{
NZXTKrakenChannel_t channel;
mode channel_mode = modes[active_mode];
if(zone == 0)
{
channel = NZXT_KRAKEN_CHANNEL_LOGO;
if(logo_modes.find(modes[active_mode].value) == logo_modes.end())
{
channel_mode = modes[default_mode];
}
}
else
{
channel = NZXT_KRAKEN_CHANNEL_RING;
}
UpdateChannel(channel, zone, channel_mode);
}
void RGBController_NZXTKraken::UpdateSingleLED(int led)
{
int zone = (led > 0) ? 1 : 0;
UpdateZoneLEDs(zone);
}
void RGBController_NZXTKraken::DeviceUpdateMode()
{
DeviceUpdateLEDs();
}
Controllers/NZXTKrakenController/RGBController_NZXTKraken.h
+50
View File
@@ -0,0 +1,50 @@
/*---------------------------------------------------------*\
| RGBController_NZXTKraken.h |
| |
| RGBController for NZXT Kraken |
| |
| Martin Hartl (inlart) 04 Apr 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <set>
#include "RGBController.h"
#include "NZXTKrakenController.h"
class RGBController_NZXTKraken : public RGBController
{
public:
RGBController_NZXTKraken(NZXTKrakenController* controller_ptr);
~RGBController_NZXTKraken();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
std::vector<std::vector<RGBColor>> GetColors
(
int zone,
const mode& channel_mode
);
void UpdateChannel
(
NZXTKrakenChannel_t channel,
int zone,
const mode& channel_mode
);
NZXTKrakenController* controller;
std::set<unsigned int> logo_modes;
int default_mode;
};