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

CorsairPeripherals: add hardware modes

Browse source
This commit is contained in:
morg 2022-06-21 16:36:50 +00:00 • committed by Adam Honse
parent e1e9af2f5d
commit f870ad20f2
5 changed files with 371 additions and 40 deletions
Download patch file Download diff file Expand all files Collapse all files

198
Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp
View file

@ -338,18 +338,48 @@ void CorsairPeripheralController::SetName(std::string device_name)
name = device_name;
}
void CorsairPeripheralController::SwitchMode(bool software)
{
if(software)
{
if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT || logical_layout == CORSAIR_TYPE_K70_MK2 || logical_layout == CORSAIR_TYPE_K68)
{
SpecialFunctionControl();
}
LightingControl();
if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT || logical_layout == CORSAIR_TYPE_K70_MK2 || logical_layout == CORSAIR_TYPE_K68)
{
SetupK55AndK95LightingControl();
}
}
else
{
unsigned char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
usb_buf[1] = CORSAIR_COMMAND_WRITE;
usb_buf[2] = CORSAIR_PROPERTY_SPECIAL_FUNCTION;
usb_buf[3] = CORSAIR_LIGHTING_CONTROL_HARDWARE;
hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
}
}
/*-------------------------------------------------------------------------------------------------*\
| Private packet sending functions. |
\*-------------------------------------------------------------------------------------------------*/
void CorsairPeripheralController::LightingControl()
{
char usb_buf[65];
char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-----------------------------------------------------*\
| Set up Lighting Control packet |
@ -386,7 +416,7 @@ void CorsairPeripheralController::LightingControl()
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
}
/*-----------------------------------------------------*\
@ -395,12 +425,12 @@ void CorsairPeripheralController::LightingControl()
void CorsairPeripheralController::SetupK55AndK95LightingControl()
{
char usb_buf[65];
char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-----------------------------------------------------*\
| Set up a packet |
@ -415,7 +445,7 @@ void CorsairPeripheralController::SetupK55AndK95LightingControl()
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
unsigned int* skipped_identifiers = key_mapping_k95_plat_ansi;
int skipped_identifiers_count = sizeof(key_mapping_k95_plat_ansi) / sizeof(key_mapping_k95_plat_ansi[0]);
@ -440,7 +470,7 @@ void CorsairPeripheralController::SetupK55AndK95LightingControl()
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-----------------------------------------------------*\
| Set up a packet - a sequence of 120 ids |
@ -467,18 +497,18 @@ void CorsairPeripheralController::SetupK55AndK95LightingControl()
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
}
}
void CorsairPeripheralController::SpecialFunctionControl()
{
char usb_buf[65];
char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-----------------------------------------------------*\
| Set up Lighting Control packet |
@ -491,19 +521,19 @@ void CorsairPeripheralController::SpecialFunctionControl()
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
}
void CorsairPeripheralController::ReadFirmwareInfo()
{
int actual;
char usb_buf[65];
char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
char offset = 0;
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-----------------------------------------------------*\
| Set up Read Firmware Info packet |
@ -517,15 +547,15 @@ void CorsairPeripheralController::ReadFirmwareInfo()
| If that fails, repeat the send and read the reply as |
| a feature report. |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char*)usb_buf, 65);
actual = hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
hid_write(dev, (unsigned char*)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
actual = hid_read_timeout(dev, (unsigned char*)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH, 1000);
if(actual == 0)
{
/*-------------------------------------------------*\
| Zero out buffer |
\*-------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-------------------------------------------------*\
| Set up Read Firmware Info packet |
@ -534,8 +564,8 @@ void CorsairPeripheralController::ReadFirmwareInfo()
usb_buf[0x01] = CORSAIR_COMMAND_READ;
usb_buf[0x02] = CORSAIR_PROPERTY_FIRMWARE_INFO;
hid_send_feature_report(dev, (unsigned char*)usb_buf, 65);
actual = hid_get_feature_report(dev, (unsigned char*)usb_buf, 65);
hid_send_feature_report(dev, (unsigned char*)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
actual = hid_get_feature_report(dev, (unsigned char*)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
offset = 1;
}
@ -659,12 +689,12 @@ void CorsairPeripheralController::StreamPacket
unsigned char* data_ptr
)
{
char usb_buf[65];
char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-----------------------------------------------------*\
| Set up Stream packet |
@ -682,7 +712,107 @@ void CorsairPeripheralController::StreamPacket
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
}
void CorsairPeripheralController::SetHardwareMode
(
int mode_value,
unsigned int color_mode,
std::vector<RGBColor> colors,
unsigned int speed,
unsigned int direction,
unsigned char brightness
)
{
unsigned char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-----------------------------------------------------*\
| Set the brightness |
\*-----------------------------------------------------*/
usb_buf[1] = CORSAIR_COMMAND_WRITE;
usb_buf[2] = 0x05;
usb_buf[3] = 0x02;
usb_buf[5] = brightness;
hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-----------------------------------------------------*\
| Send "lght_00.d" |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
usb_buf[1] = CORSAIR_COMMAND_WRITE;
usb_buf[2] = 0x17;
usb_buf[3] = 0x05;
usb_buf[5] = 0x6c;
usb_buf[6] = 0x67;
usb_buf[7] = 0x68;
usb_buf[8] = 0x74;
usb_buf[9] = 0x5F;
usb_buf[10] = 0x30;
usb_buf[11] = 0x30;
usb_buf[12] = 0x2E;
usb_buf[13] = 0x64;
hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-----------------------------------------------------*\
| Stream the mode data |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
usb_buf[1] = CORSAIR_COMMAND_STREAM;
usb_buf[2] = 0x01;
usb_buf[3] = 0x0D;
usb_buf[5] = mode_value;
usb_buf[8] = direction;
if(mode_value == CORSAIR_HW_MODE_TYPE_KEY_VALUE)
{
usb_buf[9] = speed;
}
else
{
usb_buf[6] = speed;
}
if(color_mode == MODE_COLORS_RANDOM)
{
usb_buf[7] = 0x01;
}
else if (color_mode == MODE_COLORS_MODE_SPECIFIC)
{
usb_buf[7] = 0x03;
usb_buf[10] = RGBGetRValue(colors[0]);
usb_buf[11] = RGBGetGValue(colors[0]);
usb_buf[12] = RGBGetBValue(colors[0]);
usb_buf[13] = 0xFF;
usb_buf[14] = RGBGetRValue(colors[1]);
usb_buf[15] = RGBGetGValue(colors[1]);
usb_buf[16] = RGBGetBValue(colors[1]);
usb_buf[17] = 0xFF;
}
hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-----------------------------------------------------*\
| Stop stream and commit |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
usb_buf[1] = CORSAIR_COMMAND_WRITE;
usb_buf[2] = 0x17;
usb_buf[3] = 0x09;
hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
usb_buf[3] = 0x08;
hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
}
void CorsairPeripheralController::SubmitKeyboardFullColors
@ -692,12 +822,12 @@ void CorsairPeripheralController::SubmitKeyboardFullColors
unsigned char finish_val
)
{
char usb_buf[65];
char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-----------------------------------------------------*\
| Set up Submit Keyboard 24-Bit Colors packet |
@ -712,7 +842,7 @@ void CorsairPeripheralController::SubmitKeyboardFullColors
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
}
void CorsairPeripheralController::SubmitKeyboardZonesColors
@ -722,7 +852,7 @@ void CorsairPeripheralController::SubmitKeyboardZonesColors
RGBColor right
)
{
char usb_buf[65];
char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
/*-----------------------------------------------------*\
| Zero out buffer |
@ -750,7 +880,7 @@ void CorsairPeripheralController::SubmitKeyboardZonesColors
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
}
void CorsairPeripheralController::SubmitKeyboardLimitedColors
@ -758,7 +888,7 @@ void CorsairPeripheralController::SubmitKeyboardLimitedColors
unsigned char byte_count
)
{
char usb_buf[65];
char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
/*-----------------------------------------------------*\
| Zero out buffer |
@ -776,7 +906,7 @@ void CorsairPeripheralController::SubmitKeyboardLimitedColors
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
}
void CorsairPeripheralController::SubmitMouseColors
@ -785,12 +915,12 @@ void CorsairPeripheralController::SubmitMouseColors
RGBColor * color_data
)
{
char usb_buf[65];
char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-----------------------------------------------------*\
| Set up Submit Mouse Colors packet |
@ -815,7 +945,7 @@ void CorsairPeripheralController::SubmitMouseColors
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
}
void CorsairPeripheralController::SubmitMousematColors
@ -824,12 +954,12 @@ void CorsairPeripheralController::SubmitMousematColors
RGBColor * color_data
)
{
char usb_buf[65];
char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
/*-----------------------------------------------------*\
| Set up Submit Mouse Colors packet |
@ -854,5 +984,5 @@ void CorsairPeripheralController::SubmitMousematColors
| Send packet using feature reports, as headset stand |
| seems to not update completely using HID writes |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
}

36
Controllers/CorsairPeripheralController/CorsairPeripheralController.h
View file

@ -15,6 +15,8 @@
#pragma once
#define CORSAIR_PERIPHERAL_PACKET_LENGTH 65
enum
{
CORSAIR_COMMAND_WRITE = 0x07,
@ -67,6 +69,28 @@ enum
CORSAIR_TYPE_K68 = 5
};
enum
{
CORSAIR_MODE_DIRECT_VALUE = 0xFF,
CORSAIR_HW_MODE_COLOR_PULSE_VALUE = 0x01,
CORSAIR_HW_MODE_COLOR_SHIFT_VALUE = 0x00,
CORSAIR_HW_MODE_COLOR_WAVE_VALUE = 0x04,
CORSAIR_HW_MODE_RAINBOW_WAVE_VALUE = 0x03,
CORSAIR_HW_MODE_RAIN_VALUE = 0x06,
CORSAIR_HW_MODE_SPIRAL_VALUE = 0x02,
CORSAIR_HW_MODE_TYPE_KEY_VALUE = 0x08,
CORSAIR_HW_MODE_TYPE_RIPPLE_VALUE = 0x09,
CORSAIR_HW_MODE_VISOR_VALUE = 0x05
};
enum
{
CORSAIR_HW_MODE_SPEED_MIN = 0x01,
CORSAIR_HW_MODE_SPEED_MAX = 0x03,
CORSAIR_HW_MODE_BRIGHTNESS_MIN = 0x00,
CORSAIR_HW_MODE_BRIGHTNESS_MAX = 0x03
};
class CorsairPeripheralController
{
public:
@ -87,6 +111,18 @@ public:
void SetLEDsMouse(std::vector<RGBColor> colors);
void SetLEDsMousemat(std::vector<RGBColor> colors);
void SetName(std::string device_name);
void SetHardwareMode
(
int mode_value,
unsigned int color_mode,
std::vector<RGBColor> colors,
unsigned int speed,
unsigned int direction,
unsigned char brightness
);
void SwitchMode(bool software);
private:
hid_device* dev;

6
Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp
View file

@ -179,7 +179,11 @@ void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string
if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
{
RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller);
bool supports_hardware_modes =
(info->product_id == CORSAIR_K70_RGB_MK2_PID) ||
(info->product_id == CORSAIR_K70_RGB_MK2_LP_PID);
RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller, supports_hardware_modes);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
else

168
Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp
View file

@ -1,4 +1,4 @@
/*-----------------------------------------*\
/*-----------------------------------------*\
| RGBController_CorsairPeripheral.cpp |
| |
| Generic RGB Interface for Corsair RGB |
@ -760,12 +760,16 @@ static const char* corsair_harpoon_pro_leds[] =
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:
@effects :tools:
@detectors DetectCorsairPeripheralControllers
@comment
All controllers support `Direct` mode
Currently HW modes are implemented for the following devices:
* Corsair K70 RGB MK.2
* Corsair K70 RGB MK.2 Low Profile
\*-------------------------------------------------------------------*/
RGBController_CorsairPeripheral::RGBController_CorsairPeripheral(CorsairPeripheralController* controller_ptr)
RGBController_CorsairPeripheral::RGBController_CorsairPeripheral(CorsairPeripheralController* controller_ptr, bool supports_hardware_modes)
{
controller = controller_ptr;
@ -782,11 +786,142 @@ RGBController_CorsairPeripheral::RGBController_CorsairPeripheral(CorsairPeripher
mode Direct;
Direct.name = "Direct";
Direct.value = 0;
Direct.value = CORSAIR_MODE_DIRECT_VALUE;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
if(supports_hardware_modes)
{
mode ColorPulse;
ColorPulse.name = "ColorPulse";
ColorPulse.value = CORSAIR_HW_MODE_COLOR_PULSE_VALUE;
ColorPulse.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
ColorPulse.color_mode = MODE_COLORS_RANDOM;
ColorPulse.speed = CORSAIR_HW_MODE_SPEED_MIN;
ColorPulse.speed_min = CORSAIR_HW_MODE_SPEED_MIN;
ColorPulse.speed_max = CORSAIR_HW_MODE_SPEED_MAX;
ColorPulse.brightness = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
ColorPulse.brightness_min = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
ColorPulse.brightness_max = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
ColorPulse.colors.resize(2);
modes.push_back(ColorPulse);
mode ColorShift;
ColorShift.name = "ColorShift";
ColorShift.value = CORSAIR_HW_MODE_COLOR_SHIFT_VALUE;
ColorShift.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
ColorShift.color_mode = MODE_COLORS_RANDOM;
ColorShift.speed = CORSAIR_HW_MODE_SPEED_MIN;
ColorShift.speed_min = CORSAIR_HW_MODE_SPEED_MIN;
ColorShift.speed_max = CORSAIR_HW_MODE_SPEED_MAX;
ColorShift.brightness = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
ColorShift.brightness_min = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
ColorShift.brightness_max = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
ColorShift.colors.resize(2);
modes.push_back(ColorShift);
mode ColorWave;
ColorWave.name = "ColorWave";
ColorWave.value = CORSAIR_HW_MODE_COLOR_WAVE_VALUE;
ColorWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
ColorWave.color_mode = MODE_COLORS_RANDOM;
ColorWave.direction = MODE_DIRECTION_LEFT;
ColorWave.speed = CORSAIR_HW_MODE_SPEED_MIN;
ColorWave.speed_min = CORSAIR_HW_MODE_SPEED_MIN;
ColorWave.speed_max = CORSAIR_HW_MODE_SPEED_MAX;
ColorWave.brightness = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
ColorWave.brightness_min = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
ColorWave.brightness_max = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
ColorWave.colors.resize(2);
modes.push_back(ColorWave);
mode RainbowWave;
RainbowWave.name = "RainbowWave";
RainbowWave.value = CORSAIR_HW_MODE_RAINBOW_WAVE_VALUE;
RainbowWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
RainbowWave.color_mode = MODE_COLORS_NONE;
RainbowWave.direction = MODE_DIRECTION_LEFT;
RainbowWave.speed = CORSAIR_HW_MODE_SPEED_MIN;
RainbowWave.speed_min = CORSAIR_HW_MODE_SPEED_MIN;
RainbowWave.speed_max = CORSAIR_HW_MODE_SPEED_MAX;
RainbowWave.brightness = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
RainbowWave.brightness_min = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
RainbowWave.brightness_max = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
modes.push_back(RainbowWave);
mode Rain;
Rain.name = "Rain";
Rain.value = CORSAIR_HW_MODE_RAIN_VALUE;
Rain.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Rain.color_mode = MODE_COLORS_RANDOM;
Rain.speed = CORSAIR_HW_MODE_SPEED_MIN;
Rain.speed_min = CORSAIR_HW_MODE_SPEED_MIN;
Rain.speed_max = CORSAIR_HW_MODE_SPEED_MAX;
Rain.brightness = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
Rain.brightness_min = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
Rain.brightness_max = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
Rain.colors.resize(2);
modes.push_back(Rain);
mode Spiral;
Spiral.name = "Spiral";
Spiral.value = CORSAIR_HW_MODE_SPIRAL_VALUE;
Spiral.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Spiral.color_mode = MODE_COLORS_NONE;
Spiral.speed = CORSAIR_HW_MODE_SPEED_MIN;
Spiral.speed_min = CORSAIR_HW_MODE_SPEED_MIN;
Spiral.speed_max = CORSAIR_HW_MODE_SPEED_MAX;
Spiral.brightness = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
Spiral.brightness_min = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
Spiral.brightness_max = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
Spiral.direction = MODE_DIRECTION_LEFT;
modes.push_back(Spiral);
mode TypeKey;
TypeKey.name = "TypeKey";
TypeKey.value = CORSAIR_HW_MODE_TYPE_KEY_VALUE;
TypeKey.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
TypeKey.color_mode = MODE_COLORS_RANDOM;
TypeKey.speed = CORSAIR_HW_MODE_SPEED_MIN;
TypeKey.speed_min = CORSAIR_HW_MODE_SPEED_MIN;
TypeKey.speed_max = CORSAIR_HW_MODE_SPEED_MAX;
TypeKey.brightness = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
TypeKey.brightness_min = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
TypeKey.brightness_max = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
TypeKey.colors.resize(2);
modes.push_back(TypeKey);
mode TypeRipple;
TypeRipple.name = "TypeRipple";
TypeRipple.value = CORSAIR_HW_MODE_TYPE_RIPPLE_VALUE;
TypeRipple.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
TypeRipple.color_mode = MODE_COLORS_RANDOM;
TypeRipple.speed = CORSAIR_HW_MODE_SPEED_MIN;
TypeRipple.speed_min = CORSAIR_HW_MODE_SPEED_MIN;
TypeRipple.speed_max = CORSAIR_HW_MODE_SPEED_MAX;
TypeRipple.brightness = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
TypeRipple.brightness_min = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
TypeRipple.brightness_max = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
TypeRipple.colors.resize(2);
modes.push_back(TypeRipple);
mode Visor;
Visor.name = "Visor";
Visor.value = CORSAIR_HW_MODE_VISOR_VALUE;
Visor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Visor.color_mode = MODE_COLORS_RANDOM;
Visor.speed = CORSAIR_HW_MODE_SPEED_MIN;
Visor.speed_min = CORSAIR_HW_MODE_SPEED_MIN;
Visor.speed_max = CORSAIR_HW_MODE_SPEED_MAX;
Visor.brightness = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
Visor.brightness_min = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
Visor.brightness_max = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
Visor.colors.resize(2);
modes.push_back(Visor);
}
SetupZones();
}
@ -1082,4 +1217,29 @@ void RGBController_CorsairPeripheral::SetCustomMode()
void RGBController_CorsairPeripheral::DeviceUpdateMode()
{
if(modes[active_mode].value == CORSAIR_MODE_DIRECT_VALUE)
{
controller->SwitchMode(true);
}
else
{
const mode& active = modes[active_mode];
unsigned int direction = active.direction;
if(active.flags & MODE_FLAG_HAS_DIRECTION_LR || active.flags & MODE_FLAG_HAS_DIRECTION_UD)
{
direction += 1;
if(active.value == CORSAIR_HW_MODE_SPIRAL_VALUE)
{
direction += 4;
}
}
controller->SetHardwareMode(active.value, active.color_mode, active.colors, active.speed, direction, active.brightness);
controller->SwitchMode(false);
}
}

3
Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.h
View file

@ -14,7 +14,7 @@
class RGBController_CorsairPeripheral : public RGBController
{
public:
RGBController_CorsairPeripheral(CorsairPeripheralController* controller_ptr);
RGBController_CorsairPeripheral(CorsairPeripheralController* controller_ptr, bool supports_hardware_modes);
~RGBController_CorsairPeripheral();
int physical_layout;
@ -31,6 +31,7 @@ public:
void SetCustomMode();
void DeviceUpdateMode();
private:
CorsairPeripheralController* controller;
};