Jens/LumaOps-Public
1
0 Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Publish curated LumaOps source from c85ee9ef8f1454f5c305398902afbb9e6738de40
Managed validation / full (push) Failing after 8s

Browse Source
This commit is contained in:
Public Source Publisher committed 2026-09-30 00:26:45 +00:00
1 parent 91f8b3e3c1
commit def7920856
2271 files changed
+501225 -501178
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Controllers/NZXTHue2Controller/NZXTHue2Controller.cpp
+634 -634
View File
File diff suppressed because it is too large. Load diff
Controllers/NZXTHue2Controller/NZXTHue2Controller.h
+170 -170
View File
@@ -1,170 +1,170 @@
/*---------------------------------------------------------*\
| NZXTHue2Controller.h |
| |
| Driver for NZXT Hue 2 |
| |
| Adam Honse (calcprogrammer1@gmail.com) 29 Dec 2019 |
| |
| 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
{
HUE_2_CHANNEL_ALL = 0x00, /* All channels */
HUE_2_CHANNEL_1 = 0x01, /* Channel 1 */
HUE_2_CHANNEL_2 = 0x02, /* Channel 2 */
HUE_2_CHANNEL_3 = 0x03, /* Channel 3 */
HUE_2_CHANNEL_4 = 0x04, /* Channel 4 */
HUE_2_CHANNEL_5 = 0x05, /* Channel 5 */
HUE_2_CHANNEL_6 = 0x06, /* Channel 6 */
HUE_2_NUM_CHANNELS = 0x06 /* Number of channels */
};
enum
{
HUE_2_CHANNEL_1_IDX = 0x00, /* Channel 1 array index */
HUE_2_CHANNEL_2_IDX = 0x01, /* Channel 2 array index */
HUE_2_CHANNEL_3_IDX = 0x01, /* Channel 3 array index */
HUE_2_CHANNEL_4_IDX = 0x01, /* Channel 4 array index */
};
enum
{
HUE_2_SPEED_SLOWEST = 0x00, /* Slowest speed */
HUE_2_SPEED_SLOW = 0x01, /* Slow speed */
HUE_2_SPEED_NORMAL = 0x02, /* Normal speed */
HUE_2_SPEED_FAST = 0x03, /* Fast speed */
HUE_2_SPEED_FASTEST = 0x04, /* Fastest speed */
};
enum
{
HUE_2_MODE_FIXED = 0x00, /* Fixed colors mode */
HUE_2_MODE_FADING = 0x01, /* Fading mode */
HUE_2_MODE_SPECTRUM = 0x02, /* Spectrum cycle mode */
HUE_2_MODE_MARQUEE = 0x03, /* Marquee mode */
HUE_2_MODE_COVER_MARQUEE = 0x04, /* Cover marquee mode */
HUE_2_MODE_ALTERNATING = 0x05, /* Alternating mode */
HUE_2_MODE_PULSING = 0x06, /* Pulsing mode */
HUE_2_MODE_BREATHING = 0x07, /* Breathing mode */
HUE_2_MODE_CANDLE = 0x08, /* Candle Mode */
HUE_2_MODE_STARRY_NIGHT = 0x09, /* Starry Night mode */
HUE_2_MODE_RAINBOW_FLOW = 0x0b, /* Rainbow Flow mode */
HUE_2_MODE_SUPER_RAINBOW = 0x0c, /* Super Rainbow mode */
HUE_2_MODE_RAINBOW_PULSE = 0x0d, /* Rainbow Pulse mode */
HUE_2_NUM_MODES /* Number of Hue 2 modes */
};
class NZXTHue2Controller
{
public:
NZXTHue2Controller(hid_device* dev_handle, unsigned int rgb_channels, unsigned int fan_channels, const char* path, std::string dev_name, bool use_2023_effects = false);
~NZXTHue2Controller();
std::string GetFirmwareVersion();
std::string GetLocation();
std::string GetName();
std::string GetSerialString();
unsigned char GetFanCommand
(
unsigned char fan_channel
);
unsigned short GetFanRPM
(
unsigned char fan_channel
);
unsigned int GetNumFanChannels();
unsigned int GetNumRGBChannels();
void SendFan
(
unsigned char port,
unsigned char mode,
unsigned char speed
);
void SetChannelEffect
(
unsigned char channel,
unsigned char mode,
unsigned char speed,
bool direction,
RGBColor * colors,
unsigned int num_colors
);
void SetChannelLEDs
(
unsigned char channel,
RGBColor * colors,
unsigned int num_colors
);
void UpdateDeviceList();
void UpdateStatus();
unsigned int channel_leds[HUE_2_NUM_CHANNELS];
unsigned int channel_dev_ids[HUE_2_NUM_CHANNELS][6];
unsigned int channel_dev_szs[HUE_2_NUM_CHANNELS][6];
private:
hid_device* dev;
std::vector<unsigned char> fan_cmd;
std::vector<unsigned short> fan_rpm;
char firmware_version[16];
std::string location;
std::string name;
bool use_2023_effects;
unsigned int num_fan_channels;
unsigned int num_rgb_channels;
void SendApply
(
unsigned char channel
);
void SendDirect
(
unsigned char channel,
unsigned char group,
unsigned char color_count,
unsigned char* color_data
);
void SendEffect
(
unsigned char channel,
unsigned char mode,
unsigned char speed,
bool direction,
unsigned char color_count,
unsigned char* color_data
);
void SendEffect2023
(
unsigned char channel,
unsigned char mode,
unsigned char speed,
bool direction,
unsigned char color_count,
unsigned char* color_data
);
void SendFirmwareRequest();
};
/*---------------------------------------------------------*\
| NZXTHue2Controller.h |
| |
| Driver for NZXT Hue 2 |
| |
| Adam Honse (calcprogrammer1@gmail.com) 29 Dec 2019 |
| |
| 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
{
HUE_2_CHANNEL_ALL = 0x00, /* All channels */
HUE_2_CHANNEL_1 = 0x01, /* Channel 1 */
HUE_2_CHANNEL_2 = 0x02, /* Channel 2 */
HUE_2_CHANNEL_3 = 0x03, /* Channel 3 */
HUE_2_CHANNEL_4 = 0x04, /* Channel 4 */
HUE_2_CHANNEL_5 = 0x05, /* Channel 5 */
HUE_2_CHANNEL_6 = 0x06, /* Channel 6 */
HUE_2_NUM_CHANNELS = 0x06 /* Number of channels */
};
enum
{
HUE_2_CHANNEL_1_IDX = 0x00, /* Channel 1 array index */
HUE_2_CHANNEL_2_IDX = 0x01, /* Channel 2 array index */
HUE_2_CHANNEL_3_IDX = 0x01, /* Channel 3 array index */
HUE_2_CHANNEL_4_IDX = 0x01, /* Channel 4 array index */
};
enum
{
HUE_2_SPEED_SLOWEST = 0x00, /* Slowest speed */
HUE_2_SPEED_SLOW = 0x01, /* Slow speed */
HUE_2_SPEED_NORMAL = 0x02, /* Normal speed */
HUE_2_SPEED_FAST = 0x03, /* Fast speed */
HUE_2_SPEED_FASTEST = 0x04, /* Fastest speed */
};
enum
{
HUE_2_MODE_FIXED = 0x00, /* Fixed colors mode */
HUE_2_MODE_FADING = 0x01, /* Fading mode */
HUE_2_MODE_SPECTRUM = 0x02, /* Spectrum cycle mode */
HUE_2_MODE_MARQUEE = 0x03, /* Marquee mode */
HUE_2_MODE_COVER_MARQUEE = 0x04, /* Cover marquee mode */
HUE_2_MODE_ALTERNATING = 0x05, /* Alternating mode */
HUE_2_MODE_PULSING = 0x06, /* Pulsing mode */
HUE_2_MODE_BREATHING = 0x07, /* Breathing mode */
HUE_2_MODE_CANDLE = 0x08, /* Candle Mode */
HUE_2_MODE_STARRY_NIGHT = 0x09, /* Starry Night mode */
HUE_2_MODE_RAINBOW_FLOW = 0x0b, /* Rainbow Flow mode */
HUE_2_MODE_SUPER_RAINBOW = 0x0c, /* Super Rainbow mode */
HUE_2_MODE_RAINBOW_PULSE = 0x0d, /* Rainbow Pulse mode */
HUE_2_NUM_MODES /* Number of Hue 2 modes */
};
class NZXTHue2Controller
{
public:
NZXTHue2Controller(hid_device* dev_handle, unsigned int rgb_channels, unsigned int fan_channels, const char* path, std::string dev_name, bool use_2023_effects = false);
~NZXTHue2Controller();
std::string GetFirmwareVersion();
std::string GetLocation();
std::string GetName();
std::string GetSerialString();
unsigned char GetFanCommand
(
unsigned char fan_channel
);
unsigned short GetFanRPM
(
unsigned char fan_channel
);
unsigned int GetNumFanChannels();
unsigned int GetNumRGBChannels();
void SendFan
(
unsigned char port,
unsigned char mode,
unsigned char speed
);
void SetChannelEffect
(
unsigned char channel,
unsigned char mode,
unsigned char speed,
bool direction,
RGBColor * colors,
unsigned int num_colors
);
void SetChannelLEDs
(
unsigned char channel,
RGBColor * colors,
unsigned int num_colors
);
void UpdateDeviceList();
void UpdateStatus();
unsigned int channel_leds[HUE_2_NUM_CHANNELS];
unsigned int channel_dev_ids[HUE_2_NUM_CHANNELS][6];
unsigned int channel_dev_szs[HUE_2_NUM_CHANNELS][6];
private:
hid_device* dev;
std::vector<unsigned char> fan_cmd;
std::vector<unsigned short> fan_rpm;
char firmware_version[16];
std::string location;
std::string name;
bool use_2023_effects;
unsigned int num_fan_channels;
unsigned int num_rgb_channels;
void SendApply
(
unsigned char channel
);
void SendDirect
(
unsigned char channel,
unsigned char group,
unsigned char color_count,
unsigned char* color_data
);
void SendEffect
(
unsigned char channel,
unsigned char mode,
unsigned char speed,
bool direction,
unsigned char color_count,
unsigned char* color_data
);
void SendEffect2023
(
unsigned char channel,
unsigned char mode,
unsigned char speed,
bool direction,
unsigned char color_count,
unsigned char* color_data
);
void SendFirmwareRequest();
};
Controllers/NZXTHue2Controller/NZXTHue2ControllerDetect.cpp
+124 -124
View File
@@ -1,124 +1,124 @@
/*---------------------------------------------------------*\
| NZXTHue2ControllerDetect.cpp |
| |
| Detector for NZXT Hue 2 |
| |
| Adam Honse (calcprogrammer1@gmail.com) 29 Dec 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "Detector.h"
#include "LogManager.h"
#include "NZXTHue2Controller.h"
#include "RGBController_NZXTHue2.h"
#define NZXT_VID 0x1E71
#define NZXT_HUE_2_PID 0x2001
#define NZXT_HUE_2_AMBIENT_PID 0x2002
#define NZXT_MOTHERBOARD_DEVICE_PID 0x2005
#define NZXT_MOTHERBOARD_DEVICE_2_PID 0x200B
#define NZXT_SMART_DEVICE_V2_PID 0x2006
#define NZXT_KRAKEN_X3_SERIES_PID 0x2007
#define NZXT_KRAKEN_X3_SERIES_RGB_PID 0x2014
#define NZXT_KRAKEN_2024_ELITE_SERIES_RGB_PID 0x3012
#define NZXT_RGB_FAN_CONTROLLER_PID 0x2009
#define NZXT_RGB_FAN_CONTROLLER2_PID 0x2010
#define NZXT_RGB_FAN_CONTROLLER3_PID 0x200E
#define NZXT_RGB_FAN_CONTROLLER4_PID 0x2011
#define NZXT_RGB_FAN_CONTROLLER5_PID 0x2019
#define NZXT_RGB_FAN_CONTROLLER6_PID 0x2020
#define NZXT_RGB_FAN_CONTROLLER7_PID 0x201F
#define NZXT_RGB_FAN_CONTROLLER8_PID 0x2022
#define NZXT_RGB_FAN_CONTROLLER9_PID 0x201B
#define NZXT_RGB_CONTROLLER_1_PID 0x2012
#define NZXT_RGB_CONTROLLER_2_PID 0x2021
#define NZXT_SMART_DEVICE_V2_1_PID 0x200D
#define NZXT_SMART_DEVICE_V2_2_PID 0x200F
static void spawn_hue(hid_device_info* info, const std::string& name, int rgb_channels, int fan_channels, bool use_2023_effects = false)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
NZXTHue2Controller* controller = new NZXTHue2Controller(dev, rgb_channels, fan_channels, info->path, name, use_2023_effects);
RGBController_NZXTHue2* rgb_controller = new RGBController_NZXTHue2(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
LOG_TRACE("[NZXTHue2Controller] NZXT Controller setup: %s", info->path);
}
else
{
LOG_DEBUG("[NZXTHue2Controller] Failed to load device: %s!", info->path);
}
}
void DetectNZXTHue2(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 4, 0);
}
void DetectNZXTHue2Ambient(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 2, 0);
}
void DetectNZXTHue2Motherboard(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 2, 3);
}
void DetectNZXTSmartDeviceV2(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 2, 3);
}
void DetectNZXTKrakenX3(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 3, 0);
}
void DetectNZXTKrakenElite(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 2, 2, true);
}
void DetectNZXTFanController(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 2, 3);
}
void DetectNZXTFanController6Channel(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 6, 3);
}
void DetectNZXTRGBController(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 3, 0);
}
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController, NZXT_VID, NZXT_RGB_FAN_CONTROLLER_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController, NZXT_VID, NZXT_RGB_FAN_CONTROLLER2_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController, NZXT_VID, NZXT_RGB_FAN_CONTROLLER3_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController6Channel, NZXT_VID, NZXT_RGB_FAN_CONTROLLER4_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController6Channel, NZXT_VID, NZXT_RGB_FAN_CONTROLLER5_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController6Channel, NZXT_VID, NZXT_RGB_FAN_CONTROLLER6_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController6Channel, NZXT_VID, NZXT_RGB_FAN_CONTROLLER7_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller 2024", DetectNZXTFanController6Channel, NZXT_VID, NZXT_RGB_FAN_CONTROLLER8_PID);
REGISTER_HID_DETECTOR("NZXT B650E Motherboard", DetectNZXTFanController6Channel, NZXT_VID, NZXT_RGB_FAN_CONTROLLER9_PID);
REGISTER_HID_DETECTOR("NZXT Hue 2", DetectNZXTHue2, NZXT_VID, NZXT_HUE_2_PID);
REGISTER_HID_DETECTOR("NZXT Hue 2 Ambient", DetectNZXTHue2Ambient, NZXT_VID, NZXT_HUE_2_AMBIENT_PID);
REGISTER_HID_DETECTOR("NZXT Hue 2 Motherboard", DetectNZXTHue2Motherboard, NZXT_VID, NZXT_MOTHERBOARD_DEVICE_PID);
REGISTER_HID_DETECTOR("NZXT Hue 2 Motherboard", DetectNZXTHue2Motherboard, NZXT_VID, NZXT_MOTHERBOARD_DEVICE_2_PID);
REGISTER_HID_DETECTOR("NZXT Kraken X3 Series", DetectNZXTKrakenX3, NZXT_VID, NZXT_KRAKEN_X3_SERIES_PID);
REGISTER_HID_DETECTOR("NZXT Kraken X3 Series RGB", DetectNZXTKrakenX3, NZXT_VID, NZXT_KRAKEN_X3_SERIES_RGB_PID);
REGISTER_HID_DETECTOR("NZXT Kraken 2024 ELITE Series RGB", DetectNZXTKrakenElite, NZXT_VID, NZXT_KRAKEN_2024_ELITE_SERIES_RGB_PID);
REGISTER_HID_DETECTOR("NZXT RGB Controller", DetectNZXTRGBController, NZXT_VID, NZXT_RGB_CONTROLLER_1_PID);
REGISTER_HID_DETECTOR("NZXT RGB Controller", DetectNZXTRGBController, NZXT_VID, NZXT_RGB_CONTROLLER_2_PID);
REGISTER_HID_DETECTOR("NZXT Smart Device V2", DetectNZXTSmartDeviceV2, NZXT_VID, NZXT_SMART_DEVICE_V2_PID);
REGISTER_HID_DETECTOR("NZXT Smart Device V2", DetectNZXTSmartDeviceV2, NZXT_VID, NZXT_SMART_DEVICE_V2_1_PID);
REGISTER_HID_DETECTOR("NZXT Smart Device V2", DetectNZXTSmartDeviceV2, NZXT_VID, NZXT_SMART_DEVICE_V2_2_PID);
/*---------------------------------------------------------*\
| NZXTHue2ControllerDetect.cpp |
| |
| Detector for NZXT Hue 2 |
| |
| Adam Honse (calcprogrammer1@gmail.com) 29 Dec 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "Detector.h"
#include "LogManager.h"
#include "NZXTHue2Controller.h"
#include "RGBController_NZXTHue2.h"
#define NZXT_VID 0x1E71
#define NZXT_HUE_2_PID 0x2001
#define NZXT_HUE_2_AMBIENT_PID 0x2002
#define NZXT_MOTHERBOARD_DEVICE_PID 0x2005
#define NZXT_MOTHERBOARD_DEVICE_2_PID 0x200B
#define NZXT_SMART_DEVICE_V2_PID 0x2006
#define NZXT_KRAKEN_X3_SERIES_PID 0x2007
#define NZXT_KRAKEN_X3_SERIES_RGB_PID 0x2014
#define NZXT_KRAKEN_2024_ELITE_SERIES_RGB_PID 0x3012
#define NZXT_RGB_FAN_CONTROLLER_PID 0x2009
#define NZXT_RGB_FAN_CONTROLLER2_PID 0x2010
#define NZXT_RGB_FAN_CONTROLLER3_PID 0x200E
#define NZXT_RGB_FAN_CONTROLLER4_PID 0x2011
#define NZXT_RGB_FAN_CONTROLLER5_PID 0x2019
#define NZXT_RGB_FAN_CONTROLLER6_PID 0x2020
#define NZXT_RGB_FAN_CONTROLLER7_PID 0x201F
#define NZXT_RGB_FAN_CONTROLLER8_PID 0x2022
#define NZXT_RGB_FAN_CONTROLLER9_PID 0x201B
#define NZXT_RGB_CONTROLLER_1_PID 0x2012
#define NZXT_RGB_CONTROLLER_2_PID 0x2021
#define NZXT_SMART_DEVICE_V2_1_PID 0x200D
#define NZXT_SMART_DEVICE_V2_2_PID 0x200F
static void spawn_hue(hid_device_info* info, const std::string& name, int rgb_channels, int fan_channels, bool use_2023_effects = false)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
NZXTHue2Controller* controller = new NZXTHue2Controller(dev, rgb_channels, fan_channels, info->path, name, use_2023_effects);
RGBController_NZXTHue2* rgb_controller = new RGBController_NZXTHue2(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
LOG_TRACE("[NZXTHue2Controller] NZXT Controller setup: %s", info->path);
}
else
{
LOG_DEBUG("[NZXTHue2Controller] Failed to load device: %s!", info->path);
}
}
void DetectNZXTHue2(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 4, 0);
}
void DetectNZXTHue2Ambient(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 2, 0);
}
void DetectNZXTHue2Motherboard(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 2, 3);
}
void DetectNZXTSmartDeviceV2(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 2, 3);
}
void DetectNZXTKrakenX3(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 3, 0);
}
void DetectNZXTKrakenElite(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 2, 2, true);
}
void DetectNZXTFanController(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 2, 3);
}
void DetectNZXTFanController6Channel(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 6, 3);
}
void DetectNZXTRGBController(hid_device_info* info, const std::string& name)
{
spawn_hue(info, name, 3, 0);
}
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController, NZXT_VID, NZXT_RGB_FAN_CONTROLLER_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController, NZXT_VID, NZXT_RGB_FAN_CONTROLLER2_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController, NZXT_VID, NZXT_RGB_FAN_CONTROLLER3_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController6Channel, NZXT_VID, NZXT_RGB_FAN_CONTROLLER4_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController6Channel, NZXT_VID, NZXT_RGB_FAN_CONTROLLER5_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController6Channel, NZXT_VID, NZXT_RGB_FAN_CONTROLLER6_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController6Channel, NZXT_VID, NZXT_RGB_FAN_CONTROLLER7_PID);
REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller 2024", DetectNZXTFanController6Channel, NZXT_VID, NZXT_RGB_FAN_CONTROLLER8_PID);
REGISTER_HID_DETECTOR("NZXT B650E Motherboard", DetectNZXTFanController6Channel, NZXT_VID, NZXT_RGB_FAN_CONTROLLER9_PID);
REGISTER_HID_DETECTOR("NZXT Hue 2", DetectNZXTHue2, NZXT_VID, NZXT_HUE_2_PID);
REGISTER_HID_DETECTOR("NZXT Hue 2 Ambient", DetectNZXTHue2Ambient, NZXT_VID, NZXT_HUE_2_AMBIENT_PID);
REGISTER_HID_DETECTOR("NZXT Hue 2 Motherboard", DetectNZXTHue2Motherboard, NZXT_VID, NZXT_MOTHERBOARD_DEVICE_PID);
REGISTER_HID_DETECTOR("NZXT Hue 2 Motherboard", DetectNZXTHue2Motherboard, NZXT_VID, NZXT_MOTHERBOARD_DEVICE_2_PID);
REGISTER_HID_DETECTOR("NZXT Kraken X3 Series", DetectNZXTKrakenX3, NZXT_VID, NZXT_KRAKEN_X3_SERIES_PID);
REGISTER_HID_DETECTOR("NZXT Kraken X3 Series RGB", DetectNZXTKrakenX3, NZXT_VID, NZXT_KRAKEN_X3_SERIES_RGB_PID);
REGISTER_HID_DETECTOR("NZXT Kraken 2024 ELITE Series RGB", DetectNZXTKrakenElite, NZXT_VID, NZXT_KRAKEN_2024_ELITE_SERIES_RGB_PID);
REGISTER_HID_DETECTOR("NZXT RGB Controller", DetectNZXTRGBController, NZXT_VID, NZXT_RGB_CONTROLLER_1_PID);
REGISTER_HID_DETECTOR("NZXT RGB Controller", DetectNZXTRGBController, NZXT_VID, NZXT_RGB_CONTROLLER_2_PID);
REGISTER_HID_DETECTOR("NZXT Smart Device V2", DetectNZXTSmartDeviceV2, NZXT_VID, NZXT_SMART_DEVICE_V2_PID);
REGISTER_HID_DETECTOR("NZXT Smart Device V2", DetectNZXTSmartDeviceV2, NZXT_VID, NZXT_SMART_DEVICE_V2_1_PID);
REGISTER_HID_DETECTOR("NZXT Smart Device V2", DetectNZXTSmartDeviceV2, NZXT_VID, NZXT_SMART_DEVICE_V2_2_PID);
Controllers/NZXTHue2Controller/RGBController_NZXTHue2.cpp
+443 -443
View File
@@ -1,443 +1,443 @@
/*---------------------------------------------------------*\
| RGBController_NZXTHue2.cpp |
| |
| RGBController for NZXT Hue 2 |
| |
| Adam Honse (calcprogrammer1@gmail.com) 29 Dec 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_NZXTHue2.h"
/**------------------------------------------------------------------*\
@name NZXT Hue2
@category LEDStrip
@type USB
@save :robot:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectNZXTFanController,DetectNZXTFanController6Channel,DetectNZXTHue2,DetectNZXTHue2Ambient,DetectNZXTHue2Motherboard,DetectNZXTKrakenX3,DetectNZXTRGBController,DetectNZXTSmartDeviceV2,DetectNZXTKrakenElite
@comment
\*-------------------------------------------------------------------*/
RGBController_NZXTHue2::RGBController_NZXTHue2(NZXTHue2Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
vendor = "NZXT";
type = DEVICE_TYPE_LEDSTRIP;
description = "NZXT Hue 2 Device";
version = controller->GetFirmwareVersion();
location = controller->GetLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = 0xFFFF;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Static;
Static.name = "Static";
Static.value = HUE_2_MODE_FIXED;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
modes.push_back(Static);
mode Fading;
Fading.name = "Fading";
Fading.value = HUE_2_MODE_FADING;
Fading.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Fading.speed_min = HUE_2_SPEED_SLOWEST;
Fading.speed_max = HUE_2_SPEED_FASTEST;
Fading.colors_min = 1;
Fading.colors_max = 8;
Fading.speed = HUE_2_SPEED_NORMAL;
Fading.color_mode = MODE_COLORS_MODE_SPECIFIC;
Fading.colors.resize(1);
modes.push_back(Fading);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = HUE_2_MODE_SPECTRUM;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
SpectrumCycle.speed_min = HUE_2_SPEED_SLOWEST;
SpectrumCycle.speed_max = HUE_2_SPEED_FASTEST;
SpectrumCycle.speed = HUE_2_SPEED_NORMAL;
SpectrumCycle.direction = MODE_DIRECTION_RIGHT;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
mode Marquee;
Marquee.name = "Marquee";
Marquee.value = HUE_2_MODE_MARQUEE;
Marquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Marquee.speed_min = HUE_2_SPEED_SLOWEST;
Marquee.speed_max = HUE_2_SPEED_FASTEST;
Marquee.colors_min = 1;
Marquee.colors_max = 1;
Marquee.speed = HUE_2_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 = HUE_2_MODE_COVER_MARQUEE;
CoverMarquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
CoverMarquee.speed_min = HUE_2_SPEED_SLOWEST;
CoverMarquee.speed_max = HUE_2_SPEED_FASTEST;
CoverMarquee.colors_min = 1;
CoverMarquee.colors_max = 8;
CoverMarquee.speed = HUE_2_SPEED_NORMAL;
CoverMarquee.direction = MODE_DIRECTION_RIGHT;
CoverMarquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
CoverMarquee.colors.resize(1);
modes.push_back(CoverMarquee);
mode Alternating;
Alternating.name = "Alternating";
Alternating.value = HUE_2_MODE_ALTERNATING;
Alternating.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Alternating.speed_min = HUE_2_SPEED_SLOWEST;
Alternating.speed_max = HUE_2_SPEED_FASTEST;
Alternating.colors_min = 1;
Alternating.colors_max = 2;
Alternating.speed = HUE_2_SPEED_NORMAL;
Alternating.direction = MODE_DIRECTION_RIGHT;
Alternating.color_mode = MODE_COLORS_MODE_SPECIFIC;
Alternating.colors.resize(1);
modes.push_back(Alternating);
mode Pulsing;
Pulsing.name = "Pulsing";
Pulsing.value = HUE_2_MODE_PULSING;
Pulsing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Pulsing.speed_min = HUE_2_SPEED_SLOWEST;
Pulsing.speed_max = HUE_2_SPEED_FASTEST;
Pulsing.colors_min = 1;
Pulsing.colors_max = 8;
Pulsing.speed = HUE_2_SPEED_NORMAL;
Pulsing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Pulsing.colors.resize(1) ;
modes.push_back(Pulsing);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = HUE_2_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = HUE_2_SPEED_SLOWEST;
Breathing.speed_max = HUE_2_SPEED_FASTEST;
Breathing.colors_min = 1;
Breathing.colors_max = 8;
Breathing.speed = HUE_2_SPEED_NORMAL;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize( 1);
modes.push_back(Breathing);
mode Candle;
Candle.name = "Candle";
Candle.value = HUE_2_MODE_CANDLE;
Candle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Candle.speed_min = HUE_2_SPEED_SLOWEST;
Candle.speed_max = HUE_2_SPEED_FASTEST;
Candle.colors_min = 1;
Candle.colors_max = 8;
Candle.speed = HUE_2_SPEED_NORMAL;
Candle.color_mode = MODE_COLORS_MODE_SPECIFIC;
Candle.colors.resize(1) ;
modes.push_back(Candle);
mode StarryNight;
StarryNight.name = "Starry Night";
StarryNight.value = HUE_2_MODE_STARRY_NIGHT;
StarryNight.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
StarryNight.speed_min = HUE_2_SPEED_SLOWEST;
StarryNight.speed_max = HUE_2_SPEED_FASTEST;
StarryNight.colors_min = 1;
StarryNight.colors_max = 1;
StarryNight.speed = HUE_2_SPEED_NORMAL;
StarryNight.color_mode = MODE_COLORS_MODE_SPECIFIC;
StarryNight.colors.resize(1);
modes.push_back(StarryNight);
mode SuperRainbow;
SuperRainbow.name = "Super Rainbow";
SuperRainbow.value = HUE_2_MODE_SUPER_RAINBOW;
SuperRainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
SuperRainbow.speed_min = HUE_2_SPEED_SLOWEST;
SuperRainbow.speed_max = HUE_2_SPEED_FASTEST;
SuperRainbow.speed = HUE_2_SPEED_NORMAL;
SuperRainbow.direction = MODE_DIRECTION_RIGHT;
SuperRainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(SuperRainbow);
mode RainbowPulse;
RainbowPulse.name = "Rainbow Pulse";
RainbowPulse.value = HUE_2_MODE_RAINBOW_PULSE;
RainbowPulse.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
RainbowPulse.speed_min = HUE_2_SPEED_SLOWEST;
RainbowPulse.speed_max = HUE_2_SPEED_FASTEST;
RainbowPulse.speed = HUE_2_SPEED_NORMAL;
RainbowPulse.direction = MODE_DIRECTION_RIGHT;
RainbowPulse.color_mode = MODE_COLORS_NONE;
modes.push_back(RainbowPulse);
mode RainbowFlow;
RainbowFlow.name = "Rainbow Flow";
RainbowFlow.value = HUE_2_MODE_RAINBOW_FLOW;
RainbowFlow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
RainbowFlow.speed_min = HUE_2_SPEED_SLOWEST;
RainbowFlow.speed_max = HUE_2_SPEED_FASTEST;
RainbowFlow.speed = HUE_2_SPEED_NORMAL;
RainbowFlow.direction = MODE_DIRECTION_RIGHT;
RainbowFlow.color_mode = MODE_COLORS_NONE;
modes.push_back(RainbowFlow);
SetupZones();
}
RGBController_NZXTHue2::~RGBController_NZXTHue2()
{
delete controller;
}
void RGBController_NZXTHue2::SetupZones()
{
/*-------------------------------------------------*\
| Set up zones |
\*-------------------------------------------------*/
for(unsigned int zone_idx = 0; zone_idx < controller->GetNumRGBChannels(); zone_idx++)
{
zone* new_zone = new zone;
new_zone->name = "Hue 2 Channel ";
new_zone->name.append(std::to_string(zone_idx + 1));
new_zone->type = ZONE_TYPE_LINEAR;
new_zone->leds_min = 0;
new_zone->leds_max = 40;
new_zone->leds_count = controller->channel_leds[zone_idx];
new_zone->matrix_map = NULL;
zones.push_back(*new_zone);
}
/*-------------------------------------------------*\
| Set up LEDs |
\*-------------------------------------------------*/
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
{
led new_led;
new_led.name = "Hue 2 Channel ";
new_led.name.append(std::to_string(zone_idx + 1));
new_led.name.append(", LED ");
new_led.name.append(std::to_string(led_idx + 1));
new_led.value = zone_idx;
leds.push_back(new_led);
}
}
/*-------------------------------------------------*\
| Set up segments |
\*-------------------------------------------------*/
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned int start_idx = 0;
for(unsigned int dev_idx = 0; dev_idx < 6; dev_idx++)
{
std::string device_name = "";
switch(controller->channel_dev_ids[zone_idx][dev_idx])
{
case 0x01: //Hue 1 strip
device_name = "Hue 1 strip";
break;
case 0x02: //Aer 1 fan
device_name = "Aer 1 fan";
break;
case 0x04: //Hue 2 strip (10 LEDs)
device_name = "Hue 2 strip (10 LEDs)";
break;
case 0x05: //Hue 2 strip (8 LEDs)
device_name = "Hue 2 strip (8 LEDs)";
break;
case 0x06: //Hue 2 strip (6 LEDs)
device_name = "Hue 2 strip (6 LEDs)";
break;
case 0x08: //Hue 2 Cable Comb (14 LEDs)
device_name = "Hue 2 Cable Comb (14 LEDs)";
break;
case 0x09: //Hue 2 Underglow (300mm) (15 LEDs)
device_name = "Hue 2 Underglow (300mm) (15 LEDs)";
break;
case 0x0A: //Hue 2 Underglow (200mm) (10 LEDs)
device_name = "Hue 2 Underglow (200mm) (10 LEDs)";
break;
case 0x0B: //Aer 2 fan (120mm)
device_name = "Aer 2 fan (120mm)";
break;
case 0x0C: //Aer 2 fan (140mm)
device_name = "Aer 2 fan (140mm)";
break;
case 0x10: //Kraken X3 ring
device_name = "Kraken X3 ring";
break;
case 0x11: //Kraken X3 logo
device_name = "Kraken X3 logo";
break;
case 0x13: //F120 RGB fan (120mm)
device_name = "F120 fan (120mm)";
break;
case 0x14: //F140 RGB fan (140mm)
device_name = "F140 fan (140mm)";
break;
case 0x15: //F120 RGB Duo fan (120mm)
device_name = "F120 Duo fan (120mm)";
break;
case 0x16: //F140 RGB Duo fan (140mm)
device_name = "F140 Duo fan (140mm)";
break;
case 0x17: //F120 RGB Core fan (120mm)
device_name = "F120 Core fan (120mm)";
break;
case 0x18: //F140 RGB Core fan (140mm)
device_name = "F140 Core fan (140mm)";
break;
case 0x19: //F120 RGB Core fan case version (120mm)
device_name = "F120 Core fan case version (120mm)";
break;
case 0x1D: //F360 Core fan case version (360mm)
device_name = "F360 Core fan case version (360mm)";
break;
case 0x1E: //Kraken Elite Ring
device_name = "Kraken Elite Ring";
break;
case 0x1F: //F420 RGB
device_name = "F420 Core fan case version";
break;
default:
break;
}
if(device_name != "")
{
segment new_segment;
new_segment.name = device_name;
new_segment.type = ZONE_TYPE_LINEAR;
new_segment.start_idx = start_idx;
new_segment.leds_count = controller->channel_dev_szs[zone_idx][dev_idx];
zones[zone_idx].segments.push_back(new_segment);
start_idx += new_segment.leds_count;
}
}
}
SetupColors();
}
void RGBController_NZXTHue2::ResizeZone(int zone, int new_size)
{
if((size_t) zone >= zones.size())
{
return;
}
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
{
zones[zone].leds_count = new_size;
SetupZones();
}
}
void RGBController_NZXTHue2::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
controller->SetChannelLEDs((unsigned char)zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
}
void RGBController_NZXTHue2::UpdateZoneLEDs(int zone)
{
controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
}
void RGBController_NZXTHue2::UpdateSingleLED(int led)
{
unsigned int zone_idx = leds[led].value;
controller->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
void RGBController_NZXTHue2::DeviceUpdateMode()
{
if(modes[active_mode].value == 0xFFFF)
{
DeviceUpdateLEDs();
}
else
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
RGBColor* colors = NULL;
bool direction = false;
if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
{
direction = true;
}
if(modes[active_mode].colors.size() > 0)
{
colors = &modes[active_mode].colors[0];
}
controller->SetChannelEffect
(
(unsigned char)zone_idx,
modes[active_mode].value,
modes[active_mode].speed,
direction,
colors,
(unsigned int)modes[active_mode].colors.size()
);
}
}
}
/*---------------------------------------------------------*\
| RGBController_NZXTHue2.cpp |
| |
| RGBController for NZXT Hue 2 |
| |
| Adam Honse (calcprogrammer1@gmail.com) 29 Dec 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_NZXTHue2.h"
/**------------------------------------------------------------------*\
@name NZXT Hue2
@category LEDStrip
@type USB
@save :robot:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectNZXTFanController,DetectNZXTFanController6Channel,DetectNZXTHue2,DetectNZXTHue2Ambient,DetectNZXTHue2Motherboard,DetectNZXTKrakenX3,DetectNZXTRGBController,DetectNZXTSmartDeviceV2,DetectNZXTKrakenElite
@comment
\*-------------------------------------------------------------------*/
RGBController_NZXTHue2::RGBController_NZXTHue2(NZXTHue2Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
vendor = "NZXT";
type = DEVICE_TYPE_LEDSTRIP;
description = "NZXT Hue 2 Device";
version = controller->GetFirmwareVersion();
location = controller->GetLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = 0xFFFF;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Static;
Static.name = "Static";
Static.value = HUE_2_MODE_FIXED;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
modes.push_back(Static);
mode Fading;
Fading.name = "Fading";
Fading.value = HUE_2_MODE_FADING;
Fading.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Fading.speed_min = HUE_2_SPEED_SLOWEST;
Fading.speed_max = HUE_2_SPEED_FASTEST;
Fading.colors_min = 1;
Fading.colors_max = 8;
Fading.speed = HUE_2_SPEED_NORMAL;
Fading.color_mode = MODE_COLORS_MODE_SPECIFIC;
Fading.colors.resize(1);
modes.push_back(Fading);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = HUE_2_MODE_SPECTRUM;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
SpectrumCycle.speed_min = HUE_2_SPEED_SLOWEST;
SpectrumCycle.speed_max = HUE_2_SPEED_FASTEST;
SpectrumCycle.speed = HUE_2_SPEED_NORMAL;
SpectrumCycle.direction = MODE_DIRECTION_RIGHT;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
mode Marquee;
Marquee.name = "Marquee";
Marquee.value = HUE_2_MODE_MARQUEE;
Marquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Marquee.speed_min = HUE_2_SPEED_SLOWEST;
Marquee.speed_max = HUE_2_SPEED_FASTEST;
Marquee.colors_min = 1;
Marquee.colors_max = 1;
Marquee.speed = HUE_2_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 = HUE_2_MODE_COVER_MARQUEE;
CoverMarquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
CoverMarquee.speed_min = HUE_2_SPEED_SLOWEST;
CoverMarquee.speed_max = HUE_2_SPEED_FASTEST;
CoverMarquee.colors_min = 1;
CoverMarquee.colors_max = 8;
CoverMarquee.speed = HUE_2_SPEED_NORMAL;
CoverMarquee.direction = MODE_DIRECTION_RIGHT;
CoverMarquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
CoverMarquee.colors.resize(1);
modes.push_back(CoverMarquee);
mode Alternating;
Alternating.name = "Alternating";
Alternating.value = HUE_2_MODE_ALTERNATING;
Alternating.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Alternating.speed_min = HUE_2_SPEED_SLOWEST;
Alternating.speed_max = HUE_2_SPEED_FASTEST;
Alternating.colors_min = 1;
Alternating.colors_max = 2;
Alternating.speed = HUE_2_SPEED_NORMAL;
Alternating.direction = MODE_DIRECTION_RIGHT;
Alternating.color_mode = MODE_COLORS_MODE_SPECIFIC;
Alternating.colors.resize(1);
modes.push_back(Alternating);
mode Pulsing;
Pulsing.name = "Pulsing";
Pulsing.value = HUE_2_MODE_PULSING;
Pulsing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Pulsing.speed_min = HUE_2_SPEED_SLOWEST;
Pulsing.speed_max = HUE_2_SPEED_FASTEST;
Pulsing.colors_min = 1;
Pulsing.colors_max = 8;
Pulsing.speed = HUE_2_SPEED_NORMAL;
Pulsing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Pulsing.colors.resize(1) ;
modes.push_back(Pulsing);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = HUE_2_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = HUE_2_SPEED_SLOWEST;
Breathing.speed_max = HUE_2_SPEED_FASTEST;
Breathing.colors_min = 1;
Breathing.colors_max = 8;
Breathing.speed = HUE_2_SPEED_NORMAL;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize( 1);
modes.push_back(Breathing);
mode Candle;
Candle.name = "Candle";
Candle.value = HUE_2_MODE_CANDLE;
Candle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Candle.speed_min = HUE_2_SPEED_SLOWEST;
Candle.speed_max = HUE_2_SPEED_FASTEST;
Candle.colors_min = 1;
Candle.colors_max = 8;
Candle.speed = HUE_2_SPEED_NORMAL;
Candle.color_mode = MODE_COLORS_MODE_SPECIFIC;
Candle.colors.resize(1) ;
modes.push_back(Candle);
mode StarryNight;
StarryNight.name = "Starry Night";
StarryNight.value = HUE_2_MODE_STARRY_NIGHT;
StarryNight.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
StarryNight.speed_min = HUE_2_SPEED_SLOWEST;
StarryNight.speed_max = HUE_2_SPEED_FASTEST;
StarryNight.colors_min = 1;
StarryNight.colors_max = 1;
StarryNight.speed = HUE_2_SPEED_NORMAL;
StarryNight.color_mode = MODE_COLORS_MODE_SPECIFIC;
StarryNight.colors.resize(1);
modes.push_back(StarryNight);
mode SuperRainbow;
SuperRainbow.name = "Super Rainbow";
SuperRainbow.value = HUE_2_MODE_SUPER_RAINBOW;
SuperRainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
SuperRainbow.speed_min = HUE_2_SPEED_SLOWEST;
SuperRainbow.speed_max = HUE_2_SPEED_FASTEST;
SuperRainbow.speed = HUE_2_SPEED_NORMAL;
SuperRainbow.direction = MODE_DIRECTION_RIGHT;
SuperRainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(SuperRainbow);
mode RainbowPulse;
RainbowPulse.name = "Rainbow Pulse";
RainbowPulse.value = HUE_2_MODE_RAINBOW_PULSE;
RainbowPulse.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
RainbowPulse.speed_min = HUE_2_SPEED_SLOWEST;
RainbowPulse.speed_max = HUE_2_SPEED_FASTEST;
RainbowPulse.speed = HUE_2_SPEED_NORMAL;
RainbowPulse.direction = MODE_DIRECTION_RIGHT;
RainbowPulse.color_mode = MODE_COLORS_NONE;
modes.push_back(RainbowPulse);
mode RainbowFlow;
RainbowFlow.name = "Rainbow Flow";
RainbowFlow.value = HUE_2_MODE_RAINBOW_FLOW;
RainbowFlow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
RainbowFlow.speed_min = HUE_2_SPEED_SLOWEST;
RainbowFlow.speed_max = HUE_2_SPEED_FASTEST;
RainbowFlow.speed = HUE_2_SPEED_NORMAL;
RainbowFlow.direction = MODE_DIRECTION_RIGHT;
RainbowFlow.color_mode = MODE_COLORS_NONE;
modes.push_back(RainbowFlow);
SetupZones();
}
RGBController_NZXTHue2::~RGBController_NZXTHue2()
{
delete controller;
}
void RGBController_NZXTHue2::SetupZones()
{
/*-------------------------------------------------*\
| Set up zones |
\*-------------------------------------------------*/
for(unsigned int zone_idx = 0; zone_idx < controller->GetNumRGBChannels(); zone_idx++)
{
zone* new_zone = new zone;
new_zone->name = "Hue 2 Channel ";
new_zone->name.append(std::to_string(zone_idx + 1));
new_zone->type = ZONE_TYPE_LINEAR;
new_zone->leds_min = 0;
new_zone->leds_max = 40;
new_zone->leds_count = controller->channel_leds[zone_idx];
new_zone->matrix_map = NULL;
zones.push_back(*new_zone);
}
/*-------------------------------------------------*\
| Set up LEDs |
\*-------------------------------------------------*/
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
{
led new_led;
new_led.name = "Hue 2 Channel ";
new_led.name.append(std::to_string(zone_idx + 1));
new_led.name.append(", LED ");
new_led.name.append(std::to_string(led_idx + 1));
new_led.value = zone_idx;
leds.push_back(new_led);
}
}
/*-------------------------------------------------*\
| Set up segments |
\*-------------------------------------------------*/
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned int start_idx = 0;
for(unsigned int dev_idx = 0; dev_idx < 6; dev_idx++)
{
std::string device_name = "";
switch(controller->channel_dev_ids[zone_idx][dev_idx])
{
case 0x01: //Hue 1 strip
device_name = "Hue 1 strip";
break;
case 0x02: //Aer 1 fan
device_name = "Aer 1 fan";
break;
case 0x04: //Hue 2 strip (10 LEDs)
device_name = "Hue 2 strip (10 LEDs)";
break;
case 0x05: //Hue 2 strip (8 LEDs)
device_name = "Hue 2 strip (8 LEDs)";
break;
case 0x06: //Hue 2 strip (6 LEDs)
device_name = "Hue 2 strip (6 LEDs)";
break;
case 0x08: //Hue 2 Cable Comb (14 LEDs)
device_name = "Hue 2 Cable Comb (14 LEDs)";
break;
case 0x09: //Hue 2 Underglow (300mm) (15 LEDs)
device_name = "Hue 2 Underglow (300mm) (15 LEDs)";
break;
case 0x0A: //Hue 2 Underglow (200mm) (10 LEDs)
device_name = "Hue 2 Underglow (200mm) (10 LEDs)";
break;
case 0x0B: //Aer 2 fan (120mm)
device_name = "Aer 2 fan (120mm)";
break;
case 0x0C: //Aer 2 fan (140mm)
device_name = "Aer 2 fan (140mm)";
break;
case 0x10: //Kraken X3 ring
device_name = "Kraken X3 ring";
break;
case 0x11: //Kraken X3 logo
device_name = "Kraken X3 logo";
break;
case 0x13: //F120 RGB fan (120mm)
device_name = "F120 fan (120mm)";
break;
case 0x14: //F140 RGB fan (140mm)
device_name = "F140 fan (140mm)";
break;
case 0x15: //F120 RGB Duo fan (120mm)
device_name = "F120 Duo fan (120mm)";
break;
case 0x16: //F140 RGB Duo fan (140mm)
device_name = "F140 Duo fan (140mm)";
break;
case 0x17: //F120 RGB Core fan (120mm)
device_name = "F120 Core fan (120mm)";
break;
case 0x18: //F140 RGB Core fan (140mm)
device_name = "F140 Core fan (140mm)";
break;
case 0x19: //F120 RGB Core fan case version (120mm)
device_name = "F120 Core fan case version (120mm)";
break;
case 0x1D: //F360 Core fan case version (360mm)
device_name = "F360 Core fan case version (360mm)";
break;
case 0x1E: //Kraken Elite Ring
device_name = "Kraken Elite Ring";
break;
case 0x1F: //F420 RGB
device_name = "F420 Core fan case version";
break;
default:
break;
}
if(device_name != "")
{
segment new_segment;
new_segment.name = device_name;
new_segment.type = ZONE_TYPE_LINEAR;
new_segment.start_idx = start_idx;
new_segment.leds_count = controller->channel_dev_szs[zone_idx][dev_idx];
zones[zone_idx].segments.push_back(new_segment);
start_idx += new_segment.leds_count;
}
}
}
SetupColors();
}
void RGBController_NZXTHue2::ResizeZone(int zone, int new_size)
{
if((size_t) zone >= zones.size())
{
return;
}
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
{
zones[zone].leds_count = new_size;
SetupZones();
}
}
void RGBController_NZXTHue2::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
controller->SetChannelLEDs((unsigned char)zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
}
void RGBController_NZXTHue2::UpdateZoneLEDs(int zone)
{
controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
}
void RGBController_NZXTHue2::UpdateSingleLED(int led)
{
unsigned int zone_idx = leds[led].value;
controller->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
void RGBController_NZXTHue2::DeviceUpdateMode()
{
if(modes[active_mode].value == 0xFFFF)
{
DeviceUpdateLEDs();
}
else
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
RGBColor* colors = NULL;
bool direction = false;
if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
{
direction = true;
}
if(modes[active_mode].colors.size() > 0)
{
colors = &modes[active_mode].colors[0];
}
controller->SetChannelEffect
(
(unsigned char)zone_idx,
modes[active_mode].value,
modes[active_mode].speed,
direction,
colors,
(unsigned int)modes[active_mode].colors.size()
);
}
}
}
Controllers/NZXTHue2Controller/RGBController_NZXTHue2.h
+36 -36
View File
@@ -1,36 +1,36 @@
/*---------------------------------------------------------*\
| RGBController_NZXTHue2.h |
| |
| RGBController for NZXT Hue 2 |
| |
| Adam Honse (calcprogrammer1@gmail.com) 29 Dec 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "NZXTHue2Controller.h"
class RGBController_NZXTHue2 : public RGBController
{
public:
RGBController_NZXTHue2(NZXTHue2Controller* controller_ptr);
~RGBController_NZXTHue2();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
NZXTHue2Controller* controller;
std::vector<unsigned int> leds_channel;
std::vector<unsigned int> zones_channel;
};
/*---------------------------------------------------------*\
| RGBController_NZXTHue2.h |
| |
| RGBController for NZXT Hue 2 |
| |
| Adam Honse (calcprogrammer1@gmail.com) 29 Dec 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "NZXTHue2Controller.h"
class RGBController_NZXTHue2 : public RGBController
{
public:
RGBController_NZXTHue2(NZXTHue2Controller* controller_ptr);
~RGBController_NZXTHue2();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
NZXTHue2Controller* controller;
std::vector<unsigned int> leds_channel;
std::vector<unsigned int> zones_channel;
};