From facfa05062b33cf5c9e8a0cdb56ee31d3a4c984f Mon Sep 17 00:00:00 2001 From: Martin Hartl Date: Tue, 7 Apr 2020 20:14:31 +0200 Subject: [PATCH] Add NZXT Kraken driver 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. --- .../NZXTKrakenController.cpp | 166 +++++++++ .../NZXTKrakenController.h | 86 +++++ .../NZXTKrakenControllerDetect.cpp | 37 ++ OpenRGB.cpp | 2 + OpenRGB.pro | 4 + RGBController/RGBController_NZXTKraken.cpp | 341 ++++++++++++++++++ RGBController/RGBController_NZXTKraken.h | 36 ++ 7 files changed, 672 insertions(+) create mode 100644 Controllers/NZXTKrakenController/NZXTKrakenController.cpp create mode 100644 Controllers/NZXTKrakenController/NZXTKrakenController.h create mode 100644 Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp create mode 100644 RGBController/RGBController_NZXTKraken.cpp create mode 100644 RGBController/RGBController_NZXTKraken.h diff --git a/Controllers/NZXTKrakenController/NZXTKrakenController.cpp b/Controllers/NZXTKrakenController/NZXTKrakenController.cpp new file mode 100644 index 00000000..b86dfde2 --- /dev/null +++ b/Controllers/NZXTKrakenController/NZXTKrakenController.cpp @@ -0,0 +1,166 @@ +/*---------------------------------------------------------*\ +| Driver for NZXT Kraken | +| | +| Martin Hartl (inlart), 04/04/2020 | +\*---------------------------------------------------------*/ + +#include "NZXTKrakenController.h" + +#include +#include +#include + +const int NZXT_KRAKEN_READ_ENDPOINT = 0x81; +const int NZXT_KRAKEN_WRITE_ENDPOINT = 0x01; + +static void SetColor(const std::vector& 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 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 + ); +} diff --git a/Controllers/NZXTKrakenController/NZXTKrakenController.h b/Controllers/NZXTKrakenController/NZXTKrakenController.h new file mode 100644 index 00000000..f7d6e42f --- /dev/null +++ b/Controllers/NZXTKrakenController/NZXTKrakenController.h @@ -0,0 +1,86 @@ +/*---------------------------------------------------------*\ +| Definitions for NZXT Kraken | +| | +| Martin Hartl (inlart), 04/04/2020 | +\*---------------------------------------------------------*/ + +#pragma once + +#include "RGBController.h" +#include +#include +#include + +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 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; +}; diff --git a/Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp b/Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp new file mode 100644 index 00000000..febcba0d --- /dev/null +++ b/Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp @@ -0,0 +1,37 @@ +#include "NZXTKrakenController.h" +#include "RGBController.h" +#include "RGBController_NZXTKraken.h" +#include +#include + +#define NZXT_KRAKEN_VID 0x1E71 +#define NZXT_KRAKEN_PID 0x170E + +/******************************************************************************************\ +* * +* DetectNZXTKrakenControllers * +* * +* Detect devices supported by the NZXTKraken driver * +* * * +\******************************************************************************************/ + +void DetectNZXTKrakenControllers(std::vector &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); + } + +} diff --git a/OpenRGB.cpp b/OpenRGB.cpp index 1231d588..9bdd9c54 100644 --- a/OpenRGB.cpp +++ b/OpenRGB.cpp @@ -310,6 +310,7 @@ void DetectHyperXKeyboardControllers(std::vector& rgb_controller void DetectThermaltakeRiingControllers(std::vector& rgb_controllers); void DetectRGBFusion2USBControllers(std::vector &rgb_controllers); void DetectRedragonControllers(std::vector& rgb_controllers); +void DetectNZXTKrakenControllers(std::vector& rgb_controllers); /******************************************************************************************\ * * @@ -350,6 +351,7 @@ void DetectRGBControllers(void) DetectThermaltakeRiingControllers(rgb_controllers); DetectRGBFusion2USBControllers(rgb_controllers); DetectRedragonControllers(rgb_controllers); + DetectNZXTKrakenControllers(rgb_controllers); DetectE131Controllers(rgb_controllers); diff --git a/OpenRGB.pro b/OpenRGB.pro index bbc7aec2..d53fa2e7 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -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 \ diff --git a/RGBController/RGBController_NZXTKraken.cpp b/RGBController/RGBController_NZXTKraken.cpp new file mode 100644 index 00000000..410d167e --- /dev/null +++ b/RGBController/RGBController_NZXTKraken.cpp @@ -0,0 +1,341 @@ +/*-----------------------------------------*\ +| RGBController_NZXTKraken.cpp | +| | +| Generic RGB Interface for NZXT Kraken | +| | +| Martin Hartl (inlart) 04/04/2020 | +\*-----------------------------------------*/ + +#include "RGBController_NZXTKraken.h" + +#include + +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> RGBController_NZXTKraken::GetColors(int zone) +{ + std::vector> 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()); + } + else if(modes[active_mode].color_mode == MODE_COLORS_PER_LED) + { + if(zone < 0) + { + result.push_back(colors); + } + else + { + std::vector 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(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(); +} diff --git a/RGBController/RGBController_NZXTKraken.h b/RGBController/RGBController_NZXTKraken.h new file mode 100644 index 00000000..129e6ff4 --- /dev/null +++ b/RGBController/RGBController_NZXTKraken.h @@ -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 + +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> GetColors(int zone); + + NZXTKrakenController* nzxtkraken; + std::set logo_modes; +};