diff --git a/Controllers/RedSquareKeyroxController/RGBController_RedSquareKeyrox.cpp b/Controllers/RedSquareKeyroxController/RGBController_RedSquareKeyrox.cpp new file mode 100644 index 00000000..4d22947e --- /dev/null +++ b/Controllers/RedSquareKeyroxController/RGBController_RedSquareKeyrox.cpp @@ -0,0 +1,373 @@ +/*-------------------------------------------------------*\ +| RGBController_RedSquareKeyrox.cpp | +| | +| Driver for Red Square Keyrox USB Controller | +| Based on Keychron Controller by Guimard Morgan (morg) | +| | +| cafeed28 3 Nov 2022 | +\*-------------------------------------------------------*/ +#include "RGBControllerKeyNames.h" +#include "RGBController_RedSquareKeyrox.h" + +#define NA 0xFFFFFFFF + +/*-----------------------------------*\ +| TODO: Other Keyrox boards support | +| (but I have only TKL) | +\*-----------------------------------*/ +typedef struct +{ + const unsigned int width; /* matrix width */ + const unsigned int height; /* matrix height */ + std::vector> matrix_map; /* matrix map */ + std::vector led_names; /* led names */ + std::vector led_sequence_positions; /* position in buffers */ +} keyrox; + +/*------------*\ +| Keyrox TKL | +\*------------*/ +static keyrox keyrox_tkl = +{ + 18, + 6, + { + { 0, NA, 1, 2, 3, 4, 5, 6, 7, 8, NA, 9, 10, 11, 12, 13, 14, 15 }, + { 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, NA, 30, 31, 32 }, + { 33, NA, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49 }, + { 50, NA, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, NA, 62, NA, NA, NA }, + { 63, NA, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, NA, 74, NA, NA, 75, NA }, + { 76, 77, 78, NA, NA, NA, 79, NA, NA, NA, 80, 81, NA, 82, 83, 84, 85, 86 } + }, + { + // 0 + KEY_EN_ESCAPE, + KEY_EN_F1, + KEY_EN_F2, + KEY_EN_F3, + KEY_EN_F4, + KEY_EN_F5, + KEY_EN_F6, + KEY_EN_F7, + KEY_EN_F8, + KEY_EN_F9, + // 10 + KEY_EN_F10, + KEY_EN_F11, + KEY_EN_F12, + KEY_EN_PRINT_SCREEN, + KEY_EN_SCROLL_LOCK, + KEY_EN_PAUSE_BREAK, + KEY_EN_BACK_TICK, + KEY_EN_1, + KEY_EN_2, + KEY_EN_3, + // 20 + KEY_EN_4, + KEY_EN_5, + KEY_EN_6, + KEY_EN_7, + KEY_EN_8, + KEY_EN_9, + KEY_EN_0, + KEY_EN_MINUS, + KEY_EN_EQUALS, + KEY_EN_BACKSPACE, + // 30 + KEY_EN_INSERT, + KEY_EN_HOME, + KEY_EN_PAGE_UP, + KEY_EN_TAB, + KEY_EN_Q, + KEY_EN_W, + KEY_EN_E, + KEY_EN_R, + KEY_EN_T, + KEY_EN_Y, + // 40 + KEY_EN_U, + KEY_EN_I, + KEY_EN_O, + KEY_EN_P, + KEY_EN_LEFT_BRACKET, + KEY_EN_RIGHT_BRACKET, + KEY_EN_ANSI_BACK_SLASH, + KEY_EN_DELETE, + KEY_EN_END, + KEY_EN_PAGE_DOWN, + // 50 + KEY_EN_CAPS_LOCK, + KEY_EN_A, + KEY_EN_S, + KEY_EN_D, + KEY_EN_F, + KEY_EN_G, + KEY_EN_H, + KEY_EN_J, + KEY_EN_K, + KEY_EN_L, + // 60 + KEY_EN_SEMICOLON, + KEY_EN_QUOTE, + KEY_EN_ANSI_ENTER, + KEY_EN_LEFT_SHIFT, + KEY_EN_Z, + KEY_EN_X, + KEY_EN_C, + KEY_EN_V, + KEY_EN_B, + KEY_EN_N, + // 70 + KEY_EN_M, + KEY_EN_COMMA, + KEY_EN_PERIOD, + KEY_EN_FORWARD_SLASH, + KEY_EN_RIGHT_SHIFT, + KEY_EN_UP_ARROW, + KEY_EN_LEFT_CONTROL, + KEY_EN_LEFT_WINDOWS, + KEY_EN_LEFT_ALT, + KEY_EN_SPACE, + // 80 + KEY_EN_RIGHT_ALT, + KEY_EN_RIGHT_FUNCTION, + KEY_EN_MENU, + KEY_EN_RIGHT_CONTROL, + KEY_EN_LEFT_ARROW, + KEY_EN_DOWN_ARROW, + KEY_EN_RIGHT_ARROW, + }, + { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 70, 51, 52, 53, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 50, + 75, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 88, 89, + 94, 95, 96, 98, 100, 101, 102, 103, 104, 105, 106 + } +}; + +typedef struct +{ + std::string name; + int value; + int flags; +} keyrox_effect; + +RGBController_RedSquareKeyrox::RGBController_RedSquareKeyrox(RedSquareKeyroxController* controller_ptr) +{ + controller = controller_ptr; + + name = "Red Square Keyrox"; + vendor = "Red Square"; + type = DEVICE_TYPE_KEYBOARD; + description = name; + location = controller->GetDeviceLocation(); + serial = controller->GetSerialString(); + + keyrox_effect keyrox_effects[13] = + { + { + "Custom", + CUSTOM_MODE_VALUE, + MODE_FLAG_HAS_PER_LED_COLOR + }, + { + "Wave", + WAVE_MODE_VALUE, + MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD + }, + { + "Const", + CONST_MODE_VALUE, + MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS + }, + { + "Breathe", + BREATHE_MODE_VALUE, + MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED + }, + { + "Heartrate", + HEARTRATE_MODE_VALUE, + MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED + }, + { + "Point", + POINT_MODE_VALUE, + MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED + }, + { + "Winnower", + WINNOWER_MODE_VALUE, + MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD + }, + { + "Stars", + STARS_MODE_VALUE, + MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED + }, + { + "Spectrum", + SPECTRUM_MODE_VALUE, + MODE_FLAG_HAS_SPEED + }, + { + "Plumflower", + PLUMFLOWER_MODE_VALUE, + MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED + }, + { + "Shoot", + SHOOT_MODE_VALUE, + MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED + }, + { + "Ambilight Rotate", + AMBILIGHT_ROTATE_MODE_VALUE, + MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD + }, + { + "Ripple", + RIPPLE_MODE_VALUE, + MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED + }, + }; + + for(const keyrox_effect& effect : keyrox_effects) + { + mode m; + m.name = effect.name; + m.value = effect.value; + m.flags = effect.flags | MODE_FLAG_HAS_BRIGHTNESS; + + if(m.flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR) + { + m.color_mode = MODE_COLORS_MODE_SPECIFIC; + m.colors_min = 1; + m.colors_max = 1; + + m.colors.resize(1); + m.colors.at(0) = ToRGBColor(255, 255, 255); + } + else if(m.flags & MODE_FLAG_HAS_PER_LED_COLOR) + { + m.color_mode = MODE_COLORS_PER_LED; + } + else + { + m.color_mode = MODE_COLORS_NONE; + m.colors_min = 0; + m.colors_max = 0; + m.colors.resize(0); + } + + if(m.flags & MODE_FLAG_HAS_SPEED) + { + m.speed_min = KEYROX_SPEED_MIN; + m.speed_max = KEYROX_SPEED_MAX; + m.speed = m.speed_max; + } + + if(m.flags & MODE_FLAG_HAS_BRIGHTNESS) + { + m.brightness_min = KEYROX_BRIGHTNESS_MIN; + /*------------------------------------------*\ + | In Custom mode, Keyrox stores brightness | + | in A of RGBA and range is 0x00-0xFF | + \*------------------------------------------*/ + m.brightness_max = (m.flags & MODE_FLAG_HAS_PER_LED_COLOR) ? 0xFF : KEYROX_BRIGHTNESS_MAX; + m.brightness = m.brightness_max; + } + + modes.push_back(m); + } + + SetupZones(); +} + +RGBController_RedSquareKeyrox::~RGBController_RedSquareKeyrox() +{ + delete controller; +} + +void RGBController_RedSquareKeyrox::SetupZones() +{ + keyrox* keyboard; + switch(controller->GetVariant()) + { + case KEYROX_VARIANT_TKL: + keyboard = &keyrox_tkl; + break; + } + + controller->SetLedSequencePositions(keyboard->led_sequence_positions); + + /*-----------------*\ + | Create the zone | + \*-----------------*/ + unsigned int zone_size = 0; + + zone z; + z.name = ZONE_EN_KEYBOARD; + z.type = ZONE_TYPE_MATRIX; + + z.matrix_map = new matrix_map_type; + z.matrix_map->height = keyboard->height; + z.matrix_map->width = keyboard->width; + + z.matrix_map->map = new unsigned int[keyboard->height * keyboard->width]; + + for(unsigned int h = 0; h < keyboard->height; h++) + { + for(unsigned int w = 0; w < keyboard->width; w++) + { + unsigned int key = keyboard->matrix_map[h][w]; + z.matrix_map->map[h * keyboard->width + w] = key; + + if(key != NA) + { + led l; + l.name = keyboard->led_names[key]; + leds.push_back(l); + zone_size++; + } + } + } + + z.leds_min = zone_size; + z.leds_max = zone_size; + z.leds_count = zone_size; + + zones.push_back(z); + + SetupColors(); +} + +void RGBController_RedSquareKeyrox::ResizeZone(int /*zone*/, int /*new_size*/) +{ + /*---------------------------------------------------------*\ + | This device does not support resizing zones | + \*---------------------------------------------------------*/ +} + +void RGBController_RedSquareKeyrox::DeviceUpdateLEDs() +{ + controller->SetLEDsData(modes, active_mode, colors); +} + +void RGBController_RedSquareKeyrox::UpdateZoneLEDs(int /*zone*/) +{ + DeviceUpdateLEDs(); +} + +void RGBController_RedSquareKeyrox::UpdateSingleLED(int /*led*/) +{ + DeviceUpdateLEDs(); +} + +void RGBController_RedSquareKeyrox::DeviceUpdateMode() +{ + controller->SetMode(modes, active_mode); + controller->SetModeData(modes, active_mode); +} diff --git a/Controllers/RedSquareKeyroxController/RGBController_RedSquareKeyrox.h b/Controllers/RedSquareKeyroxController/RGBController_RedSquareKeyrox.h new file mode 100644 index 00000000..428ecc3a --- /dev/null +++ b/Controllers/RedSquareKeyroxController/RGBController_RedSquareKeyrox.h @@ -0,0 +1,30 @@ +/*---------------------------------------------*\ +| RGBController_RedSquareKeyrox.h | +| | +| Driver for Red Square Keyrox USB Controller | +| | +| cafeed28 3 Nov 2022 | +\*---------------------------------------------*/ + +#pragma once +#include "RGBController.h" +#include "RedSquareKeyroxController.h" + +class RGBController_RedSquareKeyrox : public RGBController +{ +public: + RGBController_RedSquareKeyrox(RedSquareKeyroxController* controller_ptr); + ~RGBController_RedSquareKeyrox(); + + void SetupZones(); + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void DeviceUpdateMode(); + +private: + RedSquareKeyroxController* controller; +}; diff --git a/Controllers/RedSquareKeyroxController/RedSquareKeyroxController.cpp b/Controllers/RedSquareKeyroxController/RedSquareKeyroxController.cpp new file mode 100644 index 00000000..165e5e71 --- /dev/null +++ b/Controllers/RedSquareKeyroxController/RedSquareKeyroxController.cpp @@ -0,0 +1,208 @@ +/*---------------------------------------------*\ +| RedSquareKeyroxController.cpp | +| | +| Driver for Red Square Keyrox USB Controller | +| | +| cafeed28 3 Nov 2022 | +\*---------------------------------------------*/ + +#include "LogManager.h" +#include "RedSquareKeyroxController.h" + +#include + +using namespace std::chrono_literals; + +RedSquareKeyroxController::RedSquareKeyroxController(hid_device *dev_handle, const hid_device_info &info, int variant) +{ + dev = dev_handle; + location = info.path; + this->variant = variant; +} + +RedSquareKeyroxController::~RedSquareKeyroxController() +{ + hid_close(dev); +} + +int RedSquareKeyroxController::GetVariant() +{ + return variant; +} + +std::string RedSquareKeyroxController::GetDeviceLocation() +{ + return("HID: " + location); +} + +std::string RedSquareKeyroxController::GetSerialString() +{ + wchar_t serial_wchar[128]; + hid_get_serial_number_string(dev, serial_wchar, 128); + std::wstring serial_wstring(serial_wchar); + + std::string serial_string; + std::transform(serial_wstring.begin(), serial_wstring.end(), std::back_inserter(serial_string), [] (wchar_t i) + { + return (char)i; + }); + + return serial_string; +} + +int RedSquareKeyroxController::GetDirectionLRUD(int direction) +{ + switch(direction) + { + case MODE_DIRECTION_LEFT: + return 0x10; + case MODE_DIRECTION_RIGHT: + return 0x00; + case MODE_DIRECTION_UP: + return 0x20; + case MODE_DIRECTION_DOWN: + return 0x30; + default: + return 0x00; + } +} + +int RedSquareKeyroxController::GetDirectionUD(int direction) +{ + switch(direction) + { + case MODE_DIRECTION_UP: + return 0xA0; + case MODE_DIRECTION_DOWN: + return 0xB0; + default: + return 0xA0; + } +} + +void RedSquareKeyroxController::SetLedSequencePositions(std::vector positions) +{ + led_sequence_positions = positions; +} + +void RedSquareKeyroxController::SetMode(std::vector modes, int active_mode) +{ + /*---------------------------------------------*\ + | Mode set command | + \*---------------------------------------------*/ + mode m = modes[active_mode]; + + unsigned char usb_buf[PACKET_DATA_LENGTH]; + memset(usb_buf, 0x00, PACKET_DATA_LENGTH); + + usb_buf[4] = 0x01; + usb_buf[6] = 0x04; + usb_buf[8] = m.value; + + Send(usb_buf); +} + +void RedSquareKeyroxController::SetModeData(std::vector modes, int active_mode) +{ + /*---------------------------------------------*\ + | Mode specific data set command | + \*---------------------------------------------*/ + mode m = modes[active_mode]; + + if(m.value == CUSTOM_MODE_VALUE) + { + return; + } + + unsigned char usb_buf[PACKET_DATA_LENGTH]; + memset(usb_buf, 0x00, PACKET_DATA_LENGTH); + + usb_buf[4] = 0x09; + usb_buf[6] = 0x05; + usb_buf[7] = m.value; + usb_buf[8] = m.brightness; + usb_buf[9] = 0xFF; + + if(m.flags & MODE_FLAG_HAS_SPEED) + { + usb_buf[10] = m.speed; + usb_buf[11] = 0xFF; + + if(m.value == SPECTRUM_MODE_VALUE) + { + usb_buf[10] += 0x80; + } + } + + if(m.flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR) + { + if(m.flags & MODE_FLAG_HAS_RANDOM_COLOR && m.color_mode == MODE_COLORS_RANDOM) + { + usb_buf[10] += 0x80; + } + else + { + usb_buf[11] = RGBGetRValue(m.colors[0]); + usb_buf[12] = RGBGetGValue(m.colors[0]); + usb_buf[13] = RGBGetBValue(m.colors[0]); + } + } + + if((m.flags & MODE_FLAG_HAS_DIRECTION_LR) && (m.flags & MODE_FLAG_HAS_DIRECTION_UD)) + { + usb_buf[10] += GetDirectionLRUD(m.direction); + } + else if((m.flags & MODE_FLAG_HAS_DIRECTION_UD) && !(m.flags & MODE_FLAG_HAS_DIRECTION_LR)) + { + usb_buf[10] += GetDirectionUD(m.direction); + } + + Send(usb_buf); +} + +void RedSquareKeyroxController::SetLEDsData(std::vector modes, int active_mode, std::vector colors) +{ + /*---------------------------------------------*\ + | LEDs data set command | + \*---------------------------------------------*/ + mode m = modes[active_mode]; + + if(m.value != CUSTOM_MODE_VALUE) + { + return; + } + + unsigned char usb_buf[PACKET_DATA_LENGTH]; + memset(usb_buf, 0x00, PACKET_DATA_LENGTH); + + usb_buf[4] = 0xB0; + usb_buf[5] = 0x01; + usb_buf[6] = 0x07; + + for(unsigned int i = 0; i < colors.size(); i++) + { + int offset = 7 + led_sequence_positions[i] * 4; + usb_buf[offset + 1] = RGBGetRValue(colors[i]); + usb_buf[offset + 2] = RGBGetGValue(colors[i]); + usb_buf[offset + 3] = RGBGetBValue(colors[i]); + usb_buf[offset + 4] = m.brightness; + } + + Send(usb_buf); +} + +void RedSquareKeyroxController::Send(unsigned char data[PACKET_DATA_LENGTH]) +{ + unsigned char usb_buf[PACKET_DATA_LENGTH + 1]; + + usb_buf[0] = 0x00; // Report ID + + for(int x = 0; x < PACKET_DATA_LENGTH; x++) + { + usb_buf[x + 1] = data[x]; + } + + hid_send_feature_report(dev, usb_buf, PACKET_DATA_LENGTH + 1); + + std::this_thread::sleep_for(10ms); +} diff --git a/Controllers/RedSquareKeyroxController/RedSquareKeyroxController.h b/Controllers/RedSquareKeyroxController/RedSquareKeyroxController.h new file mode 100644 index 00000000..b88ca22e --- /dev/null +++ b/Controllers/RedSquareKeyroxController/RedSquareKeyroxController.h @@ -0,0 +1,85 @@ +/*---------------------------------------------*\ +| RedSquareKeyroxController.h | +| | +| Driver for Red Square Keyrox USB Controller | +| | +| cafeed28 3 Nov 2022 | +\*---------------------------------------------*/ + +#pragma once +#include +#include + +#include "RGBController.h" + +#define PACKET_DATA_LENGTH 520 + +/*-----------------------------*\ +| Red Square Keyrox variants | +\*-----------------------------*/ +enum +{ + KEYROX_VARIANT_TKL, +}; + +/*---------------------------------------*\ +| Modes | +\*---------------------------------------*/ +enum +{ + WAVE_MODE_VALUE = 0x00, + CONST_MODE_VALUE = 0x01, + BREATHE_MODE_VALUE = 0x02, + HEARTRATE_MODE_VALUE = 0x03, + POINT_MODE_VALUE = 0x04, + WINNOWER_MODE_VALUE = 0x05, + STARS_MODE_VALUE = 0x06, + SPECTRUM_MODE_VALUE = 0x07, + PLUMFLOWER_MODE_VALUE = 0x08, + SHOOT_MODE_VALUE = 0x09, + AMBILIGHT_ROTATE_MODE_VALUE = 0x0A, + RIPPLE_MODE_VALUE = 0x0B, + CUSTOM_MODE_VALUE = 0x0C, +}; + +/*-----------------------------*\ +| Other settings | +\*-----------------------------*/ +enum +{ + KEYROX_BRIGHTNESS_MIN = 0x00, + KEYROX_BRIGHTNESS_MAX = 0x7F, + KEYROX_SPEED_MIN = 0x00, + KEYROX_SPEED_MAX = 0x04, +}; + + +class RedSquareKeyroxController +{ +public: + RedSquareKeyroxController(hid_device *dev_handle, const hid_device_info &info, int variant); + ~RedSquareKeyroxController(); + + int GetVariant(); + std::string GetDeviceLocation(); + std::string GetSerialString(); + + int GetDirectionLRUD(int direction); // Direction for Left-Right-Up-Down modes + int GetDirectionUD(int direction); // Direction for Up-Down modes + + void SetLedSequencePositions(std::vector positions); + void SetMode(std::vector modes, int active_mode); + void SetModeData(std::vector modes, int active_mode); + void SetLEDsData(std::vector modes, int active_mode, std::vector colors); + + void Send(unsigned char data[PACKET_DATA_LENGTH]); + +protected: + hid_device* dev; + +private: + int variant; + std::string location; + std::string serial_number; + std::vector led_sequence_positions; +}; diff --git a/Controllers/RedSquareKeyroxController/RedSquareKeyroxControllerDetect.cpp b/Controllers/RedSquareKeyroxController/RedSquareKeyroxControllerDetect.cpp new file mode 100644 index 00000000..b69ddc0a --- /dev/null +++ b/Controllers/RedSquareKeyroxController/RedSquareKeyroxControllerDetect.cpp @@ -0,0 +1,31 @@ +#include "Detector.h" +#include "RedSquareKeyroxController.h" +#include "RGBController.h" +#include "RGBController_RedSquareKeyrox.h" +#include + +/*-----------------------------------------------------*\ +| Red Square vendor ID | +\*-----------------------------------------------------*/ +#define RED_SQUARE_VID 0x1A2C + +/*-----------------------------------------------------*\ +| Red Square Keyrox TKL product ID | +\*-----------------------------------------------------*/ +#define RED_SQUARE_KEYROX_TKL_PID 0x1511 + +void DetectRedSquareKeyroxTKL(hid_device_info* info, const std::string& name) +{ + hid_device* dev = hid_open_path(info->path); + + if(dev) + { + RedSquareKeyroxController* controller = new RedSquareKeyroxController(dev, *info, KEYROX_VARIANT_TKL); + RGBController_RedSquareKeyrox* rgb_controller = new RGBController_RedSquareKeyrox(controller); + rgb_controller->name = name; + + ResourceManager::get()->RegisterRGBController(rgb_controller); + } +} + +REGISTER_HID_DETECTOR_IPU("Red Square Keyrox TKL", DetectRedSquareKeyroxTKL, RED_SQUARE_VID, RED_SQUARE_KEYROX_TKL_PID, 3, 0xFF00, 2); diff --git a/OpenRGB.pro b/OpenRGB.pro index d2dd721f..1dc088c4 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -154,6 +154,7 @@ INCLUDEPATH += Controllers/QMKOpenRGBController/ \ Controllers/RazerController/ \ Controllers/RedragonController/ \ + Controllers/RedSquareKeyroxController/ \ Controllers/RoccatController/ \ Controllers/SapphireGPUController/ \ Controllers/SinowealthController/ \ @@ -546,6 +547,8 @@ HEADERS += Controllers/RazerController/RGBController_RazerKraken.h \ Controllers/RedragonController/RedragonM711Controller.h \ Controllers/RedragonController/RGBController_RedragonM711.h \ + Controllers/RedSquareKeyroxController/RedSquareKeyroxController.h \ + Controllers/RedSquareKeyroxController/RGBController_RedSquareKeyrox.h \ Controllers/RoccatController/RGBController_RoccatBurst.h \ Controllers/RoccatController/RGBController_RoccatHordeAimo.h \ Controllers/RoccatController/RGBController_RoccatKoneAimo.h \ @@ -1122,6 +1125,9 @@ SOURCES += Controllers/RedragonController/RedragonM711Controller.cpp \ Controllers/RedragonController/RedragonControllerDetect.cpp \ Controllers/RedragonController/RGBController_RedragonM711.cpp \ + Controllers/RedSquareKeyroxController/RedSquareKeyroxController.cpp \ + Controllers/RedSquareKeyroxController/RedSquareKeyroxControllerDetect.cpp \ + Controllers/RedSquareKeyroxController/RGBController_RedSquareKeyrox.cpp \ Controllers/RoccatController/RGBController_RoccatBurst.cpp \ Controllers/RoccatController/RGBController_RoccatHordeAimo.cpp \ Controllers/RoccatController/RGBController_RoccatKoneAimo.cpp \