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

Add support for Corsair K95 Platinum XT. Closes #2511

Browse source
This commit is contained in:
morg 2022-06-19 21:33:26 +00:00 • committed by Adam Honse
parent a39f8dd560
commit d193c93e6d
6 changed files with 616 additions and 13 deletions
Download patch file Download diff file Expand all files Collapse all files

142
Controllers/CorsairPeripheralController/CorsairK95PlatinumXTController.cpp Normal file
View file

@ -0,0 +1,142 @@
/*-----------------------------------------*\
| CorsairK195PlatinumXTController.h |
| |
| Driver for Corsair K95 Platinum XT |
| Keyboard |
| Guimard Morgan (morg) 6/07/2022 |
\*-----------------------------------------*/
#include "CorsairK95PlatinumXTController.h"
CorsairK95PlatinumXTController::CorsairK95PlatinumXTController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
Init();
}
CorsairK95PlatinumXTController::~CorsairK95PlatinumXTController()
{
hid_close(dev);
}
std::string CorsairK95PlatinumXTController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string CorsairK95PlatinumXTController::GetFirmwareString()
{
return "";
}
std::string CorsairK95PlatinumXTController::GetName()
{
return name;
}
std::string CorsairK95PlatinumXTController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
std::wstring return_wstring = serial_string;
std::string return_string(return_wstring.begin(), return_wstring.end());
return(return_string);
}
void CorsairK95PlatinumXTController::Init()
{
unsigned char usb_buf[K95_PLATINUM_XT_REPORT_LENGTH];
memset(usb_buf, 0x00, K95_PLATINUM_XT_REPORT_LENGTH);
usb_buf[0x01] = K95_PLATINUM_XT_REPORT_ID;
usb_buf[0x02] = 0x01;
usb_buf[0x03] = 0x03;
usb_buf[0x05] = 0x02;
hid_write(dev, usb_buf, K95_PLATINUM_XT_REPORT_LENGTH);
memset(usb_buf, 0x00, K95_PLATINUM_XT_REPORT_LENGTH);
usb_buf[0x01] = K95_PLATINUM_XT_REPORT_ID;
usb_buf[0x02] = 0x02;
usb_buf[0x03] = 0x6E;
hid_write(dev, usb_buf, K95_PLATINUM_XT_REPORT_LENGTH);
memset(usb_buf, 0x00, K95_PLATINUM_XT_REPORT_LENGTH);
usb_buf[0x01] = K95_PLATINUM_XT_REPORT_ID;
usb_buf[0x02] = 0x0D;
usb_buf[0x03] = 0x01;
usb_buf[0x04] = 0x01;
hid_write(dev, usb_buf, K95_PLATINUM_XT_REPORT_LENGTH);
}
void CorsairK95PlatinumXTController::SendDirect(const std::vector<RGBColor>& colors, const std::vector<std::tuple<std::string,unsigned int>>& leds_positions)
{
/*-----------------------------------------------------*\
| RGB indexes |
\*-----------------------------------------------------*/
unsigned int red_start = 0x008;
unsigned int grn_start = 0x0A4;
unsigned int blu_start = 0x140;
/*-----------------------------------------------------*\
| Fill the color data array |
\*-----------------------------------------------------*/
unsigned char color_data[K95_PLATINUM_XT_COLOR_DATA_LENGTH];
memset(color_data, 0x00, K95_PLATINUM_XT_COLOR_DATA_LENGTH);
color_data[0x00] = 0xD4;
color_data[0x01] = 0x01;
for(unsigned int c = 0; c < colors.size(); c++)
{
unsigned char red = RGBGetRValue(colors[c]);
unsigned char grn = RGBGetGValue(colors[c]);
unsigned char blu = RGBGetBValue(colors[c]);
unsigned int led_pos = std::get<1>(leds_positions[c]);
color_data[led_pos + red_start] = red;
color_data[led_pos + grn_start] = grn;
color_data[led_pos + blu_start] = blu;
}
/*-----------------------------------------------------*\
| Send the 8 pages of colors |
\*-----------------------------------------------------*/
unsigned char usb_buf[K95_PLATINUM_XT_REPORT_LENGTH];
usb_buf[0x00] = 0x00;
usb_buf[0x01] = K95_PLATINUM_XT_REPORT_ID;
usb_buf[0x02] = 0x06;
usb_buf[0x03] = 0x01;
for(unsigned int i = 0; i < K95_PLATINUM_XT_NUMBER_OF_PAGES; i++)
{
/*-----------------------------------------------------*\
| Copy colors in current page |
\*-----------------------------------------------------*/
memcpy
(
&usb_buf[0x04],
&color_data[(K95_PLATINUM_XT_REPORT_LENGTH - 4) * i],
K95_PLATINUM_XT_REPORT_LENGTH - 4
);
/*-----------------------------------------------------*\
| Send the buffer |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, K95_PLATINUM_XT_REPORT_LENGTH);
/*-----------------------------------------------------*\
| Next pages start with 0x07 |
\*-----------------------------------------------------*/
usb_buf[0x02] = 0x07;
}
}

