mirror of
https://github.com/CalcProgrammer1/OpenRGB.git
synced 2025-12-23 23:37:48 -05:00
363 lines
13 KiB
C++
363 lines
13 KiB
C++
/*---------------------------------------------------------*\
|
|
| 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();
|
|
}
|