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

Add NZXT Kraken driver

Browse source 
Driver should work for NZXT Kraken X42/X52/X62/X72. Most of the color
modes and settings are already working. However, there are currently
some limitations in settings different ring and logo modes.
This commit is contained in:
Martin Hartl 2020-04-07 20:14:31 +02:00 • committed by Adam Honse
parent 6fd6c7f176
commit facfa05062
7 changed files with 672 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

166
Controllers/NZXTKrakenController/NZXTKrakenController.cpp Normal file
View file

@ -0,0 +1,166 @@
/*---------------------------------------------------------*\
| Driver for NZXT Kraken |
| |
| Martin Hartl (inlart), 04/04/2020 |
\*---------------------------------------------------------*/
#include "NZXTKrakenController.h"
#include <string>
#include <sstream>
#include <cstring>
const int NZXT_KRAKEN_READ_ENDPOINT = 0x81;
const int NZXT_KRAKEN_WRITE_ENDPOINT = 0x01;
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 = 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(libusb_device_handle* dev_handle)
{
dev = dev_handle;
/*-----------------------------------------------------*\
| Get the firmware version |
\*-----------------------------------------------------*/
UpdateStatus();
}
NZXTKrakenController::~NZXTKrakenController()
{
}
std::string NZXTKrakenController::GetFirmwareVersion()
{
return firmware_version;
}
void NZXTKrakenController::UpdateStatus()
{
int actual;
unsigned char usb_buf[64];
memset(usb_buf, 0, sizeof(usb_buf));
libusb_interrupt_transfer(dev, NZXT_KRAKEN_READ_ENDPOINT, usb_buf, sizeof(usb_buf), &actual, 0);
/*-----------------------------------------------------*\
| 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];
memset(color_data, 0, sizeof(color_data));
if(!colors.empty() && channel != NZXT_KRAKEN_CHANNEL_RING)
{
colors[0] = ToLogoColor(colors[0]);
}
SetColor(colors, color_data);
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 */
)
{
int actual;
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| 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 |
\*-----------------------------------------------------*/
libusb_interrupt_transfer
(
dev,
NZXT_KRAKEN_WRITE_ENDPOINT,
usb_buf,
sizeof(usb_buf),
&actual,
0
);
}

86
Controllers/NZXTKrakenController/NZXTKrakenController.h Normal file
View file

@ -0,0 +1,86 @@
/*---------------------------------------------------------*\
| Definitions for NZXT Kraken |
| |
| Martin Hartl (inlart), 04/04/2020 |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include <vector>
#include <string>
#include <libusb-1.0/libusb.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(libusb_device_handle* dev_handle);
~NZXTKrakenController();
std::string GetFirmwareVersion();
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
);
libusb_device_handle* dev;
// -- status
std::string firmware_version;
double liquid_temperature;
unsigned int fan_speed;
unsigned int pump_speed;
};

37
Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp Normal file
View file

@ -0,0 +1,37 @@
#include "NZXTKrakenController.h"
#include "RGBController.h"
#include "RGBController_NZXTKraken.h"
#include <vector>
#include <libusb-1.0/libusb.h>
#define NZXT_KRAKEN_VID 0x1E71
#define NZXT_KRAKEN_PID 0x170E
/******************************************************************************************\
* *
* DetectNZXTKrakenControllers *
* *
* Detect devices supported by the NZXTKraken driver *
* * *
\******************************************************************************************/
void DetectNZXTKrakenControllers(std::vector<RGBController*> &rgb_controllers)
{
libusb_context * ctx;
libusb_init(&ctx);
libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, NZXT_KRAKEN_VID, NZXT_KRAKEN_PID);
if( dev )
{
libusb_detach_kernel_driver(dev, 0);
libusb_claim_interface(dev, 0);
NZXTKrakenController* controller = new NZXTKrakenController(dev);
RGBController_NZXTKraken* rgb_controller = new RGBController_NZXTKraken(controller);
rgb_controllers.push_back(rgb_controller);
}
}

2
OpenRGB.cpp
View file

