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

Publish LumaOps source

Browse Source
This commit is contained in:
LumaOps release export
2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Controllers/WootingKeyboardController/RGBController_WootingKeyboard.cpp
+778
View File
@@ -0,0 +1,778 @@
/*---------------------------------------------------------*\
| RGBController_WootingKeyboard.cpp |
| |
| RGBController for Wooting keyboard |
| |
| Diogo Trindade (diogotr7) 25 Dec 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBControllerKeyNames.h"
#include "RGBController_WootingKeyboard.h"
#include "LogManager.h"
//TODO: These matrix maps have indices to the 6x21 full layout.
// This is incorrect. The values in the matrix map should be indices to the `leds` vector.
// the Value property in each LED is what should map to the index in the full 6x21 layout.
//0xFFFFFFFF indicates an unused entry in matrix
#define NA 0xFFFFFFFF
static unsigned int matrix_map_full[6][21] = {
{ 0, NA, 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, 33, 34, 35, 36, 37, 38, 39, 40, 41 },
{ 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62 },
{ 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, NA, NA, NA, 80, 81, 82, NA },
{ 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, NA, 97, NA, 99, NA, 101, 102, 103, 104 },
{ 105, 106, 107, NA, NA, NA, 111, NA, NA, NA, 115, 116, 117, 118, 119, 120, 121, NA, 123, 124, NA }
};
static const char *led_names_full[6][21] {
//Row 0
{
KEY_EN_ESCAPE,
KEY_EN_UNUSED,
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,
KEY_EN_F10,
KEY_EN_F11,
KEY_EN_F12,
KEY_EN_PRINT_SCREEN,
KEY_EN_PAUSE_BREAK,
KEY_EN_SCROLL_LOCK,
"Key: Custom1",
"Key: Custom2",
"Key: Custom3",
"Key: Mode",
},
//row 1
{
KEY_EN_BACK_TICK,
KEY_EN_1,
KEY_EN_2,
KEY_EN_3,
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_PLUS,
KEY_EN_BACKSPACE,
KEY_EN_INSERT,
KEY_EN_HOME,
KEY_EN_PAGE_UP,
KEY_EN_NUMPAD_LOCK,
KEY_EN_NUMPAD_DIVIDE,
KEY_EN_NUMPAD_TIMES,
KEY_EN_NUMPAD_MINUS,
},
//row 2
{
KEY_EN_TAB,
KEY_EN_Q,
KEY_EN_W,
KEY_EN_E,
KEY_EN_R,
KEY_EN_T,
KEY_EN_Y,
KEY_EN_U,
KEY_EN_I,
KEY_EN_O,
KEY_EN_P,
KEY_EN_LEFT_BRACKET,
KEY_EN_RIGHT_BRACKET,
KEY_EN_BACK_SLASH,
KEY_EN_DELETE,
KEY_EN_END,
KEY_EN_PAGE_DOWN,
KEY_EN_NUMPAD_7,
KEY_EN_NUMPAD_8,
KEY_EN_NUMPAD_9,
KEY_EN_NUMPAD_PLUS,
},
//row 3
{
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,
KEY_EN_SEMICOLON,
KEY_EN_QUOTE,
KEY_EN_POUND,
KEY_EN_ANSI_ENTER,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_NUMPAD_4,
KEY_EN_NUMPAD_5,
KEY_EN_NUMPAD_6,
KEY_EN_UNUSED,
},
//row 4
{
KEY_EN_LEFT_SHIFT,
KEY_EN_ISO_BACK_SLASH,
KEY_EN_Z,
KEY_EN_X,
KEY_EN_C,
KEY_EN_V,
KEY_EN_B,
KEY_EN_N,
KEY_EN_M,
KEY_EN_COMMA,
KEY_EN_PERIOD,
KEY_EN_FORWARD_SLASH,
KEY_EN_UNUSED,
KEY_EN_RIGHT_SHIFT,
KEY_EN_UNUSED,
KEY_EN_UP_ARROW,
KEY_EN_UNUSED,
KEY_EN_NUMPAD_1,
KEY_EN_NUMPAD_2,
KEY_EN_NUMPAD_3,
KEY_EN_NUMPAD_ENTER,
},
//row 5
{
KEY_EN_LEFT_CONTROL,
KEY_EN_LEFT_WINDOWS,
KEY_EN_LEFT_ALT,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_SPACE,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_RIGHT_ALT,
KEY_EN_RIGHT_WINDOWS,
KEY_EN_RIGHT_FUNCTION,
KEY_EN_RIGHT_CONTROL,
KEY_EN_LEFT_ARROW,
KEY_EN_DOWN_ARROW,
KEY_EN_RIGHT_ARROW,
KEY_EN_UNUSED,
KEY_EN_NUMPAD_0,
KEY_EN_NUMPAD_PERIOD,
KEY_EN_UNUSED,
}
};
static unsigned int matrix_map_tkl[6][17] = {
{ 0, NA, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
{ 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37 },
{ 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58 },
{ 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, NA, NA, NA },
{ 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, NA, 97, NA, 99, NA },
{ 105, 106, 107, NA, NA, NA, 111, NA, NA, NA, 115, 116, 117, 118, 119, 120, 121 }
};
static const char *led_names_tkl[6][17] {
//Row 0
{
KEY_EN_ESCAPE,
KEY_EN_UNUSED,
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,
KEY_EN_F10,
KEY_EN_F11,
KEY_EN_F12,
KEY_EN_PRINT_SCREEN,
KEY_EN_PAUSE_BREAK,
"Key: Custom1",
},
//row 1
{
KEY_EN_BACK_TICK,
KEY_EN_1,
KEY_EN_2,
KEY_EN_3,
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_PLUS,
KEY_EN_BACKSPACE,
KEY_EN_INSERT,
KEY_EN_HOME,
KEY_EN_PAGE_UP,
},
//row 2
{
KEY_EN_TAB,
KEY_EN_Q,
KEY_EN_W,
KEY_EN_E,
KEY_EN_R,
KEY_EN_T,
KEY_EN_Y,
KEY_EN_U,
KEY_EN_I,
KEY_EN_O,
KEY_EN_P,
KEY_EN_LEFT_BRACKET,
KEY_EN_RIGHT_BRACKET,
KEY_EN_BACK_SLASH,
KEY_EN_DELETE,
KEY_EN_END,
KEY_EN_PAGE_DOWN,
},
//row 3
{
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,
KEY_EN_SEMICOLON,
KEY_EN_QUOTE,
KEY_EN_POUND,
KEY_EN_ANSI_ENTER,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
},
//row 4
{
KEY_EN_LEFT_SHIFT,
KEY_EN_ISO_BACK_SLASH,
KEY_EN_Z,
KEY_EN_X,
KEY_EN_C,
KEY_EN_V,
KEY_EN_B,
KEY_EN_N,
KEY_EN_M,
KEY_EN_COMMA,
KEY_EN_PERIOD,
KEY_EN_FORWARD_SLASH,
KEY_EN_UNUSED,
KEY_EN_RIGHT_SHIFT,
KEY_EN_UNUSED,
KEY_EN_UP_ARROW,
KEY_EN_UNUSED,
},
//row 5
{
KEY_EN_LEFT_CONTROL,
KEY_EN_LEFT_WINDOWS,
KEY_EN_LEFT_ALT,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_SPACE,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_RIGHT_ALT,
KEY_EN_RIGHT_WINDOWS,
KEY_EN_RIGHT_FUNCTION,
KEY_EN_RIGHT_CONTROL,
KEY_EN_LEFT_ARROW,
KEY_EN_DOWN_ARROW,
KEY_EN_RIGHT_ARROW,
}
};
static unsigned int matrix_map_80HE[6][17] = {
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, NA, 10, 11, 12, 13, 14, 15, 16 },
{ 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37 },
{ 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, NA, 56, 57, 58 },
{ 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, NA, 77, NA, NA },
{ 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, NA, 97, 98, 99, NA },
{ 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, NA, 119, 120, 121 }
};
static const char *led_names_80HE[6][17] {
//Row 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_UNUSED,
KEY_EN_F9,
KEY_EN_F10,
KEY_EN_F11,
KEY_EN_F12,
"Key: Mode",
KEY_EN_PRINT_SCREEN,
KEY_EN_PAUSE_BREAK,
},
//row 1
{
KEY_EN_BACK_TICK,
KEY_EN_1,
KEY_EN_2,
KEY_EN_3,
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_PLUS,
"Key: JIS Specific TODO",
KEY_EN_BACKSPACE,
KEY_EN_INSERT,
KEY_EN_HOME,
},
//row 2
{
KEY_EN_TAB,
KEY_EN_Q,
KEY_EN_W,
KEY_EN_E,
KEY_EN_R,
KEY_EN_T,
KEY_EN_Y,
KEY_EN_U,
KEY_EN_I,
KEY_EN_O,
KEY_EN_P,
KEY_EN_LEFT_BRACKET,
KEY_EN_RIGHT_BRACKET,
KEY_EN_UNUSED,
KEY_EN_BACK_SLASH,
KEY_EN_DELETE,
KEY_EN_END,
},
//row 3
{
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,
KEY_EN_SEMICOLON,
KEY_EN_QUOTE,
KEY_EN_POUND,
KEY_EN_UNUSED,
KEY_EN_ANSI_ENTER,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
},
//row 4
{
KEY_EN_LEFT_SHIFT,
KEY_EN_ISO_BACK_SLASH,
KEY_EN_Z,
KEY_EN_X,
KEY_EN_C,
KEY_EN_V,
KEY_EN_B,
KEY_EN_N,
KEY_EN_M,
KEY_EN_COMMA,
KEY_EN_PERIOD,
KEY_EN_FORWARD_SLASH,
KEY_EN_UNUSED,
"Key: JIS Specific TODO",
KEY_EN_RIGHT_SHIFT,
KEY_EN_UP_ARROW,
KEY_EN_UNUSED,
},
//row 5
{
KEY_EN_LEFT_CONTROL,
KEY_EN_LEFT_WINDOWS,
KEY_EN_LEFT_ALT,
"Key: JIS Specific TODO",
"Spacebar LED 1",
"Spacebar LED 2",
KEY_EN_SPACE,
"Spacebar LED 3",
"Spacebar LED 4",
"Key: JIS Specific TODO",
KEY_EN_RIGHT_ALT,
KEY_EN_RIGHT_WINDOWS,
KEY_EN_RIGHT_FUNCTION,
KEY_EN_UNUSED,
KEY_EN_LEFT_ARROW,
KEY_EN_DOWN_ARROW,
KEY_EN_RIGHT_ARROW,
}
};
static unsigned int matrix_map_60[5][14] = {
{ 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34 },
{ 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55 },
{ 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76 },
{ 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, NA, 97 },
{ 105, 106, 107, NA, 109, 110, 111, 112, 113, NA, 115, 116, 117, 118 }
};
static const char *led_names_60HE[5][14] {
//row 0
{
KEY_EN_ESCAPE,
KEY_EN_1,
KEY_EN_2,
KEY_EN_3,
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_PLUS,
KEY_EN_BACKSPACE,
},
//row 1
{
KEY_EN_TAB,
KEY_EN_Q,
KEY_EN_W,
KEY_EN_E,
KEY_EN_R,
KEY_EN_T,
KEY_EN_Y,
KEY_EN_U,
KEY_EN_I,
KEY_EN_O,
KEY_EN_P,
KEY_EN_LEFT_BRACKET,
KEY_EN_RIGHT_BRACKET,
KEY_EN_BACK_SLASH,
},
//row 2
{
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,
KEY_EN_SEMICOLON,
KEY_EN_QUOTE,
KEY_EN_POUND,
KEY_EN_ANSI_ENTER,
},
//row 3
{
KEY_EN_LEFT_SHIFT,
KEY_EN_ISO_BACK_SLASH,
KEY_EN_Z,
KEY_EN_X,
KEY_EN_C,
KEY_EN_V,
KEY_EN_B,
KEY_EN_N,
KEY_EN_M,
KEY_EN_COMMA,
KEY_EN_PERIOD,
KEY_EN_FORWARD_SLASH,
KEY_EN_UNUSED,
KEY_EN_RIGHT_SHIFT,
},
//row 4
{
KEY_EN_LEFT_CONTROL,
KEY_EN_LEFT_WINDOWS,
KEY_EN_LEFT_ALT,
KEY_EN_UNUSED,
"Spacebar LED 1",
"Spacebar LED 2",
KEY_EN_SPACE,
"Spacebar LED 3",
"Spacebar LED 4",
KEY_EN_UNUSED,
KEY_EN_RIGHT_ALT,
KEY_EN_MENU,
KEY_EN_RIGHT_CONTROL,
KEY_EN_RIGHT_FUNCTION,
}
};
static unsigned int matrix_map_3pad[5][7] = {
{ 0, NA, 2, NA, 4, NA, 6 },
{ 21, NA, NA, NA, NA, NA, 27 },
{ 42, 43, NA, 45, NA, 47, 48 },
{ 63, NA, NA, NA, NA, NA, 69 },
{ NA, 85, 86, NA, 88, 89, NA }
};
static const char *led_names_3pad[5][7] {
//row 0
{
//top, right to left
"Lightbar 14",
KEY_EN_UNUSED,
"Lightbar 13",
KEY_EN_UNUSED,
"Lightbar 12",
KEY_EN_UNUSED,
"Lightbar 11",
},
//row 1
{
"Lighbar 1", //left side, top led
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
"Lightbar 10",//right side, top led
},
//row 2
{
"Lightbar 2",//left side, middle led
"Keypad 1",
KEY_EN_UNUSED,
"Keypad 2",
KEY_EN_UNUSED,
"Keypad 3",
"Lightbar 9",//right side, middle led
},
//row 3
{
"Lightbar 3",//left side, bottom led
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
KEY_EN_UNUSED,
"Lightbar 8",//right side, bottom led
},
//row 4
{
//bottom leds, left to right
KEY_EN_UNUSED,
"Lightbar 4",
"Lightbar 5",
KEY_EN_UNUSED,
"Lightbar 6",
"Lightbar 7",
KEY_EN_UNUSED,
}
};
/**------------------------------------------------------------------*\
@name Wooting Keyboards
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectWootingV1KeyboardControllers,DetectWootingV2KeyboardControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_WootingKeyboard::RGBController_WootingKeyboard(WootingKeyboardController* controller_ptr)
{
controller = controller_ptr;
LOG_DEBUG("%sAdding meta data", WOOTING_CONTROLLER_NAME);
name = controller->GetName();
vendor = controller->GetVendor();
type = DEVICE_TYPE_KEYBOARD;
description = controller->GetDescription();
location = controller->GetLocation();
serial = controller->GetSerial();
LOG_DEBUG("%sAdding modes", WOOTING_CONTROLLER_NAME);
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);
SetupZones();
}
RGBController_WootingKeyboard::~RGBController_WootingKeyboard()
{
/*---------------------------------------------------------*\
| Delete the matrix map |
\*---------------------------------------------------------*/
for (unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
{
if (zones[zone_index].matrix_map != NULL)
{
delete zones[zone_index].matrix_map;
}
}
delete controller;
}
void RGBController_WootingKeyboard::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
WOOTING_DEVICE_TYPE wooting_type = controller->GetWootingType();
const char** led_names = nullptr;
unsigned int* matrix_map = nullptr;
size_t matrix_rows = 0;
size_t matrix_columns = 0;
if(wooting_type == WOOTING_KB_TKL)
{
matrix_map = (unsigned int *)matrix_map_tkl;
led_names = (const char **)led_names_tkl;
matrix_rows = 6;
matrix_columns = 17;
}
else if(wooting_type == WOOTING_KB_80PER)
{
matrix_map = (unsigned int *)matrix_map_80HE;
led_names = (const char **)led_names_80HE;
matrix_rows = 6;
matrix_columns = 17;
}
else if(wooting_type == WOOTING_KB_60PER)
{
matrix_map = (unsigned int *)matrix_map_60;
led_names = (const char **)led_names_60HE;
matrix_rows = 5;
matrix_columns = 14;
}
else if(wooting_type == WOOTING_KB_3PAD)
{
matrix_map = (unsigned int *)matrix_map_3pad;
led_names = (const char **)led_names_3pad;
matrix_rows = 5;
matrix_columns = 7;
}
else // Fullsize and default
{
matrix_map = (unsigned int *)matrix_map_full;
led_names = (const char **)led_names_full;
matrix_rows = 6;
matrix_columns = 21;
}
unsigned int* new_matrix = new unsigned int[matrix_rows * matrix_columns];
unsigned int total_led_count = 0;
for(size_t row = 0; row < matrix_rows; row++)
{
for(size_t col = 0; col < matrix_columns; col++)
{
size_t idx = row * matrix_columns + col;
unsigned int hardware_index = matrix_map[idx];
if(hardware_index == NA)
{
new_matrix[idx] = NA;
continue;
}
led new_led;
new_led.name = led_names[idx];
new_led.value = hardware_index;
leds.push_back(new_led);
// 3. The zone map now points to the LED's position in the vector
new_matrix[idx] = total_led_count;
total_led_count++;
}
}
zone new_zone;
new_zone.name = name.append(" zone");
new_zone.type = ZONE_TYPE_MATRIX;
new_zone.leds_min = total_led_count;
new_zone.leds_max = total_led_count;
new_zone.leds_count = total_led_count;
new_zone.matrix_map = new matrix_map_type;
new_zone.matrix_map->height = (unsigned int)matrix_rows;
new_zone.matrix_map->width = (unsigned int)matrix_columns;
new_zone.matrix_map->map = new_matrix;
zones.push_back(new_zone);
SetupColors();
}
void RGBController_WootingKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_WootingKeyboard::DeviceUpdateLEDs()
{
RGBColor framebuffer[WOOTING_RGB_ROWS * WOOTING_RGB_COLUMNS] = {0};
for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
{
unsigned int framebuffer_index = leds[led_idx].value;
framebuffer[framebuffer_index] = colors[led_idx];
}
controller->SendDirect(&framebuffer[0], WOOTING_RGB_ROWS * WOOTING_RGB_COLUMNS);
}
void RGBController_WootingKeyboard::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_WootingKeyboard::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_WootingKeyboard::DeviceUpdateMode()
{
}
Controllers/WootingKeyboardController/RGBController_WootingKeyboard.h
+34
View File
@@ -0,0 +1,34 @@
/*---------------------------------------------------------*\
| RGBController_WootingKeyboard.h |
| |
| RGBController for Wooting keyboard |
| |
| Diogo Trindade (diogotr7) 25 Dec 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "WootingKeyboardController.h"
class RGBController_WootingKeyboard : public RGBController
{
public:
RGBController_WootingKeyboard(WootingKeyboardController* controller_ptr);
~RGBController_WootingKeyboard();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
WootingKeyboardController* controller;
};
Controllers/WootingKeyboardController/WootingKeyboardController.cpp
+90
View File
@@ -0,0 +1,90 @@
/*---------------------------------------------------------*\
| WootingKeyboardController.cpp |
| |
| Driver for Wooting keyboard |
| |
| Chris M (Dr_No) 09 Jul 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "StringUtils.h"
#include "WootingKeyboardController.h"
WootingKeyboardController::WootingKeyboardController()
{
}
WootingKeyboardController::~WootingKeyboardController()
{
}
std::string WootingKeyboardController::GetName()
{
return name;
}
std::string WootingKeyboardController::GetVendor()
{
return vendor;
}
std::string WootingKeyboardController::GetLocation()
{
return("HID: " + location);
}
std::string WootingKeyboardController::GetDescription()
{
return description;
}
std::string WootingKeyboardController::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
WOOTING_DEVICE_TYPE WootingKeyboardController::GetWootingType()
{
return wooting_type;
}
void WootingKeyboardController::SendInitialize()
{
wooting_usb_send_feature(WOOTING_COLOR_INIT_COMMAND, 0,0,0,0);
std::this_thread::sleep_for(std::chrono::milliseconds(50));
}
bool WootingKeyboardController::wooting_usb_send_feature(uint8_t commandId, uint8_t parameter0, uint8_t parameter1, uint8_t parameter2, uint8_t parameter3)
{
uint8_t feature_buffer[WOOTING_COMMAND_SIZE] = { 0, 0xD0, 0xDA };
/*---------------------------------------------------------*\
| Set up the Send Feature packet |
\*---------------------------------------------------------*/
feature_buffer[3] = commandId;
feature_buffer[4] = parameter3;
feature_buffer[5] = parameter2;
feature_buffer[6] = parameter1;
feature_buffer[7] = parameter0;
/*---------------------------------------------------------*\
| Send packet |
\*---------------------------------------------------------*/
uint8_t report_size = hid_send_feature_report(dev, feature_buffer, WOOTING_COMMAND_SIZE);
LOG_DEBUG("%sSend feature returned - %04i expected %04i", WOOTING_CONTROLLER_NAME, report_size, WOOTING_COMMAND_SIZE);
return (report_size == WOOTING_COMMAND_SIZE);
}
Controllers/WootingKeyboardController/WootingKeyboardController.h
+83
View File
@@ -0,0 +1,83 @@
/*---------------------------------------------------------*\
| WootingKeyboardController.h |
| |
| Driver for Wooting keyboard |
| |
| Chris M (Dr_No) 09 Jul 2021 |
| Diogo Trindade (diogotr7) 25 Dec 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <hidapi.h>
#include "RGBController.h"
#include "LogManager.h"
#define WOOTING_COMMAND_SIZE 8
#define WOOTING_RAW_COLORS_REPORT 11
#define WOOTING_SINGLE_COLOR_COMMAND 30
#define WOOTING_SINGLE_RESET_COMMAND 31
#define WOOTING_RESET_ALL_COMMAND 32
#define WOOTING_COLOR_INIT_COMMAND 33
#define WOOTING_RGB_ROWS 6
#define WOOTING_RGB_COLUMNS 21
#define WOOTING_ONE_RGB_COLUMNS 17
#define WOOTING_TWO_RGB_COLUMNS 21
#define WOOTING_60_RGB_COLUMNS 14
#define WOOTING_3PAD_RGB_COLUMNS 7
/*---------------------------------------------------------*\
| Placeholder for compilation. Redefined by each subclass |
\*---------------------------------------------------------*/
#define WOOTING_CONTROLLER_NAME "[Wooting] "
enum WOOTING_DEVICE_TYPE
{
WOOTING_KB_TKL = 0,
WOOTING_KB_FULL = 1,
WOOTING_KB_60PER = 2,
WOOTING_KB_3PAD = 3,
WOOTING_KB_80PER = 4,
};
enum RGB_PARTS
{
PART0,
PART1,
PART2,
PART3,
PART4
};
class WootingKeyboardController
{
public:
WootingKeyboardController();
virtual ~WootingKeyboardController();
hid_device* dev;
std::string name;
std::string vendor;
std::string description;
std::string location;
WOOTING_DEVICE_TYPE wooting_type;
std::string GetName();
std::string GetVendor();
std::string GetDescription();
std::string GetLocation();
std::string GetSerial();
WOOTING_DEVICE_TYPE GetWootingType();
bool wooting_usb_send_feature(uint8_t command, uint8_t param0,
uint8_t param1, uint8_t param2, uint8_t param3);
virtual void SendDirect(RGBColor* colors, uint8_t color_count) = 0;
virtual void SendInitialize();
};
Controllers/WootingKeyboardController/WootingKeyboardControllerDetect.cpp
+186
View File
@@ -0,0 +1,186 @@
/*---------------------------------------------------------*\
| WootingKeyboardControllerDetect.cpp |
| |
| Detector for Wooting keyboard |
| |
| Diogo Trindade (diogotr7) 25 Dec 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "Detector.h"
#include "WootingV1KeyboardController.h"
#include "WootingV2KeyboardController.h"
#include "WootingV3KeyboardController.h"
#include "RGBController_WootingKeyboard.h"
#include "LogManager.h"
#define WOOTING_CONFIG_USAGE_PAGE_V2 0x1337
#define WOOTING_CONFIG_USAGE_PAGE_V3 0xFF55
/*-----------------------------------------------------*\
| Wooting vendor ID |
\*-----------------------------------------------------*/
#define WOOTING_OLD_VID 0x03EB
#define WOOTING_NEW_VID 0x31E3
/*-----------------------------------------------------*\
| Keyboard product IDs |
\*-----------------------------------------------------*/
#define WOOTING_ONE_LEGACY_PID 0xFF01
#define WOOTING_TWO_LEGACY_PID 0xFF02
#define WOOTING_ONE_PID 0x1100
#define WOOTING_TWO_PID 0x1200
#define WOOTING_TWO_LE_PID 0x1210
#define WOOTING_TWO_HE_PID 0x1220
#define WOOTING_TWO_HE_ARM_PID 0x1230
#define WOOTING_60HE_PID 0x1300
#define WOOTING_60HE_ARM_PID 0x1310
#define WOOTING_60HE_PLUS_PID 0x1320
#define WOOTING_60HE_V2_PID 0x1340
#define WOOTING_80HE_PID 0x1400
#define WOOTING_UWU_RGB_PID 0x1510
/*-----------------------------------------------------*\
| Product ID helpers |
| XINP: Xbox input emulation enabled |
| DINP: Classic DirectInput emulation enabled |
| NONE: Controller emulation disabled |
\*-----------------------------------------------------*/
#define XINP_PID(pid) (pid | 0x0000)
#define DINP_PID(pid) (pid | 0x0001)
#define NONE_PID(pid) (pid | 0x0002)
void DetectWootingControllers(hid_device_info *info, const std::string &name)
{
static const char *controller_name = "Wooting";
LOG_DEBUG("[%s] Interface %i\tPage %04X\tUsage %i\tPath %s", controller_name, info->interface_number, info->usage_page, info->usage, info->path);
hid_device *dev = hid_open_path(info->path);
if(!dev)
return;
WOOTING_DEVICE_TYPE wooting_type;
uint16_t pid = info->product_id;
if(pid == WOOTING_ONE_LEGACY_PID)
{
wooting_type = WOOTING_KB_TKL;
}
else if(pid == WOOTING_TWO_LEGACY_PID)
{
wooting_type = WOOTING_KB_FULL;
}
else
{
//on modern devices, mask out the last nibble to get base PID
switch(pid & 0xFFF0)
{
case WOOTING_ONE_LEGACY_PID:
case WOOTING_ONE_PID:
wooting_type = WOOTING_KB_TKL;
break;
case WOOTING_TWO_LEGACY_PID:
case WOOTING_TWO_PID:
case WOOTING_TWO_LE_PID:
case WOOTING_TWO_HE_PID:
case WOOTING_TWO_HE_ARM_PID:
wooting_type = WOOTING_KB_FULL;
break;
case WOOTING_60HE_PID:
case WOOTING_60HE_ARM_PID:
case WOOTING_60HE_PLUS_PID:
case WOOTING_60HE_V2_PID:
wooting_type = WOOTING_KB_60PER;
break;
case WOOTING_80HE_PID:
wooting_type = WOOTING_KB_80PER;
break;
case WOOTING_UWU_RGB_PID:
wooting_type = WOOTING_KB_3PAD;
break;
default:
//default to largest keyboard if unknown
wooting_type = WOOTING_KB_FULL;
break;
}
}
LOG_INFO("[%s] Detected Wooting device type %i for device at path %s", controller_name, wooting_type, info->path);
//V1 firmware used the ATMEL VID, and uses the V1 controller
if(info->vendor_id == WOOTING_OLD_VID && info->usage_page == WOOTING_CONFIG_USAGE_PAGE_V2)
{
LOG_DEBUG("[%s] Old VID detected - creating V1 Controller", controller_name);
WootingV1KeyboardController *controller = new WootingV1KeyboardController(dev, info->path, wooting_type, name);
LOG_DEBUG("[%s] Controller created - creating RGBController", controller_name);
RGBController_WootingKeyboard *rgb_controller = new RGBController_WootingKeyboard(controller);
LOG_DEBUG("[%s] Initialization complete - Registering controller\t%s", controller_name, name.c_str());
ResourceManager::get()->RegisterRGBController(rgb_controller);
return;
}
//V2-V2.11 firmware uses the V2 protocol indicated by the V2 usage page
if(info->usage_page == WOOTING_CONFIG_USAGE_PAGE_V2)
{
LOG_DEBUG("[%s] V2 usage page detected - creating V2 Controller", controller_name);
WootingV2KeyboardController *controller = new WootingV2KeyboardController(dev, info->path, wooting_type, name);
LOG_DEBUG("[%s] Controller created - creating RGBController", controller_name);
RGBController_WootingKeyboard *rgb_controller = new RGBController_WootingKeyboard(controller);
LOG_DEBUG("[%s] Initialization complete - Registering controller\t%s", controller_name, name.c_str());
ResourceManager::get()->RegisterRGBController(rgb_controller);
return;
}
//V2.12+ firmware uses the new report structure indicated by the V3 usage page
if(info->usage_page == WOOTING_CONFIG_USAGE_PAGE_V3)
{
LOG_DEBUG("[%s] V3 usage page detected - creating V3 Controller", controller_name);
WootingV3KeyboardController *controller = new WootingV3KeyboardController(dev, info->path, wooting_type, name);
LOG_DEBUG("[%s] Controller created - creating RGBController", controller_name);
RGBController_WootingKeyboard *rgb_controller = new RGBController_WootingKeyboard(controller);
LOG_DEBUG("[%s] Initialization complete - Registering controller\t%s", controller_name, name.c_str());
ResourceManager::get()->RegisterRGBController(rgb_controller);
return;
}
hid_close(dev);
LOG_TRACE("[%s] No compatible Wooting controller found for device at path %s", controller_name, info->path);
}
/*-----------------------------------------------------*\
| Wooting keyboards use different PIDs based on which |
| gamepad emulation mode is selected. We can use their |
| base PID, and set the last nibble to get the modes. |
\*-----------------------------------------------------*/
#define REGISTER_WOOTING_DETECTOR(name, vid, pid) \
static HIDDeviceDetector detector_wooting_##vid##_##pid##_base(name, DetectWootingControllers, vid, NONE_PID(pid), HID_INTERFACE_ANY, HID_USAGE_PAGE_ANY, HID_USAGE_ANY); \
static HIDDeviceDetector detector_wooting_##vid##_##pid##_xinp(name, DetectWootingControllers, vid, XINP_PID(pid), HID_INTERFACE_ANY, HID_USAGE_PAGE_ANY, HID_USAGE_ANY); \
static HIDDeviceDetector detector_wooting_##vid##_##pid##_dinp(name, DetectWootingControllers, vid, DINP_PID(pid), HID_INTERFACE_ANY, HID_USAGE_PAGE_ANY, HID_USAGE_ANY)
// Legacy devices with V1 firmware
REGISTER_HID_DETECTOR_P("Wooting One (Legacy)", DetectWootingControllers, WOOTING_OLD_VID, WOOTING_ONE_LEGACY_PID, WOOTING_CONFIG_USAGE_PAGE_V2);
REGISTER_HID_DETECTOR_P("Wooting Two (Legacy)", DetectWootingControllers, WOOTING_OLD_VID, WOOTING_TWO_LEGACY_PID, WOOTING_CONFIG_USAGE_PAGE_V2);
// All other devices
REGISTER_WOOTING_DETECTOR("Wooting One", WOOTING_NEW_VID, WOOTING_ONE_PID );
REGISTER_WOOTING_DETECTOR("Wooting Two", WOOTING_NEW_VID, WOOTING_TWO_PID );
REGISTER_WOOTING_DETECTOR("Wooting Two Lekker Edition", WOOTING_NEW_VID, WOOTING_TWO_LE_PID );
REGISTER_WOOTING_DETECTOR("Wooting Two HE", WOOTING_NEW_VID, WOOTING_TWO_HE_PID );
REGISTER_WOOTING_DETECTOR("Wooting Two HE (ARM)", WOOTING_NEW_VID, WOOTING_TWO_HE_ARM_PID);
REGISTER_WOOTING_DETECTOR("Wooting 60HE", WOOTING_NEW_VID, WOOTING_60HE_PID );
REGISTER_WOOTING_DETECTOR("Wooting 60HE (ARM)", WOOTING_NEW_VID, WOOTING_60HE_ARM_PID );
REGISTER_WOOTING_DETECTOR("Wooting 60HE+", WOOTING_NEW_VID, WOOTING_60HE_PLUS_PID );
REGISTER_WOOTING_DETECTOR("Wooting 60HEv2", WOOTING_NEW_VID, WOOTING_60HE_V2_PID );
REGISTER_WOOTING_DETECTOR("Wooting 80HE", WOOTING_NEW_VID, WOOTING_80HE_PID );
REGISTER_WOOTING_DETECTOR("Wooting UwU RGB", WOOTING_NEW_VID, WOOTING_UWU_RGB_PID );
Controllers/WootingKeyboardController/WootingV1KeyboardController/WootingV1KeyboardController.cpp
+213
View File
@@ -0,0 +1,213 @@
/*---------------------------------------------------------*\
| WootingV1KeyboardController.cpp |
| |
| Driver for Wooting keyboards with v1 firmware |
| |
| Diogo Trindade (diogotr7) 25 Dec 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "StringUtils.h"
#include "WootingV1KeyboardController.h"
#undef WOOTING_CONTROLLER_NAME
#define WOOTING_CONTROLLER_NAME "[WootingONE] "
//0xFFFFFFFF indicates an unused entry in matrix
#define NA 0xFFFFFFFF
#define RGB_RAW_BUFFER_SIZE 96
static const unsigned int rgb_led_index[WOOTING_RGB_ROWS][WOOTING_RGB_COLUMNS] =
{
{ 0, NA, 11, 12, 23, 24, 36, 47, 85, 84, 49, 48, 59, 61, 73, 81, 80, 113, 114, 115, 116 },
{ 2, 1, 14, 13, 26, 25, 35, 38, 37, 87, 86, 95, 51, 63, 75, 72, 74, 96, 97, 98, 99 },
{ 3, 4, 15, 16, 27, 28, 39, 42, 40, 88, 89, 52, 53, 71, 76, 83, 77, 102, 103, 104, 100 },
{ 5, 6, 17, 18, 29, 30, 41, 46, 44, 90, 93, 54, 57, 65, NA, NA, NA, 105, 106, 107, NA },
{ 9, 8, 19, 20, 31, 34, 32, 45, 43, 91, 92, 55, NA, 66, NA, 78, NA, 108, 109, 110, 101 },
{ 10, 22, 21, NA, NA, NA, 33, NA, NA, NA, 94, 58, 67, 68, 70, 79, 82, NA, 111, 112, NA }
};
static uint16_t getCrc16ccitt(const uint8_t* buffer, uint16_t size)
{
uint16_t crc = 0;
while(size--)
{
crc ^= (*buffer++ << 8);
for(uint8_t i = 0; i < 8; ++i)
{
if(crc & 0x8000)
{
crc = (crc << 1) ^ 0x1021;
}
else
{
crc = crc << 1;
}
}
}
return crc;
}
WootingV1KeyboardController::WootingV1KeyboardController(hid_device* dev_handle, const char *path, WOOTING_DEVICE_TYPE wooting_type, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
this->wooting_type = wooting_type;
key_code_limit = WOOTING_TWO_KEY_CODE_LIMIT;
/*---------------------------------------------------------*\
| Get device HID manufacturer and product strings |
\*---------------------------------------------------------*/
const int szTemp = 256;
wchar_t tmpName[szTemp];
hid_get_manufacturer_string(dev, tmpName, szTemp);
vendor = std::string(StringUtils::wstring_to_string(tmpName));
hid_get_product_string(dev, tmpName, szTemp);
description = std::string(StringUtils::wstring_to_string(tmpName));
SendInitialize();
}
WootingV1KeyboardController::~WootingV1KeyboardController()
{
}
void WootingV1KeyboardController::SendDirect(RGBColor* colors, uint8_t colour_count)
{
const uint8_t pwm_mem_map[48] =
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D
};
unsigned char buffer0[RGB_RAW_BUFFER_SIZE] = {0};
unsigned char buffer1[RGB_RAW_BUFFER_SIZE] = {0};
unsigned char buffer2[RGB_RAW_BUFFER_SIZE] = {0};
unsigned char buffer3[RGB_RAW_BUFFER_SIZE] = {0};
unsigned char buffer4[RGB_RAW_BUFFER_SIZE] = {0};
for(uint8_t index = 0; index < colour_count; index++)
{
unsigned char row = index / WOOTING_RGB_COLUMNS;
unsigned char col = index % WOOTING_RGB_COLUMNS;
unsigned char led_index = rgb_led_index[row][col];
if(led_index > key_code_limit)
{
continue;
}
unsigned char *buffer_pointer = buffer0;
if(led_index >= 96)
{
buffer_pointer = buffer4;
}
else if(led_index >= 72)
{
buffer_pointer = buffer3;
}
else if(led_index >= 48)
{
buffer_pointer = buffer2;
}
else if(led_index >= 24)
{
buffer_pointer = buffer1;
}
else
{
buffer_pointer = buffer0;
}
unsigned char buffer_index = pwm_mem_map[led_index % 24];
buffer_pointer[buffer_index + 0x00] = RGBGetRValue(colors[index]);
buffer_pointer[buffer_index + 0x10] = RGBGetGValue(colors[index]);
buffer_pointer[buffer_index + 0x20] = RGBGetBValue(colors[index]);
}
wooting_usb_send_buffer(RGB_PARTS::PART0, buffer0);
wooting_usb_send_buffer(RGB_PARTS::PART1, buffer1);
wooting_usb_send_buffer(RGB_PARTS::PART2, buffer2);
wooting_usb_send_buffer(RGB_PARTS::PART3, buffer3);
if(key_code_limit > WOOTING_ONE_KEY_CODE_LIMIT)
{
wooting_usb_send_buffer(RGB_PARTS::PART4, buffer4);
}
}
bool WootingV1KeyboardController::wooting_usb_send_buffer(RGB_PARTS part_number, uint8_t* rgb_buffer)
{
unsigned char report_buffer[WOOTING_REPORT_SIZE] = {0};
/*---------------------------------------------------------*\
| Set up the Send Buffer packet |
\*---------------------------------------------------------*/
report_buffer[0] = 0; // HID report index (unused)
report_buffer[1] = 0xD0; // Magic word
report_buffer[2] = 0xDA; // Magic word
report_buffer[3] = WOOTING_RAW_COLORS_REPORT; // Report ID
switch(part_number)
{
case PART0:
report_buffer[4] = 0; // Slave nr
report_buffer[5] = 0; // Reg start address
break;
case PART1:
report_buffer[4] = 0; // Slave nr
report_buffer[5] = RGB_RAW_BUFFER_SIZE; // Reg start address
break;
case PART2:
report_buffer[4] = 1; // Slave nr
report_buffer[5] = 0; // Reg start address
break;
case PART3:
report_buffer[4] = 1; // Slave nr
report_buffer[5] = RGB_RAW_BUFFER_SIZE; // Reg start address
break;
case PART4:
report_buffer[4] = 2; // Slave nr
report_buffer[5] = 0; // Reg start address
break;
default:
return false;
break;
}
/*---------------------------------------------------------*\
| Copy in the buffer data |
\*---------------------------------------------------------*/
memcpy(&report_buffer[6], rgb_buffer, RGB_RAW_BUFFER_SIZE);
/*---------------------------------------------------------*\
| Calculate the CRC and append it to the packet |
\*---------------------------------------------------------*/
unsigned short crc = getCrc16ccitt((unsigned char*)&report_buffer, WOOTING_REPORT_SIZE - 2);
report_buffer[127] = (unsigned char)crc;
report_buffer[128] = crc >> 8;
/*---------------------------------------------------------*\
| Send packet |
\*---------------------------------------------------------*/
hid_write(dev, report_buffer, WOOTING_REPORT_SIZE);
return true;
}
Controllers/WootingKeyboardController/WootingV1KeyboardController/WootingV1KeyboardController.h
+32
View File
@@ -0,0 +1,32 @@
/*---------------------------------------------------------*\
| WootingV1KeyboardController.h |
| |
| Driver for Wooting keyboards with v1 firmware |
| |
| Diogo Trindade (diogotr7) 25 Dec 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "WootingKeyboardController.h"
#define WOOTING_REPORT_SIZE 129
#define WOOTING_ONE_KEY_CODE_LIMIT 95
#define WOOTING_TWO_KEY_CODE_LIMIT 116
class WootingV1KeyboardController : public WootingKeyboardController
{
public:
WootingV1KeyboardController(hid_device* dev_handle, const char *path, WOOTING_DEVICE_TYPE wooting_type, std::string dev_name);
~WootingV1KeyboardController();
uint8_t key_code_limit;
void SendDirect(RGBColor* colors, uint8_t colour_count);
private:
bool wooting_usb_send_buffer(RGB_PARTS part_number, uint8_t* report_buffer);
};
Controllers/WootingKeyboardController/WootingV2KeyboardController/WootingV2KeyboardController.cpp
+72
View File
@@ -0,0 +1,72 @@
/*---------------------------------------------------------*\
| WootingV2KeyboardController.cpp |
| |
| Driver for Wooting keyboards with v2 firmware |
| |
| Chris M (Dr_No) 09 Jul 2021 |
| Diogo Trindade (diogotr7) 25 Dec 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "StringUtils.h"
#include "WootingV2KeyboardController.h"
#define WOOTING_TWO_REPORT_SIZE 257
#undef WOOTING_CONTROLLER_NAME
#define WOOTING_CONTROLLER_NAME "[WootingTWO] "
//Indicates an unused entry in matrix
#define NA 0x7D
//WootingTwo uses a 16bit color space
typedef uint16_t R5G6B5_color;
#define RGB888ToRGBcolor16(r, g, b) ((R5G6B5_color)((red & 0xF8) << 8 | (green & 0xFC) << 3 | (b & 0xF8) >> 3))
#define RGB32ToRGBcolor16(color32) ((R5G6B5_color)((color32 & 0xF8) << 8 | (color32 & 0xFC00) >> 5 | (color32 & 0xF80000) >> 19))
WootingV2KeyboardController::WootingV2KeyboardController(hid_device* dev_handle, const char *path, WOOTING_DEVICE_TYPE wooting_type, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
this->wooting_type = wooting_type;
/*---------------------------------------------------------*\
| Get device HID manufacturer and product strings |
\*---------------------------------------------------------*/
const int szTemp = 256;
wchar_t tmpName[szTemp];
hid_get_manufacturer_string(dev, tmpName, szTemp);
vendor = std::string(StringUtils::wstring_to_string(tmpName));
hid_get_product_string(dev, tmpName, szTemp);
description = std::string(StringUtils::wstring_to_string(tmpName));
SendInitialize();
}
WootingV2KeyboardController::~WootingV2KeyboardController()
{
}
void WootingV2KeyboardController::SendDirect(RGBColor* colors, uint8_t color_count)
{
uint8_t rgb_buffer[WOOTING_TWO_REPORT_SIZE] = { 0, 0xD0, 0xDA, WOOTING_RAW_COLORS_REPORT};
for(std::size_t index = 0; index < color_count; index++)
{
size_t buffer_index = 4 + (index * 2);
R5G6B5_color color16 = RGB32ToRGBcolor16(colors[index]);
rgb_buffer[buffer_index] = color16 & 0xFF;
rgb_buffer[buffer_index+1] = color16 >> 8;
}
uint16_t report_size = hid_write(dev, rgb_buffer, WOOTING_TWO_REPORT_SIZE);
LOG_DEBUG("%sSend buffer returned - %04i expected %04i", WOOTING_CONTROLLER_NAME, report_size, WOOTING_TWO_REPORT_SIZE);
}
Controllers/WootingKeyboardController/WootingV2KeyboardController/WootingV2KeyboardController.h
+24
View File
@@ -0,0 +1,24 @@
/*---------------------------------------------------------*\
| WootingV2KeyboardController.h |
| |
| Driver for Wooting keyboards with v2 firmware |
| |
| Chris M (Dr_No) 09 Jul 2021 |
| Diogo Trindade (diogotr7) 25 Dec 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "WootingKeyboardController.h"
class WootingV2KeyboardController : public WootingKeyboardController
{
public:
WootingV2KeyboardController(hid_device* dev_handle, const char *path, WOOTING_DEVICE_TYPE wooting_type, std::string dev_name);
~WootingV2KeyboardController();
void SendDirect(RGBColor* colors, uint8_t colour_count);
};
Controllers/WootingKeyboardController/WootingV3KeyboardController/WootingV3KeyboardController.cpp
+76
View File
@@ -0,0 +1,76 @@
/*---------------------------------------------------------*\
| WootingV3KeyboardController.cpp |
| |
| Driver for Wooting keyboards with v3 firmware |
| |
| Diogo Trindade (diogotr7) 25 Dec 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "StringUtils.h"
#include "WootingV3KeyboardController.h"
#define WOOTING_V3_REPORT_SIZE 2046
#undef WOOTING_CONTROLLER_NAME
#define WOOTING_CONTROLLER_NAME "[WootingTWO] "
//Indicates an unused entry in matrix
#define NA 0x7D
//WootingTwo uses a 16bit color space
typedef uint16_t R5G6B5_color;
#define RGB888ToRGBcolor16(r, g, b) ((R5G6B5_color)((red & 0xF8) << 8 | (green & 0xFC) << 3 | (b & 0xF8) >> 3))
#define RGB32ToRGBcolor16(color32) ((R5G6B5_color)((color32 & 0xF8) << 8 | (color32 & 0xFC00) >> 5 | (color32 & 0xF80000) >> 19))
WootingV3KeyboardController::WootingV3KeyboardController(hid_device* dev_handle, const char *path, WOOTING_DEVICE_TYPE wooting_type, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
this->wooting_type = wooting_type;
/*---------------------------------------------------------*\
| Get device HID manufacturer and product strings |
\*---------------------------------------------------------*/
const int szTemp = 256;
wchar_t tmpName[szTemp];
hid_get_manufacturer_string(dev, tmpName, szTemp);
vendor = std::string(StringUtils::wstring_to_string(tmpName));
hid_get_product_string(dev, tmpName, szTemp);
description = std::string(StringUtils::wstring_to_string(tmpName));
SendInitialize();
}
WootingV3KeyboardController::~WootingV3KeyboardController()
{
}
void WootingV3KeyboardController::SendDirect(RGBColor* colors, uint8_t color_count)
{
uint8_t rgb_buffer[WOOTING_V3_REPORT_SIZE] = {0};
rgb_buffer[0] = 4;
rgb_buffer[1] = 0xD1;
rgb_buffer[2] = 0xDA;
rgb_buffer[3] = WOOTING_RAW_COLORS_REPORT;
for(std::size_t index = 0; index < color_count; index++)
{
size_t buffer_index = 4 + (index * 2);
R5G6B5_color color16 = RGB32ToRGBcolor16(colors[index]);
rgb_buffer[buffer_index] = color16 & 0xFF;
rgb_buffer[buffer_index+1] = color16 >> 8;
}
uint16_t report_size = hid_write(dev, rgb_buffer, WOOTING_V3_REPORT_SIZE);
LOG_DEBUG("%sSend buffer returned - %04i expected %04i", WOOTING_CONTROLLER_NAME, report_size, WOOTING_V3_REPORT_SIZE);
}
Controllers/WootingKeyboardController/WootingV3KeyboardController/WootingV3KeyboardController.h
+23
View File
@@ -0,0 +1,23 @@
/*---------------------------------------------------------*\
| WootingV3KeyboardController.h |
| |
| Driver for Wooting keyboards with v3 firmware |
| |
| Diogo Trindade (diogotr7) 25 Dec 2025 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "WootingKeyboardController.h"
class WootingV3KeyboardController : public WootingKeyboardController
{
public:
WootingV3KeyboardController(hid_device* dev_handle, const char *path, WOOTING_DEVICE_TYPE wooting_type, std::string dev_name);
~WootingV3KeyboardController();
void SendDirect(RGBColor* colors, uint8_t colour_count);
};