44
Controllers/CorsairPeripheralController/CorsairK95PlatinumXTController.h Normal file
View file

@ -0,0 +1,44 @@
/*-----------------------------------------*\
| CorsairK95PlatinumXTController.h |
| |
| Driver for Corsair K95 Platinum XT |
| Keyboard |
| |
| Guimard Morgan (morg) 6/07/2022 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include <string.h>
#include <hidapi/hidapi.h>
#define K95_PLATINUM_XT_REPORT_LENGTH 65
#define K95_PLATINUM_XT_COLOR_DATA_LENGTH 488
#define K95_PLATINUM_XT_REPORT_ID 0x08
#define K95_PLATINUM_XT_NUMBER_OF_PAGES 0x08
#define K95_PLATINUM_XT_READ_COMMAND 0x02
#define K95_PLATINUM_XT_DIRECT_START_STREAM 0x07
#define K95_PLATINUM_XT_DIRECT_BLOCK_STREAM 0x06
class CorsairK95PlatinumXTController
{
public:
CorsairK95PlatinumXTController(hid_device* dev_handle, const char* path);
~CorsairK95PlatinumXTController();
std::string GetDeviceLocation();
std::string GetFirmwareString();
std::string GetName();
std::string GetSerialString();
void SendDirect(const std::vector<RGBColor>& colors, const std::vector<std::tuple<std::string,unsigned int>>& leds_positions);
private:
hid_device* dev;
std::string firmware_version;
std::string location;
std::string name;
void Init();
};

49
Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp
View file

@ -8,6 +8,7 @@
#include "RGBController_CorsairK100.h"
#include "RGBController_CorsairK55RGBPRO.h"
#include "RGBController_CorsairK65Mini.h"
#include "RGBController_CorsairK95PlatinumXT.h"
#include <hidapi/hidapi.h>
#define CORSAIR_PERIPHERAL_CONTROLLER_NAME "Corsair peripheral"
@ -80,6 +81,24 @@
\*-----------------------------------------------------*/
#define CORSAIR_K100_PID 0x1B7C
/*-----------------------------------------------------*\
| Corsair K55 RGB PRO Keyboard product ID |
| This keyboard uses a separate driver |
\*-----------------------------------------------------*/
#define CORSAIR_K55_RGB_PRO_PID 0x1BA4
/*-----------------------------------------------------*\
| Corsair K65 Mini Keyboard product ID |
| This keyboard uses a separate driver |
\*-----------------------------------------------------*/
#define CORSAIR_K65_MINI_PID 0x1BAF
/*-----------------------------------------------------*\
| Corsair K95 Platinum XT Keyboard product ID |
| This keyboard uses a separate driver |
\*-----------------------------------------------------*/
#define CORSAIR_K95_PLATINUM_XT_PID 0x1B89
void DetectCorsairK100Controllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
@ -101,12 +120,6 @@ void DetectCorsairK100Controllers(hid_device_info* info, const std::string& name
}
} /* DetectCorsairPeripheralControllers() */
/*-----------------------------------------------------*\
| Corsair K55 RGB PRO Keyboard product ID |
| This keyboard uses a separate driver |
\*-----------------------------------------------------*/
#define CORSAIR_K55_RGB_PRO_PID 0x1BA4
void DetectCorsairK55RGBPROControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
@ -120,25 +133,31 @@ void DetectCorsairK55RGBPROControllers(hid_device_info* info, const std::string&
}
} /* DetectCorsairK55RGBPROControllers() */
/*-----------------------------------------------------*\
| Corsair K65 Mini Keyboard product ID |
| This keyboard uses a separate driver |
\*-----------------------------------------------------*/
#define CORSAIR_K65_MINI_PID 0x1BAF
void DetectCorsairK65MiniControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
CorsairK65MiniController* controller = new CorsairK65MiniController(dev, info->path);
CorsairK65MiniController* controller = new CorsairK65MiniController(dev, info->path);
RGBController_CorsairK65Mini* rgb_controller = new RGBController_CorsairK65Mini(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
} /* DetectCorsairK65MiniControllers() */
void DetectCorsairK95PlatinumXTControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
CorsairK95PlatinumXTController* controller = new CorsairK95PlatinumXTController(dev, info->path);
RGBController_CorsairK95PlatinumXT* rgb_controller = new RGBController_CorsairK95PlatinumXT(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
} /* DetectCorsairK65MiniControllers() */
/******************************************************************************************\
* *
@ -238,3 +257,7 @@ REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO", DetectCorsairK55RGBP
| Corsair K65 Mini Keyboard |
\*-----------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_IPU("Corsair K65 Mini", DetectCorsairK65MiniControllers, CORSAIR_VID, CORSAIR_K65_MINI_PID, 1, 0, 0);
/*-----------------------------------------------------------------------------------------------------*\
| Corsair K95 Platinum XT Keyboard |
\*-----------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_IP("Corsair K95 RGB PLATINUM XT", DetectCorsairK95PlatinumXTControllers, CORSAIR_VID, CORSAIR_K95_PLATINUM_XT_PID, 1, 0xFF42);

362
Controllers/CorsairPeripheralController/RGBController_CorsairK95PlatinumXT.cpp Normal file
View file

@ -0,0 +1,362 @@
/*-----------------------------------------*\
| RGBController_CorsairK95PlatinumXT.h |
| |
| |
| Guimard Morgan (morg) 6/07/2022 |
\*-----------------------------------------*/
#include "RGBControllerKeyNames.h"
#include "RGBController_CorsairK95PlatinumXT.h"
#include "RGBControllerKeyNames.h"
#define NA 0xFFFFFFFF
#define K95_PLATINUM_BAR_LENGTH 19
#define K95_PLATINUM_XT_HEIGHT 7
#define K95_PLATINUM_XT_WIDTH 23
static unsigned int k95_platinum_xt_matrix_map[K95_PLATINUM_XT_HEIGHT][K95_PLATINUM_XT_WIDTH] =
{
{ NA, NA, NA, NA, 22, 28, 34, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 96, NA, NA, NA},
{ 0, 6, NA, 16, 23, 29, 35, NA, 45, 50, 55, 60, 66, 72, 76, 78, 83, 87, 92, 97, 103, 108, 114},
{ 1, 7, 12, 17, 24, 30, 36, 40, 46, 51, 56, 61, 67, 73, NA, 79, 84, 88, 93, 98, 104, 109, 115},
{ 2, 8, 13, 18, 25, 31, 37, 41, 47, 52, 57, 62, 68, 74, NA, 80, 85, 89, 94, 99, 105, 110, 116},
{ 3, 9, 14, 19, 26, 32, 38, 42, 48, 53, 58, 63, 69, NA, NA, 81, NA, NA, NA, 100, 106, 111, NA},
{ 4, 10, NA, 20, 27, 33, 39, 43, 49, 54, 59, 64, 70, NA, 77, NA, NA, 90, NA, 101, 107, 112, 117},
{ 5, 11, 15, 21, NA, NA, NA, 44, NA, NA, NA, 65, 71, 75, NA, 82, 86, 91, 95, 102, NA, 113, NA}
};
static std::vector<std::tuple<std::string, unsigned int>> k95_platinum_xt_leds_names_and_positions =
{
// Top Bar
{"LED: 1", 133},
{"LED: 2", 134},
{"LED: 3", 135},
{"LED: 4", 136},
{"LED: 5", 137},
{"LED: 6", 138},
{"LED: 7", 139},
{"LED: 8", 140},
{"LED: 9", 141},
{"LED: 10", 142},
{"LED: 11", 143},
{"LED: 12", 144},
{"LED: 13", 145},
{"LED: 14", 146},
{"LED: 15", 147},
{"LED: 16", 148},
{"LED: 17", 149},
{"LED: 18", 150},
{"LED: 19", 151},
// COL 1
{"Key: G1", 127},
{"Key: G2", 128},
{"Key: G3", 129},
{"Key: G4", 130},
{"Key: G5", 131},
{"Key: G6", 132},
// COL 2
{KEY_EN_ESCAPE, 37},
{KEY_EN_BACK_TICK, 49},
{KEY_EN_TAB, 39},
{KEY_EN_CAPS_LOCK, 53},
{KEY_EN_LEFT_SHIFT, 102},
{KEY_EN_LEFT_CONTROL, 101},
// COL 3
{KEY_EN_1, 26},
{KEY_EN_Q, 16},
{KEY_EN_A, 0},
{KEY_EN_LEFT_WINDOWS, 104},
// COL 4
{KEY_EN_F1, 54},
{KEY_EN_2, 27},
{KEY_EN_W, 22},
{KEY_EN_S, 18},
{KEY_EN_Z, 25},
{KEY_EN_LEFT_ALT, 103},
// COL 5
{"Key: User", 124},
{KEY_EN_F2, 55},
{KEY_EN_3, 28},
{KEY_EN_E, 4},
{KEY_EN_D, 3},
{KEY_EN_X, 23},
// COL 6
{"Key: Brightness", 109},
{KEY_EN_F3, 56},
{KEY_EN_4, 29},
{KEY_EN_R, 17},
{KEY_EN_F, 5},
{KEY_EN_C, 2},
// COL 7
{"Key: Lock", 110},
{KEY_EN_F4, 57},
{KEY_EN_5, 30},
{KEY_EN_T, 19},
{KEY_EN_G, 6},
{KEY_EN_V, 21},
// COL 8
{KEY_EN_6, 31},
{KEY_EN_Y, 24},
{KEY_EN_H, 7},
{KEY_EN_B, 1},
{KEY_EN_SPACE, 40},
// COL 9
{KEY_EN_F5, 58},
{KEY_EN_7, 32},
{KEY_EN_U, 20},
{KEY_EN_J, 9},
{KEY_EN_N, 13},
// COL 10
{KEY_EN_F6, 59},
{KEY_EN_8, 33},
{KEY_EN_I, 8},
{KEY_EN_K, 10},
{KEY_EN_M, 12},
// COL 11
{KEY_EN_F7, 60},
{KEY_EN_9, 34},
{KEY_EN_O, 14},
{KEY_EN_L, 11},
{KEY_EN_COMMA, 50},
// COL 12
{KEY_EN_F8, 61},
{KEY_EN_0, 35},
{KEY_EN_P, 15},
{KEY_EN_SEMICOLON, 47},
{KEY_EN_PERIOD, 51},
{KEY_EN_RIGHT_ALT, 107},
// COL 13
{KEY_EN_F9, 62},
{KEY_EN_MINUS, 41},
{KEY_EN_LEFT_BRACKET, 43},
{KEY_EN_QUOTE, 48},
{KEY_EN_FORWARD_SLASH, 52},
{KEY_EN_RIGHT_WINDOWS, 108},
// COL 14
{KEY_EN_F10, 63},
{KEY_EN_EQUALS, 42},
{KEY_EN_RIGHT_BRACKET, 44},
{KEY_EN_MENU, 97},
// COL 15
{KEY_EN_F11, 64},
{KEY_EN_RIGHT_SHIFT, 106},
// COL 16
{KEY_EN_F12, 65},
{KEY_EN_BACKSPACE, 38},
{KEY_EN_ANSI_BACK_SLASH, 45},
{KEY_EN_ANSI_ENTER, 36},
{KEY_EN_RIGHT_CONTROL, 105},
// COL 17
{KEY_EN_PRINT_SCREEN, 66},
{KEY_EN_INSERT, 69},
{KEY_EN_DELETE, 72},
{KEY_EN_LEFT_ARROW, 76},
// COL 18
{KEY_EN_SCROLL_LOCK, 67},
{KEY_EN_HOME, 70},
{KEY_EN_END, 73},
{KEY_EN_UP_ARROW, 78},
{KEY_EN_DOWN_ARROW, 77},
// COL 19
{KEY_EN_PAUSE_BREAK, 68},
{KEY_EN_PAGE_UP, 71},
{KEY_EN_PAGE_DOWN, 74},
{KEY_EN_RIGHT_ARROW, 75},
// COL 20
{KEY_EN_MEDIA_MUTE, 98},
{KEY_EN_MEDIA_STOP, 119},
{KEY_EN_NUMPAD_LOCK, 79},
{KEY_EN_NUMPAD_7, 91},
{KEY_EN_NUMPAD_4, 88},
{KEY_EN_NUMPAD_1, 85},
{KEY_EN_NUMPAD_0, 94},
// COL 21
{KEY_EN_MEDIA_PREVIOUS, 122},
{KEY_EN_NUMPAD_DIVIDE, 80},
{KEY_EN_NUMPAD_8, 92},
{KEY_EN_NUMPAD_5, 89},
{KEY_EN_NUMPAD_2, 86},
// COL 22
{KEY_EN_MEDIA_PLAY_PAUSE, 120},
{KEY_EN_NUMPAD_TIMES, 81},
{KEY_EN_NUMPAD_9, 93},
{KEY_EN_NUMPAD_6, 90},
{KEY_EN_NUMPAD_3, 87},
{KEY_EN_NUMPAD_PERIOD, 95},
// COL 23
{KEY_EN_MEDIA_NEXT, 121},
{KEY_EN_NUMPAD_MINUS, 82},
{KEY_EN_NUMPAD_PLUS, 83},
{KEY_EN_NUMPAD_ENTER, 84}
};
/**------------------------------------------------------------------*\
@name Corsair K95 Platinum XT Keyboard
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectCorsairK95PlatinumXTControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_CorsairK95PlatinumXT::RGBController_CorsairK95PlatinumXT(CorsairK95PlatinumXTController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
vendor = "Corsair";
description = "Corsair K95 Platinum XT Keyboard Device";
type = DEVICE_TYPE_KEYBOARD;
version = controller->GetFirmwareString();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = 0;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
}
RGBController_CorsairK95PlatinumXT::~RGBController_CorsairK95PlatinumXT()
{
/*---------------------------------------------------------*\
| Delete the matrix map |
\*---------------------------------------------------------*/
for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
{
if(zones[zone_index].type == ZONE_TYPE_MATRIX)
{
delete zones[zone_index].matrix_map;
}
}
delete controller;
}
void RGBController_CorsairK95PlatinumXT::SetupZones()
{
/*---------------------------------------------------------*\
| Top bar zone setup |
\*---------------------------------------------------------*/
zone top_bar_zone;
top_bar_zone.name = "Top Bar";
top_bar_zone.type = ZONE_TYPE_LINEAR;
top_bar_zone.leds_min = K95_PLATINUM_BAR_LENGTH;
top_bar_zone.leds_max = K95_PLATINUM_BAR_LENGTH;
top_bar_zone.leds_count = K95_PLATINUM_BAR_LENGTH;
top_bar_zone.matrix_map = nullptr;
for(unsigned int i = 0; i < top_bar_zone.leds_count; i++)
{
led new_led;
new_led.name = std::get<0>(k95_platinum_xt_leds_names_and_positions[i]);
leds.push_back(new_led);
}
zones.push_back(top_bar_zone);
/*---------------------------------------------------------*\
| Keyboard zone setup |
\*---------------------------------------------------------*/
zone keyboard_zone;
keyboard_zone.name = "Keyboard";
keyboard_zone.type = ZONE_TYPE_MATRIX;
keyboard_zone.matrix_map = new matrix_map_type;
keyboard_zone.matrix_map->height = K95_PLATINUM_XT_HEIGHT;
keyboard_zone.matrix_map->width = K95_PLATINUM_XT_WIDTH;
keyboard_zone.matrix_map->map = new unsigned int[K95_PLATINUM_XT_HEIGHT * K95_PLATINUM_XT_WIDTH];
unsigned int keyboard_leds_count = 0;
for(unsigned int w = 0; w < K95_PLATINUM_XT_WIDTH; w++)
{
for(unsigned int h = 0; h < K95_PLATINUM_XT_HEIGHT; h++)
{
unsigned int key = k95_platinum_xt_matrix_map[h][w];
keyboard_zone.matrix_map->map[h * K95_PLATINUM_XT_WIDTH + w] = key;
if(key != NA)
{
led new_led;
new_led.name = std::get<0>(k95_platinum_xt_leds_names_and_positions[top_bar_zone.leds_count + keyboard_leds_count]);
leds.push_back(new_led);
keyboard_leds_count++;
}
}
}
keyboard_zone.leds_min = keyboard_leds_count;
keyboard_zone.leds_max = keyboard_leds_count;
keyboard_zone.leds_count = keyboard_leds_count;
zones.push_back(keyboard_zone);
SetupColors();
}
void RGBController_CorsairK95PlatinumXT::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_CorsairK95PlatinumXT::DeviceUpdateLEDs()
{
controller->SendDirect(colors, k95_platinum_xt_leds_names_and_positions);
}
void RGBController_CorsairK95PlatinumXT::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_CorsairK95PlatinumXT::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_CorsairK95PlatinumXT::SetCustomMode()
{
active_mode = 0;
}
void RGBController_CorsairK95PlatinumXT::DeviceUpdateMode()
{
DeviceUpdateLEDs();
}