@ -310,6 +310,7 @@ void DetectHyperXKeyboardControllers(std::vector<RGBController*>& rgb_controller
void DetectThermaltakeRiingControllers(std::vector<RGBController*>& rgb_controllers);
void DetectRGBFusion2USBControllers(std::vector<RGBController*> &rgb_controllers);
void DetectRedragonControllers(std::vector<RGBController*>& rgb_controllers);
void DetectNZXTKrakenControllers(std::vector<RGBController*>& rgb_controllers);
/******************************************************************************************\
* *
@ -350,6 +351,7 @@ void DetectRGBControllers(void)
DetectThermaltakeRiingControllers(rgb_controllers);
DetectRGBFusion2USBControllers(rgb_controllers);
DetectRedragonControllers(rgb_controllers);
DetectNZXTKrakenControllers(rgb_controllers);
DetectE131Controllers(rgb_controllers);

4
OpenRGB.pro
View file

@ -46,6 +46,7 @@ INCLUDEPATH += \
Controllers/LEDStripController/ \
Controllers/MSI3ZoneController/ \
Controllers/MSIRGBController/ \
Controllers/NZXTKrakenController/ \
Controllers/PatriotViperController/ \
Controllers/PolychromeController/ \
Controllers/PoseidonZRGBController/ \
@ -111,6 +112,8 @@ SOURCES += \
Controllers/MSI3ZoneController/MSI3ZoneControllerDetect.cpp \
Controllers/MSIRGBController/MSIRGBController.cpp \
Controllers/MSIRGBController/MSIRGBControllerDetect.cpp \
Controllers/NZXTKrakenController/NZXTKrakenController.cpp \
Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp \
Controllers/PatriotViperController/PatriotViperController.cpp \
Controllers/PatriotViperController/PatriotViperControllerDetect.cpp \
Controllers/PolychromeController/PolychromeController.cpp \
@ -148,6 +151,7 @@ SOURCES += \
RGBController/RGBController_LEDStrip.cpp \
RGBController/RGBController_MSI3Zone.cpp \
RGBController/RGBController_MSIRGB.cpp \
RGBController/RGBController_NZXTKraken.cpp \
RGBController/RGBController_PatriotViper.cpp \
RGBController/RGBController_Polychrome.cpp \
RGBController/RGBController_PoseidonZRGB.cpp \

341
RGBController/RGBController_NZXTKraken.cpp Normal file
View file

@ -0,0 +1,341 @@
/*-----------------------------------------*\
| RGBController_NZXTKraken.cpp |
| |
| Generic RGB Interface for NZXT Kraken |
| |
| Martin Hartl (inlart) 04/04/2020 |
\*-----------------------------------------*/
#include "RGBController_NZXTKraken.h"
#include <iostream>
RGBController_NZXTKraken::RGBController_NZXTKraken(NZXTKrakenController* nzxtkraken_ptr)
{
nzxtkraken = nzxtkraken_ptr;
name = "NZXT Kraken X";
type = DEVICE_TYPE_COOLER;
description = "NZXT Kraken X42/X52/X62/X72";
version = nzxtkraken->GetFirmwareVersion();
mode Fixed;
Fixed.name = "Fixed";
Fixed.value = NZXT_KRAKEN_MODE_FIXED;
Fixed.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Fixed.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Fixed);
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.colors_min = 1;
WaterCooler.colors_max = 1;
WaterCooler.color_mode = MODE_COLORS_NONE;
WaterCooler.colors.resize(1);
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);
/*---------------------------------------------------------*\
| 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();
}
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;
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;
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)
{
std::vector<std::vector<RGBColor>> result;
int length = zone < 0 ? leds.size() : zones[zone].leds_count;
if(modes[active_mode].color_mode == MODE_COLORS_NONE)
{
result.push_back(std::vector<RGBColor>());
}
else if(modes[active_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(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
{
for(std::size_t idx = 0; idx < modes[active_mode].colors.size(); ++idx)
{
result.push_back(std::vector<RGBColor>(length, modes[active_mode].colors[idx]));
}
}
return result;
}
void RGBController_NZXTKraken::UpdateLEDs()
{
UpdateZoneLEDs(-1);
}
void RGBController_NZXTKraken::UpdateZoneLEDs(int zone)
{
NZXTKrakenChannel_t channel;
bool direction = false;
/*---------------------------------------------------------*\
| If the logo doesn't support the mode, only update the ring|
\*---------------------------------------------------------*/
if(logo_modes.find(modes[active_mode].value) == logo_modes.end())
{
if(zone == 0)
{
return;
}
zone = 1;
}
if(zone < 0)
{
channel = NZXT_KRAKEN_CHANNEL_SYNC;
}
else if(zone == 0)
{
channel = NZXT_KRAKEN_CHANNEL_LOGO;
}
else
{
channel = NZXT_KRAKEN_CHANNEL_RING;
}
if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR)
&& modes[active_mode].direction == MODE_DIRECTION_LEFT)
{
direction = true;
}
unsigned char speed = NZXT_KRAKEN_SPEED_NORMAL;
if(modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
{
speed = modes[active_mode].speed;
}
auto update_colors = GetColors(zone);
for(std::size_t idx = 0; idx < update_colors.size(); ++idx)
{
nzxtkraken->UpdateEffect(
channel,
modes[active_mode].value,
direction,
speed,
idx,
update_colors[idx]
);
}
}
void RGBController_NZXTKraken::UpdateSingleLED(int led)
{
int zone = (led > 0) ? 1 : 0;
UpdateZoneLEDs(zone);
}
void RGBController_NZXTKraken::SetCustomMode()
{
active_mode = 0;
}
void RGBController_NZXTKraken::UpdateMode()
{
UpdateLEDs();
}

36
RGBController/RGBController_NZXTKraken.h Normal file
View file

@ -0,0 +1,36 @@
/*-----------------------------------------*\
| RGBController_NZXTKraken.h |
| |
| Generic RGB Interface for NZXT Kraken |
| |
| Martin Hartl (inlart) 04/04/2020 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "NZXTKrakenController.h"
#include <set>
class RGBController_NZXTKraken : public RGBController
{
public:
RGBController_NZXTKraken(NZXTKrakenController* nzxtkraken_ptr);
void SetupZones();
void ResizeZone(int zone, int new_size);
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
std::vector<std::vector<RGBColor>> GetColors(int zone);
NZXTKrakenController* nzxtkraken;
std::set<unsigned int> logo_modes;
};