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

Store name in NZXTKrakenController to avoid setting it in detector

Browse source
This commit is contained in:
Adam Honse 2025-08-14 11:50:06 -05:00
parent d8c40cab6d
commit 3ab1519e25
4 changed files with 122 additions and 114 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Controllers/NZXTKrakenController/NZXTKrakenController.cpp
View file

@ -32,10 +32,11 @@ static RGBColor ToLogoColor(RGBColor rgb)
return ToRGBColor(RGBGetGValue(rgb), RGBGetRValue(rgb), RGBGetBValue(rgb)); return ToRGBColor(RGBGetGValue(rgb), RGBGetRValue(rgb), RGBGetBValue(rgb));
} }
NZXTKrakenController::NZXTKrakenController(hid_device* dev_handle, const char* path) NZXTKrakenController::NZXTKrakenController(hid_device* dev_handle, const char* path, std::string dev_name)
{ {
dev = dev_handle; dev = dev_handle;
location = path; location = path;
name = dev_name;
/*-----------------------------------------------------*\ /*-----------------------------------------------------*\
| Get the firmware version | | Get the firmware version |
@ -58,6 +59,11 @@ std::string NZXTKrakenController::GetLocation()
return("HID: " + location); return("HID: " + location);
} }
std::string NZXTKrakenController::GetName()
{
return(name);
}
std::string NZXTKrakenController::GetSerialString() std::string NZXTKrakenController::GetSerialString()
{ {
wchar_t serial_string[128]; wchar_t serial_string[128];

4
Controllers/NZXTKrakenController/NZXTKrakenController.h
View file

@ -51,11 +51,12 @@ enum
class NZXTKrakenController class NZXTKrakenController
{ {
public: public:
NZXTKrakenController(hid_device* dev_handle, const char* path); NZXTKrakenController(hid_device* dev_handle, const char* path, std::string dev_name);
~NZXTKrakenController(); ~NZXTKrakenController();
std::string GetFirmwareVersion(); std::string GetFirmwareVersion();
std::string GetLocation(); std::string GetLocation();
std::string GetName();
std::string GetSerialString(); std::string GetSerialString();
void UpdateEffect void UpdateEffect
@ -89,6 +90,7 @@ private:
std::string firmware_version; std::string firmware_version;
double liquid_temperature; double liquid_temperature;
std::string location; std::string location;
std::string name;
unsigned int fan_speed; unsigned int fan_speed;
unsigned int pump_speed; unsigned int pump_speed;
}; };

7
Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp
View file

@ -29,11 +29,12 @@
void DetectNZXTKrakenControllers(hid_device_info* info, const std::string& name) void DetectNZXTKrakenControllers(hid_device_info* info, const std::string& name)
{ {
hid_device* dev = hid_open_path(info->path); hid_device* dev = hid_open_path(info->path);
if( dev )
if(dev)
{ {
NZXTKrakenController* controller = new NZXTKrakenController(dev, info->path); NZXTKrakenController* controller = new NZXTKrakenController(dev, info->path, name);
RGBController_NZXTKraken* rgb_controller = new RGBController_NZXTKraken(controller); RGBController_NZXTKraken* rgb_controller = new RGBController_NZXTKraken(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller); ResourceManager::get()->RegisterRGBController(rgb_controller);
} }
} /* DetectNZXTKrakenControllers() */ } /* DetectNZXTKrakenControllers() */

217
Controllers/NZXTKrakenController/RGBController_NZXTKraken.cpp
View file

@ -25,158 +25,158 @@
RGBController_NZXTKraken::RGBController_NZXTKraken(NZXTKrakenController* controller_ptr) RGBController_NZXTKraken::RGBController_NZXTKraken(NZXTKrakenController* controller_ptr)
{ {
controller = controller_ptr; controller = controller_ptr;
name = "NZXT Kraken X/M"; name = controller->GetName();
vendor = "NZXT"; vendor = "NZXT";
type = DEVICE_TYPE_COOLER; type = DEVICE_TYPE_COOLER;
description = "NZXT Kraken X42/X52/X62/X72/M22"; description = "NZXT Kraken X42/X52/X62/X72/M22";
version = controller->GetFirmwareVersion(); version = controller->GetFirmwareVersion();
location = controller->GetLocation(); location = controller->GetLocation();
serial = controller->GetSerialString(); serial = controller->GetSerialString();
mode Direct; mode Direct;
Direct.name = "Direct"; Direct.name = "Direct";
Direct.value = NZXT_KRAKEN_MODE_FIXED; Direct.value = NZXT_KRAKEN_MODE_FIXED;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED; Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct); modes.push_back(Direct);
mode Fading; mode Fading;
Fading.name = "Fading"; Fading.name = "Fading";
Fading.value = NZXT_KRAKEN_MODE_FADING; Fading.value = NZXT_KRAKEN_MODE_FADING;
Fading.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; Fading.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Fading.speed_min = NZXT_KRAKEN_SPEED_SLOWEST; Fading.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
Fading.speed_max = NZXT_KRAKEN_SPEED_FASTEST; Fading.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
Fading.colors_min = 2; Fading.colors_min = 2;
Fading.colors_max = 8; Fading.colors_max = 8;
Fading.speed = NZXT_KRAKEN_SPEED_NORMAL; Fading.speed = NZXT_KRAKEN_SPEED_NORMAL;
Fading.color_mode = MODE_COLORS_MODE_SPECIFIC; Fading.color_mode = MODE_COLORS_MODE_SPECIFIC;
Fading.colors.resize(2); Fading.colors.resize(2);
modes.push_back(Fading); modes.push_back(Fading);
mode SpectrumCycle; mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle"; SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = NZXT_KRAKEN_MODE_SPECTRUM; SpectrumCycle.value = NZXT_KRAKEN_MODE_SPECTRUM;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR; SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
SpectrumCycle.speed_min = NZXT_KRAKEN_SPEED_SLOWEST; SpectrumCycle.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
SpectrumCycle.speed_max = NZXT_KRAKEN_SPEED_FASTEST; SpectrumCycle.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
SpectrumCycle.speed = NZXT_KRAKEN_SPEED_NORMAL; SpectrumCycle.speed = NZXT_KRAKEN_SPEED_NORMAL;
SpectrumCycle.direction = MODE_DIRECTION_RIGHT; SpectrumCycle.direction = MODE_DIRECTION_RIGHT;
SpectrumCycle.color_mode = MODE_COLORS_NONE; SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle); modes.push_back(SpectrumCycle);
mode Marquee; mode Marquee;
Marquee.name = "Marquee"; Marquee.name = "Marquee";
Marquee.value = NZXT_KRAKEN_MODE_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.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_min = NZXT_KRAKEN_SPEED_SLOWEST;
Marquee.speed_max = NZXT_KRAKEN_SPEED_FASTEST; Marquee.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
Marquee.colors_min = 1; Marquee.colors_min = 1;
Marquee.colors_max = 1; Marquee.colors_max = 1;
Marquee.speed = NZXT_KRAKEN_SPEED_NORMAL; Marquee.speed = NZXT_KRAKEN_SPEED_NORMAL;
Marquee.direction = MODE_DIRECTION_RIGHT; Marquee.direction = MODE_DIRECTION_RIGHT;
Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC; Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
Marquee.colors.resize(1); Marquee.colors.resize(1);
modes.push_back(Marquee); modes.push_back(Marquee);
mode CoverMarquee; mode CoverMarquee;
CoverMarquee.name = "Cover Marquee"; CoverMarquee.name = "Cover Marquee";
CoverMarquee.value = NZXT_KRAKEN_MODE_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.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_min = NZXT_KRAKEN_SPEED_SLOWEST;
CoverMarquee.speed_max = NZXT_KRAKEN_SPEED_FASTEST; CoverMarquee.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
CoverMarquee.colors_min = 1; CoverMarquee.colors_min = 1;
CoverMarquee.colors_max = 8; CoverMarquee.colors_max = 8;
CoverMarquee.speed = NZXT_KRAKEN_SPEED_NORMAL; CoverMarquee.speed = NZXT_KRAKEN_SPEED_NORMAL;
CoverMarquee.direction = MODE_DIRECTION_RIGHT; CoverMarquee.direction = MODE_DIRECTION_RIGHT;
CoverMarquee.color_mode = MODE_COLORS_MODE_SPECIFIC; CoverMarquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
CoverMarquee.colors.resize(2); CoverMarquee.colors.resize(2);
modes.push_back(CoverMarquee); modes.push_back(CoverMarquee);
mode Alternating; mode Alternating;
Alternating.name = "Alternating"; Alternating.name = "Alternating";
Alternating.value = NZXT_KRAKEN_MODE_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.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_min = NZXT_KRAKEN_SPEED_SLOWEST;
Alternating.speed_max = NZXT_KRAKEN_SPEED_FASTEST; Alternating.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
Alternating.colors_min = 2; Alternating.colors_min = 2;
Alternating.colors_max = 2; Alternating.colors_max = 2;
Alternating.speed = NZXT_KRAKEN_SPEED_NORMAL; Alternating.speed = NZXT_KRAKEN_SPEED_NORMAL;
Alternating.direction = MODE_DIRECTION_RIGHT; Alternating.direction = MODE_DIRECTION_RIGHT;
Alternating.color_mode = MODE_COLORS_MODE_SPECIFIC; Alternating.color_mode = MODE_COLORS_MODE_SPECIFIC;
Alternating.colors.resize(2); Alternating.colors.resize(2);
modes.push_back(Alternating); modes.push_back(Alternating);
mode Pulse; mode Pulse;
Pulse.name = "Pulse"; Pulse.name = "Pulse";
Pulse.value = NZXT_KRAKEN_MODE_PULSE; Pulse.value = NZXT_KRAKEN_MODE_PULSE;
Pulse.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; Pulse.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Pulse.speed_min = NZXT_KRAKEN_SPEED_SLOWEST; Pulse.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
Pulse.speed_max = NZXT_KRAKEN_SPEED_FASTEST; Pulse.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
Pulse.colors_min = 1; Pulse.colors_min = 1;
Pulse.colors_max = 8; Pulse.colors_max = 8;
Pulse.speed = NZXT_KRAKEN_SPEED_NORMAL; Pulse.speed = NZXT_KRAKEN_SPEED_NORMAL;
Pulse.color_mode = MODE_COLORS_MODE_SPECIFIC; Pulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
Pulse.colors.resize(1); Pulse.colors.resize(1);
modes.push_back(Pulse); modes.push_back(Pulse);
mode Breathing; mode Breathing;
Breathing.name = "Breathing"; Breathing.name = "Breathing";
Breathing.value = NZXT_KRAKEN_MODE_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.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_min = NZXT_KRAKEN_SPEED_SLOWEST;
Breathing.speed_max = NZXT_KRAKEN_SPEED_FASTEST; Breathing.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
Breathing.colors_min = 1; Breathing.colors_min = 1;
Breathing.colors_max = 8; Breathing.colors_max = 8;
Breathing.speed = NZXT_KRAKEN_SPEED_NORMAL; Breathing.speed = NZXT_KRAKEN_SPEED_NORMAL;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize(1); Breathing.colors.resize(1);
modes.push_back(Breathing); modes.push_back(Breathing);
mode ThaiChi; mode ThaiChi;
ThaiChi.name = "Thai Chi"; ThaiChi.name = "Thai Chi";
ThaiChi.value = NZXT_KRAKEN_MODE_TAI_CHI; ThaiChi.value = NZXT_KRAKEN_MODE_TAI_CHI;
ThaiChi.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; ThaiChi.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
ThaiChi.speed_min = NZXT_KRAKEN_SPEED_SLOWEST; ThaiChi.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
ThaiChi.speed_max = NZXT_KRAKEN_SPEED_FASTEST; ThaiChi.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
ThaiChi.speed = NZXT_KRAKEN_SPEED_NORMAL; ThaiChi.speed = NZXT_KRAKEN_SPEED_NORMAL;
ThaiChi.colors_min = 2; ThaiChi.colors_min = 2;
ThaiChi.colors_max = 2; ThaiChi.colors_max = 2;
ThaiChi.color_mode = MODE_COLORS_MODE_SPECIFIC; ThaiChi.color_mode = MODE_COLORS_MODE_SPECIFIC;
ThaiChi.colors.resize(2); ThaiChi.colors.resize(2);
modes.push_back(ThaiChi); modes.push_back(ThaiChi);
mode WaterCooler; mode WaterCooler;
WaterCooler.name = "Water Cooler"; WaterCooler.name = "Water Cooler";
WaterCooler.value = NZXT_KRAKEN_MODE_WATER_COOLER; WaterCooler.value = NZXT_KRAKEN_MODE_WATER_COOLER;
WaterCooler.flags = MODE_FLAG_HAS_SPEED; WaterCooler.flags = MODE_FLAG_HAS_SPEED;
WaterCooler.speed_min = NZXT_KRAKEN_SPEED_SLOWEST; WaterCooler.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
WaterCooler.speed_max = NZXT_KRAKEN_SPEED_FASTEST; WaterCooler.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
WaterCooler.speed = NZXT_KRAKEN_SPEED_NORMAL; WaterCooler.speed = NZXT_KRAKEN_SPEED_NORMAL;
WaterCooler.color_mode = MODE_COLORS_NONE; WaterCooler.color_mode = MODE_COLORS_NONE;
modes.push_back(WaterCooler); modes.push_back(WaterCooler);
mode Loading; mode Loading;
Loading.name = "Loading"; Loading.name = "Loading";
Loading.value = NZXT_KRAKEN_MODE_LOADING; Loading.value = NZXT_KRAKEN_MODE_LOADING;
Loading.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; Loading.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Loading.colors_min = 1; Loading.colors_min = 1;
Loading.colors_max = 1; Loading.colors_max = 1;
Loading.color_mode = MODE_COLORS_MODE_SPECIFIC; Loading.color_mode = MODE_COLORS_MODE_SPECIFIC;
Loading.colors.resize(1); Loading.colors.resize(1);
modes.push_back(Loading); modes.push_back(Loading);
mode Wings; mode Wings;
Wings.name = "Wings"; Wings.name = "Wings";
Wings.value = NZXT_KRAKEN_MODE_WINGS; Wings.value = NZXT_KRAKEN_MODE_WINGS;
Wings.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; Wings.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Wings.speed_min = NZXT_KRAKEN_SPEED_SLOWEST; Wings.speed_min = NZXT_KRAKEN_SPEED_SLOWEST;
Wings.speed_max = NZXT_KRAKEN_SPEED_FASTEST; Wings.speed_max = NZXT_KRAKEN_SPEED_FASTEST;
Wings.speed = NZXT_KRAKEN_SPEED_NORMAL; Wings.speed = NZXT_KRAKEN_SPEED_NORMAL;
Wings.colors_min = 1; Wings.colors_min = 1;
Wings.colors_max = 1; Wings.colors_max = 1;
Wings.color_mode = MODE_COLORS_MODE_SPECIFIC; Wings.color_mode = MODE_COLORS_MODE_SPECIFIC;
Wings.colors.resize(1); Wings.colors.resize(1);
modes.push_back(Wings); modes.push_back(Wings);
@ -197,7 +197,6 @@ RGBController_NZXTKraken::RGBController_NZXTKraken(NZXTKrakenController* control
NZXT_KRAKEN_MODE_PULSE NZXT_KRAKEN_MODE_PULSE
}; };
SetupZones(); SetupZones();
} }