28
Controllers/CorsairPeripheralController/RGBController_CorsairK95PlatinumXT.h Normal file
View file

@ -0,0 +1,28 @@
/*-----------------------------------------*\
| RGBController_CorsairK95PlatinumXT.h |
| |
| |
| Guimard Morgan (morg) 6/07/2022 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "CorsairK95PlatinumXTController.h"
class RGBController_CorsairK95PlatinumXT : public RGBController
{
public:
RGBController_CorsairK95PlatinumXT(CorsairK95PlatinumXTController* controller_ptr);
~RGBController_CorsairK95PlatinumXT();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void SetCustomMode();
private:
CorsairK95PlatinumXTController* controller;
};

4
OpenRGB.pro
View file

@ -306,10 +306,12 @@ HEADERS +=
Controllers/CorsairPeripheralController/CorsairK100Controller.h \
Controllers/CorsairPeripheralController/CorsairK55RGBPROController.h \
Controllers/CorsairPeripheralController/CorsairK65MiniController.h \
Controllers/CorsairPeripheralController/CorsairK95PlatinumXTController.h \
Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.h \
Controllers/CorsairPeripheralController/RGBController_CorsairK100.h \
Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPRO.h \
Controllers/CorsairPeripheralController/RGBController_CorsairK65Mini.h \
Controllers/CorsairPeripheralController/RGBController_CorsairK95PlatinumXT.h \
Controllers/CorsairVengeanceController/CorsairVengeanceController.h \
Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.h \
Controllers/CorsairVengeanceProController/CorsairVengeanceProController.h \
@ -764,10 +766,12 @@ SOURCES +=
Controllers/CorsairPeripheralController/CorsairK100Controller.cpp \
Controllers/CorsairPeripheralController/CorsairK55RGBPROController.cpp \
Controllers/CorsairPeripheralController/CorsairK65MiniController.cpp \
Controllers/CorsairPeripheralController/CorsairK95PlatinumXTController.cpp \
Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp \
Controllers/CorsairPeripheralController/RGBController_CorsairK100.cpp \
Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPRO.cpp \
Controllers/CorsairPeripheralController/RGBController_CorsairK65Mini.cpp \
Controllers/CorsairPeripheralController/RGBController_CorsairK95PlatinumXT.cpp \
Controllers/CorsairVengeanceController/CorsairVengeanceController.cpp \
Controllers/CorsairVengeanceController/CorsairVengeanceControllerDetect.cpp \
Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.cpp \