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

add support for Roccat Vulcan TKL to resolve #1616 + improvements to Roccat Vulcan protocol

Browse source
This commit is contained in:
Mola19 2022-04-06 08:26:22 +02:00 • committed by Adam Honse
parent 8716760e7e
commit 5cb0e54443
8 changed files with 458 additions and 123 deletions
Download patch file Download diff file Expand all files Collapse all files

41
Controllers/RoccatController/RGBController_RoccatVulcanAimo.h
View file

@ -1,41 +0,0 @@
/*-----------------------------------------*\
| RGBController_RoccatVulcanAimo.h |
| |
| Generic RGB Interface for Roccat Vulcan |
| Aimo controller |
| |
| Mola19 17/12/2021 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "RoccatVulcanAimoController.h"
enum
{
ROCCAT_VULCAN_SPEED_MIN = 0x01,
ROCCAT_VULCAN_SPEED_MAX = 0x0B,
ROCCAT_VULCAN_SPEED_DEFAULT = 0x06,
ROCCAT_VULCAN_BRIGHTNESS_MIN = 0x01,
ROCCAT_VULCAN_BRIGHTNESS_MAX = 0x45,
ROCCAT_VULCAN_BRIGHTNESS_DEFAULT = 0x45,
};
class RGBController_RoccatVulcanAimo : public RGBController
{
public:
RGBController_RoccatVulcanAimo(RoccatVulcanAimoController* controller_ptr);
~RGBController_RoccatVulcanAimo();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
RoccatVulcanAimoController* controller;
};

83
Controllers/RoccatController/RGBController_RoccatVulcanAimo.cpp → Controllers/RoccatController/RGBController_RoccatVulcanKeyboard.cpp
View file

@ -1,5 +1,5 @@
/*-----------------------------------------*\
| RGBController_RoccatVulcanAimo.cpp |
| RGBController_RoccatVulcanKeyboard.cpp |
| |
| Generic RGB Interface for OpenRGB |
| |
@ -8,32 +8,36 @@
\*-----------------------------------------*/
#include "RGBControllerKeyNames.h"
#include "RGBController_RoccatVulcanAimo.h"
#include "RGBController_RoccatVulcanKeyboard.h"
#include <vector>
#define NA 0xFFFFFFFF
/**------------------------------------------------------------------*\
@name Roccat Vulcan Aimo
@name Roccat Vulcan Keyboard
@category Keyboard
@type USB
@save :robot:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectRoccatVulcanAimoControllers
@comment
@detectors DetectRoccatVulcanKeyboardControllers
@comment The mode "Default" differs from device to device and
and sometimes also based on which profile you are on.
Often it is very close to the rainbow mode.
\*-------------------------------------------------------------------*/
RGBController_RoccatVulcanAimo::RGBController_RoccatVulcanAimo(RoccatVulcanAimoController* controller_ptr)
RGBController_RoccatVulcanKeyboard::RGBController_RoccatVulcanKeyboard(RoccatVulcanKeyboardController* controller_ptr)
{
controller = controller_ptr;
pid = controller->device_pid;
controller->InitDeviceInfo();
name = "Roccat Vulcan 120-Series Aimo";
name = "Roccat Vulcan Keyboard";
vendor = "Roccat";
type = DEVICE_TYPE_KEYBOARD;
description = "Roccat Vulcan Aimo Keyboard";
description = "Roccat Vulcan Keyboard";
version = controller->GetDeviceInfo().version;
location = controller->GetLocation();
serial = controller->GetSerial();
@ -68,16 +72,42 @@ RGBController_RoccatVulcanAimo::RGBController_RoccatVulcanAimo(RoccatVulcanAimoC
Wave.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave);
mode Default;
Default.name = "Default";
Default.value = ROCCAT_VULCAN_MODE_DEFAULT;
Default.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Default.brightness_min = ROCCAT_VULCAN_BRIGHTNESS_MIN;
Default.brightness_max = ROCCAT_VULCAN_BRIGHTNESS_MAX;
Default.brightness = ROCCAT_VULCAN_BRIGHTNESS_DEFAULT;
Default.color_mode = MODE_COLORS_NONE;
modes.push_back(Default);
SetupZones();
}
RGBController_RoccatVulcanAimo::~RGBController_RoccatVulcanAimo()
RGBController_RoccatVulcanKeyboard::~RGBController_RoccatVulcanKeyboard()
{
delete controller;
}
void RGBController_RoccatVulcanAimo::SetupZones()
void RGBController_RoccatVulcanKeyboard::SetupZones()
{
std::map<int,layout_info> * keyboard_ptr;
switch(pid)
{
case ROCCAT_VULCAN_120_AIMO:
keyboard_ptr = &RoccatVulcan120AimoLayouts;
break;
case ROCCAT_VULCAN_TKL:
keyboard_ptr = &RoccatVulcanTKLLayouts;
break;
default:
keyboard_ptr = &RoccatVulcan120AimoLayouts;
}
std::map<int,layout_info> & keyboard = *keyboard_ptr;
unsigned char layout;
switch(controller->GetDeviceInfo().layout_type)
@ -96,20 +126,20 @@ void RGBController_RoccatVulcanAimo::SetupZones()
zone keyboard_zone;
keyboard_zone.name = "Keyboard";
keyboard_zone.type = ZONE_TYPE_MATRIX;
keyboard_zone.leds_min = RoccatVulcanLayouts[layout].size;
keyboard_zone.leds_max = RoccatVulcanLayouts[layout].size;
keyboard_zone.leds_count = RoccatVulcanLayouts[layout].size;
keyboard_zone.leds_min = keyboard[layout].size;
keyboard_zone.leds_max = keyboard[layout].size;
keyboard_zone.leds_count = keyboard[layout].size;
keyboard_zone.matrix_map = new matrix_map_type;
keyboard_zone.matrix_map->height = RoccatVulcanLayouts[layout].rows;
keyboard_zone.matrix_map->width = RoccatVulcanLayouts[layout].cols;
keyboard_zone.matrix_map->map = RoccatVulcanLayouts[layout].matrix_map;
keyboard_zone.matrix_map->height = keyboard[layout].rows;
keyboard_zone.matrix_map->width = keyboard[layout].cols;
keyboard_zone.matrix_map->map = keyboard[layout].matrix_map;
zones.push_back(keyboard_zone);
for(int led_id = 0; led_id < RoccatVulcanLayouts[layout].size; led_id++)
for(unsigned int led_id = 0; led_id < keyboard[layout].size; led_id++)
{
led new_led;
new_led.name = RoccatVulcanLayouts[layout].led_names[led_id].name;
new_led.value = RoccatVulcanLayouts[layout].led_names[led_id].id;
new_led.name = keyboard[layout].led_names[led_id].name;
new_led.value = keyboard[layout].led_names[led_id].id;
leds.push_back(new_led);
}
@ -119,16 +149,17 @@ void RGBController_RoccatVulcanAimo::SetupZones()
| sends the init packet for the default mode (direct) |
\*---------------------------------------------------------*/
DeviceUpdateMode();
DeviceUpdateLEDs();
}
void RGBController_RoccatVulcanAimo::ResizeZone(int /*zone*/, int /*new_size*/)
void RGBController_RoccatVulcanKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_RoccatVulcanAimo::DeviceUpdateLEDs()
void RGBController_RoccatVulcanKeyboard::DeviceUpdateLEDs()
{
if (modes[active_mode].value == ROCCAT_VULCAN_MODE_DIRECT)
{
@ -147,17 +178,17 @@ void RGBController_RoccatVulcanAimo::DeviceUpdateLEDs()
}
}
void RGBController_RoccatVulcanAimo::UpdateZoneLEDs(int /*zone_idx*/)
void RGBController_RoccatVulcanKeyboard::UpdateZoneLEDs(int /*zone_idx*/)
{
DeviceUpdateLEDs();
}
void RGBController_RoccatVulcanAimo::UpdateSingleLED(int /*led_idx*/)
void RGBController_RoccatVulcanKeyboard::UpdateSingleLED(int /*led_idx*/)
{
DeviceUpdateLEDs();
}
void RGBController_RoccatVulcanAimo::DeviceUpdateMode()
void RGBController_RoccatVulcanKeyboard::DeviceUpdateMode()
{
std::vector<led_color> led_color_list = {};
@ -170,4 +201,8 @@ void RGBController_RoccatVulcanAimo::DeviceUpdateMode()
}
controller->SendMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, led_color_list);
controller->WaitUntilReady();
controller->EnableDirect(modes[active_mode].value != ROCCAT_VULCAN_MODE_DEFAULT);
controller->WaitUntilReady();
}

32
Controllers/RoccatController/RGBController_RoccatVulcanKeyboard.h Normal file
View file

@ -0,0 +1,32 @@
/*-----------------------------------------*\
| RGBController_RoccatVulcanKeyboard.h |
| |
| Generic RGB Interface for Roccat Vulcan |
| Keyboard controller |
| |
| Mola19 17/12/2021 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "RoccatVulcanKeyboardController.h"
class RGBController_RoccatVulcanKeyboard : public RGBController
{
public:
RGBController_RoccatVulcanKeyboard(RoccatVulcanKeyboardController* controller_ptr);
~RGBController_RoccatVulcanKeyboard();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
RoccatVulcanKeyboardController* controller;
uint16_t pid;
};

44
Controllers/RoccatController/RoccatControllerDetect.cpp
View file

@ -1,16 +1,8 @@
/******************************************************************************************\
* *
* DetectRoccatControllers *
* *
* Tests the USB address to see if a Roccat Kone Aimo controller exists there. *
* *
\******************************************************************************************/
#include "Detector.h"
#include "RoccatBurstController.h"
#include "RoccatKoneAimoController.h"
#include "RoccatSenseAimoController.h"
#include "RoccatVulcanAimoController.h"
#include "RoccatVulcanKeyboardController.h"
#include "RoccatKovaController.h"
#include "RoccatEloController.h"
#include "RGBController.h"
@ -18,7 +10,7 @@
#include "RGBController_RoccatHordeAimo.h"
#include "RGBController_RoccatKoneAimo.h"
#include "RGBController_RoccatSenseAimo.h"
#include "RGBController_RoccatVulcanAimo.h"
#include "RGBController_RoccatVulcanKeyboard.h"
#include "RGBController_RoccatKova.h"
#include "RGBController_RoccatElo.h"
#include <hidapi/hidapi.h>
@ -29,6 +21,7 @@
#define ROCCAT_KONE_AIMO_PID 0x2E27
#define ROCCAT_KONE_AIMO_16K_PID 0x2E2C
#define ROCCAT_VULCAN_120_AIMO_PID 0x3098
#define ROCCAT_VULCAN_TKL_PID 0x2FEE
#define ROCCAT_HORDE_AIMO_PID 0x303E
#define ROCCAT_BURST_CORE_PID 0x2DE6
#define ROCCAT_BURST_PRO_PID 0x2DE1
@ -50,24 +43,24 @@ void DetectRoccatMouseControllers(hid_device_info* info, const std::string& name
}
}
/*-----------------------------------------------------------------------------*\
| Tracks the paths used in DetectRoccatVulcanAimoControllers so multiple Roccat |
| devices can be detected without all controlling the same device. |
\*-----------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------*\
| Tracks the paths used in DetectRoccatVulcanKeyboardControllers so multiple Roccat |
| devices can be detected without all controlling the same device. |
\*---------------------------------------------------------------------------------*/
static std::unordered_set<std::string> used_paths;
/*--------------------------------------------------------------------------------*\
| Removes all entries in used_paths so device discovery does not skip any of them. |
\*--------------------------------------------------------------------------------*/
void ResetRoccatVulcanAimoControllersPaths()
void ResetRoccatVulcanKeyboardControllersPaths()
{
used_paths.clear();
}
void DetectRoccatVulcanAimoControllers(hid_device_info* info, const std::string& name)
void DetectRoccatVulcanKeyboardControllers(hid_device_info* info, const std::string& name)
{
/*-------------------------------------------------------------------------------------------------*\
| Create a local copy of the HID enumerations for the Roccat Vulcan Aimo VID/PID and iterate |
| Create a local copy of the HID enumerations for the Roccat Vulcan Keyboard VID/PID and iterate |
| through it. This prevents detection from failing if interface 1 comes before interface 0 in the |
| main info list. |
\*-------------------------------------------------------------------------------------------------*/
@ -83,10 +76,10 @@ void DetectRoccatVulcanAimoControllers(hid_device_info* info, const std::string&
while(info_temp)
{
/*------------------------------------------------------------------------------------*\
| Check for paths used on an already registered Roccat Vulcan Aimo controller to avoid |
| registering multiple controllers that refer to the same physical hardware. |
\*------------------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------------------*\
| Check for paths used on an already registered Roccat Vulcan Keyboard controller to avoid |
| registering multiple controllers that refer to the same physical hardware. |
\*----------------------------------------------------------------------------------------*/
if(info_temp->vendor_id == info->vendor_id
&& info_temp->product_id == info->product_id
&& used_paths.find(info_temp->path) == used_paths.end() )
@ -113,8 +106,8 @@ void DetectRoccatVulcanAimoControllers(hid_device_info* info, const std::string&
if(dev_ctrl && dev_led)
{
RoccatVulcanAimoController * controller = new RoccatVulcanAimoController(dev_ctrl, dev_led, info->path);
RGBController_RoccatVulcanAimo * rgb_controller = new RGBController_RoccatVulcanAimo(controller);
RoccatVulcanKeyboardController * controller = new RoccatVulcanKeyboardController(dev_ctrl, dev_led, info->path, info->product_id);
RGBController_RoccatVulcanKeyboard * rgb_controller = new RGBController_RoccatVulcanKeyboard(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
used_paths.insert(dev_ctrl_path);
@ -206,11 +199,12 @@ void DetectRoccatSenseAimoControllers(hid_device_info* info, const std::string&
}
}
REGISTER_PRE_DETECTION_HOOK(ResetRoccatVulcanAimoControllersPaths);
REGISTER_PRE_DETECTION_HOOK(ResetRoccatVulcanKeyboardControllersPaths);
REGISTER_HID_DETECTOR_IPU("Roccat Kone Aimo", DetectRoccatMouseControllers, ROCCAT_VID, ROCCAT_KONE_AIMO_PID, 0, 0x0B, 0 );
REGISTER_HID_DETECTOR_IPU("Roccat Kone Aimo 16K", DetectRoccatMouseControllers, ROCCAT_VID, ROCCAT_KONE_AIMO_16K_PID, 0, 0x0B, 0 );
REGISTER_HID_DETECTOR_IP ("Roccat Vulcan 120-Series Aimo", DetectRoccatVulcanAimoControllers, ROCCAT_VID, ROCCAT_VULCAN_120_AIMO_PID, 1, 11);
REGISTER_HID_DETECTOR_IP ("Roccat Vulcan 120-Series Aimo", DetectRoccatVulcanKeyboardControllers, ROCCAT_VID, ROCCAT_VULCAN_120_AIMO_PID, 1, 11);
REGISTER_HID_DETECTOR_IP ("Roccat Vulcan TKL", DetectRoccatVulcanKeyboardControllers, ROCCAT_VID, ROCCAT_VULCAN_TKL_PID, 1, 11);
REGISTER_HID_DETECTOR_IPU("Roccat Horde Aimo", DetectRoccatHordeAimoKeyboardControllers, ROCCAT_VID, ROCCAT_HORDE_AIMO_PID, 1, 0x0B, 0 );
REGISTER_HID_DETECTOR_IPU("Roccat Burst Core", DetectRoccatBurstCoreControllers, ROCCAT_VID, ROCCAT_BURST_CORE_PID, 3, 0xFF01, 1 );
REGISTER_HID_DETECTOR_IPU("Roccat Burst Pro", DetectRoccatBurstProControllers, ROCCAT_VID, ROCCAT_BURST_PRO_PID, 3, 0xFF01, 1 );

70
Controllers/RoccatController/RoccatVulcanAimoController.cpp → Controllers/RoccatController/RoccatVulcanKeyboardController.cpp
View file

@ -1,33 +1,36 @@
/*-------------------------------------------------------------------*\
| RoccatVulcanAimoController.cpp |
| RoccatVulcanKeyboardController.cpp |
| |
| Driver for Roccat Vulcan Aimo Mouse |
| Driver for Roccat Vulcan Keyboard |
| |
| Mola19 17/12/2021 |
| |
\*-------------------------------------------------------------------*/
#include "RoccatVulcanAimoController.h"
#include "RoccatVulcanKeyboardController.h"
#include <cstring>
#include <math.h>
#include <chrono>
#include <thread>
#include "LogManager.h"
RoccatVulcanAimoController::RoccatVulcanAimoController(hid_device* dev_ctrl_handle, hid_device* dev_led_handle, char *path)
RoccatVulcanKeyboardController::RoccatVulcanKeyboardController(hid_device* dev_ctrl_handle, hid_device* dev_led_handle, char *path, uint16_t pid)
{
dev_ctrl = dev_ctrl_handle;
dev_led = dev_led_handle;
location = path;
device_pid = pid;
}
RoccatVulcanAimoController::~RoccatVulcanAimoController()
RoccatVulcanKeyboardController::~RoccatVulcanKeyboardController()
{
hid_close(dev_ctrl);
hid_close(dev_led);
}
std::string RoccatVulcanAimoController::GetSerial()
std::string RoccatVulcanKeyboardController::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev_ctrl, serial_string, 128);
@ -44,13 +47,13 @@ std::string RoccatVulcanAimoController::GetSerial()
}
std::string RoccatVulcanAimoController::GetLocation()
std::string RoccatVulcanKeyboardController::GetLocation()
{
return("HID: " + location);
}
device_info RoccatVulcanAimoController::InitDeviceInfo()
device_info RoccatVulcanKeyboardController::InitDeviceInfo()
{
unsigned char usb_buf[8] = { 0x0F };
hid_get_feature_report(dev_ctrl, usb_buf, 8);
@ -58,18 +61,23 @@ device_info RoccatVulcanAimoController::InitDeviceInfo()
dev_info.version = std::to_string((int) floor(usb_buf[2] / 100)) + "." + std::to_string(usb_buf[2] % 100);
dev_info.layout_type = usb_buf[6];
LOG_DEBUG("[Roccat Vulcan Aimo]: Detected layout '0x%02X'", usb_buf[6]);
LOG_DEBUG("[Roccat Vulcan Keyboard]: Detected layout '0x%02X'", usb_buf[6]);
return dev_info;
}
device_info RoccatVulcanAimoController::GetDeviceInfo()
device_info RoccatVulcanKeyboardController::GetDeviceInfo()
{
return dev_info;
}
void RoccatVulcanKeyboardController::EnableDirect(bool on_off_switch)
{
unsigned char buf[3] = { 0x15, 0x00, on_off_switch };
hid_send_feature_report(dev_ctrl, buf, 3);
}
void RoccatVulcanAimoController::SendColors(std::vector<led_color> colors)
void RoccatVulcanKeyboardController::SendColors(std::vector<led_color> colors)
{
unsigned char bufs[7][65];
@ -105,12 +113,15 @@ void RoccatVulcanAimoController::SendColors(std::vector<led_color> colors)
{
hid_write(dev_led, bufs[p], 65);
}
ClearResponses();
AwaitResponse(20);
}
void RoccatVulcanAimoController::SendMode(unsigned int mode, unsigned int speed, unsigned int brightness, std::vector<led_color> colors)
void RoccatVulcanKeyboardController::SendMode(unsigned int mode, unsigned int speed, unsigned int brightness, std::vector<led_color> colors)
{
if(speed == 0) speed = 1;
if(brightness == 0) brightness = 1;
if(speed == 0) speed = ROCCAT_VULCAN_SPEED_DEFAULT;
if(brightness == 0) brightness = ROCCAT_VULCAN_BRIGHTNESS_DEFAULT;
unsigned char buf[443];
@ -156,3 +167,34 @@ void RoccatVulcanAimoController::SendMode(unsigned int mode, unsigned int speed,
hid_send_feature_report(dev_ctrl, buf, 443);
}
void RoccatVulcanKeyboardController::WaitUntilReady()
{
unsigned char buf[3] = { 0x04, 0x00, 0x00 };
for(unsigned char i = 0; buf[1] != 1 && i < 100; i++)
{
if(i != 0)
{
std::this_thread::sleep_for(std::chrono::milliseconds(25));
}
hid_get_feature_report(dev_ctrl, buf, 3);
}
}
void RoccatVulcanKeyboardController::AwaitResponse(int ms)
{
unsigned char usb_buf_out[65];
hid_read_timeout(dev_led, usb_buf_out, 65, ms);
}
void RoccatVulcanKeyboardController::ClearResponses()
{
int result = 1;
unsigned char usb_buf_flush[65];
while(result > 0)
{
result = hid_read_timeout(dev_led, usb_buf_flush, 65, 0);
}
}

35
Controllers/RoccatController/RoccatVulcanAimoController.h → Controllers/RoccatController/RoccatVulcanKeyboardController.h
View file

@ -1,7 +1,7 @@
/*-------------------------------------------------------------------*\
| RoccatVulcanAimoController.h |
| RoccatVulcanKeyboardController.h |
| |
| Driver for Roccat Vulcan Aimo Keyboard |
| Driver for Roccat Vulcan Keyboard |
| |
| Mola19 17/12/2021 |
| |
@ -10,16 +10,33 @@
#pragma once
#include "RGBController.h"
#include "RoccatVulcanAimoLayouts.h"
#include "RoccatVulcanKeyboardLayouts.h"
#include <string>
#include <hidapi/hidapi.h>
enum
{
ROCCAT_VULCAN_120_AIMO = 0x3098,
ROCCAT_VULCAN_TKL = 0x2FEE,
};
enum
{
ROCCAT_VULCAN_MODE_DIRECT = 0x0B,
ROCCAT_VULCAN_MODE_STATIC = 0x01,
ROCCAT_VULCAN_MODE_WAVE = 0x0A,
ROCCAT_VULCAN_MODE_DEFAULT = 0x00,
};
enum
{
ROCCAT_VULCAN_SPEED_MIN = 0x01,
ROCCAT_VULCAN_SPEED_MAX = 0x0B,
ROCCAT_VULCAN_SPEED_DEFAULT = 0x06,
ROCCAT_VULCAN_BRIGHTNESS_MIN = 0x01,
ROCCAT_VULCAN_BRIGHTNESS_MAX = 0x45,
ROCCAT_VULCAN_BRIGHTNESS_DEFAULT = 0x45,
};
struct device_info
@ -34,19 +51,25 @@ struct led_color
RGBColor color;
};
class RoccatVulcanAimoController
class RoccatVulcanKeyboardController
{
public:
RoccatVulcanAimoController(hid_device* dev_ctrl_handle, hid_device* dev_led_handle, char *path);
~RoccatVulcanAimoController();
RoccatVulcanKeyboardController(hid_device* dev_ctrl_handle, hid_device* dev_led_handle, char *path, uint16_t pid);
~RoccatVulcanKeyboardController();
std::string GetSerial();
std::string GetLocation();
device_info InitDeviceInfo();
device_info GetDeviceInfo();
void EnableDirect(bool on_off_switch);
void SendColors(std::vector<led_color> colors);
void SendMode(unsigned int mode, unsigned int speed, unsigned int brightness, std::vector<led_color> colors);
void WaitUntilReady();
void AwaitResponse(int ms);
void ClearResponses();
uint16_t device_pid;
private:
std::string location;

266
Controllers/RoccatController/RoccatVulcanAimoLayouts.h → Controllers/RoccatController/RoccatVulcanKeyboardLayouts.h
View file

@ -1,8 +1,8 @@
/*-----------------------------------------*\
| RoccatVulcanAimoLayouts.h |
| RoccatVulcanKeyboardLayouts.h |
| |
| Keyboard Layouts for Roccat Vulcan Aimo |
| USB RGB lighting controller |
| Keyboard Layouts for Roccat Vulcan |
| Keyboard USB RGB lighting controller |
| |
| Mola19 09/29/2022 |
\*-----------------------------------------*/
@ -39,7 +39,7 @@ struct layout_info
std::vector<led_value> led_names;
};
static unsigned int ROCCAT_VULCAN_LAYOUT_KEYS_104[6][24] = {
static unsigned int ROCCAT_VULCAN_120_AIMO_LAYOUT_KEYS_104[6][24] = {
{ 0, NA, 8, 14, 19, 24, NA, 34, 39, 44, 49, 55, 61, 66, 70, NA, 74, 78, 83, NA, NA, NA, NA, NA },
{ 1, 6, 9, 15, 20, 25, 29, 35, 40, 45, 50, 56, 62, 67, NA, NA, 75, 79, 84, NA, 87, 92, 96, 101 },
{ 2, NA, 10, 16, 21, 26, 30, 36, 41, 46, 51, 57, 63, 68, 71, NA, 76, 80, 85, NA, 88, 93, 97, 102 },
@ -49,7 +49,7 @@ static unsigned int ROCCAT_VULCAN_LAYOUT_KEYS_104[6][24] = {
};
static unsigned int ROCCAT_VULCAN_LAYOUT_KEYS_105[6][24] = {
static unsigned int ROCCAT_VULCAN_120_AIMO_LAYOUT_KEYS_105[6][24] = {
{ 0, NA, 9, 15, 20, 25, NA, 35, 40, 45, 50, 56, 62, 67, 72, NA, 75, 79, 84, NA, NA, NA, NA, NA },
{ 1, 6, 10, 16, 21, 26, 30, 36, 41, 46, 51, 57, 63, 68, NA, NA, 76, 80, 85, NA, 88, 93, 97, 102 },
{ 2, NA, 11, 17, 22, 27, 31, 37, 42, 47, 52, 58, 64, 69, NA, NA, 77, 81, 86, NA, 89, 94, 98, 103 },
@ -58,12 +58,31 @@ static unsigned int ROCCAT_VULCAN_LAYOUT_KEYS_105[6][24] = {
{ 5, 8, 14, NA, NA, NA, 34, NA, NA, NA, 55, 61, 66, NA, 74, NA, 78, 83, 87, NA, 92, NA, 101, NA }
};
static std::map<int, layout_info> RoccatVulcanLayouts =
static unsigned int ROCCAT_VULCAN_TKL_LAYOUT_KEYS_104[6][19] = {
{ 0, NA, 8, 14, 19, 24, NA, 34, 39, 44, 49, 55, 61, 66, 70, NA, 74, NA, NA },
{ 1, 6, 9, 15, 20, 25, 29, 35, 40, 45, 50, 56, 62, 67, NA, NA, 75, 78, 82 },
{ 2, NA, 10, 16, 21, 26, 30, 36, 41, 46, 51, 57, 63, 68, 71, NA, 76, 79, 83 },
{ 3, NA, 11, 17, 22, 27, 31, 37, 42, 47, 52, 58, 64, NA, 72, NA, NA, NA, NA },
{ 4, NA, 12, 18, 23, 28, 32, 38, 43, 48, 53, 59, NA, 69, NA, NA, NA, 80, NA },
{ 5, 7, 13, NA, NA, NA, 33, NA, NA, NA, 54, 60, 65, NA, 73, NA, 77, 81, 84 }
};
static unsigned int ROCCAT_VULCAN_TKL_LAYOUT_KEYS_105[6][19] = {
{ 0, NA, 9, 15, 20, 25, NA, 35, 40, 45, 50, 56, 62, 67, 72, NA, 75, NA, NA },
{ 1, 6, 10, 16, 21, 26, 30, 36, 41, 46, 51, 57, 63, 68, NA, NA, 76, 79, 83 },
{ 2, NA, 11, 17, 22, 27, 31, 37, 42, 47, 52, 58, 64, 69, NA, NA, 77, 80, 84 },
{ 3, NA, 12, 18, 23, 28, 32, 38, 43, 48, 53, 59, 65, 70, 73, NA, NA, NA, NA },
{ 4, 7, 13, 19, 24, 29, 33, 39, 44, 49, 54, 60, NA, 71, NA, NA, NA, 81, NA },
{ 5, 8, 14, NA, NA, NA, 34, NA, NA, NA, 55, 61, 66, NA, 74, NA, 78, 82, 85 }
};
static std::map<int, layout_info> RoccatVulcan120AimoLayouts =
{
{
ROCCAT_VULCAN_LAYOUT_UK,
{
*ROCCAT_VULCAN_LAYOUT_KEYS_105,
*ROCCAT_VULCAN_120_AIMO_LAYOUT_KEYS_105,
105,
6,
24,
@ -200,7 +219,7 @@ static std::map<int, layout_info> RoccatVulcanLayouts =
{
ROCCAT_VULCAN_LAYOUT_US,
{
*ROCCAT_VULCAN_LAYOUT_KEYS_104,
*ROCCAT_VULCAN_120_AIMO_LAYOUT_KEYS_104,
104,
6,
24,
@ -334,3 +353,234 @@ static std::map<int, layout_info> RoccatVulcanLayouts =
}
},
};
static std::map<int, layout_info> RoccatVulcanTKLLayouts =
{
{
ROCCAT_VULCAN_LAYOUT_UK,
{
*ROCCAT_VULCAN_TKL_LAYOUT_KEYS_105,
86,
6,
19,
{
{ KEY_EN_ESCAPE, 0x02 },
{ KEY_EN_BACK_TICK, 0x03 },
{ KEY_EN_TAB, 0x04 },
{ KEY_EN_CAPS_LOCK, 0x05 },
{ KEY_EN_LEFT_SHIFT, 0x00 },
{ KEY_EN_LEFT_CONTROL, 0x01 },
{ KEY_EN_1, 0x08 },
{ KEY_EN_ISO_BACK_SLASH, 0x06 },
{ KEY_EN_LEFT_WINDOWS, 0x07 },
{ KEY_EN_F1, 0x0D },
{ KEY_EN_2, 0x0E },
{ KEY_EN_Q, 0x09 },
{ KEY_EN_A, 0x0A },
{ KEY_EN_Z, 0x0B },
{ KEY_EN_LEFT_ALT, 0x0C },
{ KEY_EN_F2, 0x14 },
{ KEY_EN_3, 0x15 },
{ KEY_EN_W, 0x0F },
{ KEY_EN_S, 0x10 },
{ KEY_EN_X, 0x11 },
{ KEY_EN_F3, 0x19 },
{ KEY_EN_4, 0x1A },
{ KEY_EN_E, 0x16 },
{ KEY_EN_D, 0x17 },
{ KEY_EN_C, 0x18 },
{ KEY_EN_F4, 0x1E },
{ KEY_EN_5, 0x1F },
{ KEY_EN_R, 0x1B },
{ KEY_EN_F, 0x1C },
{ KEY_EN_V, 0x1D },
{ KEY_EN_6, 0x24 },
{ KEY_EN_T, 0x20 },
{ KEY_EN_G, 0x21 },
{ KEY_EN_B, 0x22 },
{ KEY_EN_SPACE, 0x23 },
{ KEY_EN_F5, 0x28 },
{ KEY_EN_7, 0x29 },
{ KEY_EN_Y, 0x25 },
{ KEY_EN_H, 0x26 },
{ KEY_EN_N, 0x27 },
{ KEY_EN_F6, 0x2F },
{ KEY_EN_8, 0x30 },
{ KEY_EN_U, 0x2A },
{ KEY_EN_J, 0x2B },
{ KEY_EN_M, 0x2C },
{ KEY_EN_F7, 0x35 },
{ KEY_EN_9, 0x36 },
{ KEY_EN_I, 0x31 },
{ KEY_EN_K, 0x32 },
{ KEY_EN_COMMA, 0x33 },
{ KEY_EN_F8, 0x3B },
{ KEY_EN_0, 0x3C },
{ KEY_EN_O, 0x37 },
{ KEY_EN_L, 0x38 },
{ KEY_EN_PERIOD, 0x39 },
{ KEY_EN_RIGHT_ALT, 0x3A },
{ KEY_EN_F9, 0x41 },
{ KEY_EN_MINUS, 0x42 },
{ KEY_EN_P, 0x3D },
{ KEY_EN_SEMICOLON, 0x3E },
{ KEY_EN_FORWARD_SLASH, 0x3F },
{ KEY_EN_RIGHT_FUNCTION, 0x40 },
{ KEY_EN_F10, 0x47 },
{ KEY_EN_EQUALS, 0x48 },
{ KEY_EN_LEFT_BRACKET, 0x43 },
{ KEY_EN_QUOTE, 0x44 },
{ KEY_EN_MENU, 0x46 },
{ KEY_EN_F11, 0x4D },
{ KEY_EN_BACKSPACE, 0x50 },
{ KEY_EN_RIGHT_BRACKET, 0x49 },
{ KEY_EN_POUND, 0x4A },
{ KEY_EN_RIGHT_SHIFT, 0x4B },
{ KEY_EN_F12, 0x4F },
{ KEY_EN_ISO_ENTER, 0x52 },
{ KEY_EN_RIGHT_CONTROL, 0x4C },
{ KEY_EN_MEDIA_MUTE, 0x5C },
{ KEY_EN_INSERT, 0x54 },
{ KEY_EN_DELETE, 0x55 },
{ KEY_EN_LEFT_ARROW, 0x56 },
{ KEY_EN_HOME, 0x58 },
{ KEY_EN_END, 0x59 },
{ KEY_EN_UP_ARROW, 0x5A },
{ KEY_EN_DOWN_ARROW, 0x5B },
{ KEY_EN_PAGE_UP, 0x5D },
{ KEY_EN_PAGE_DOWN, 0x5E },
{ KEY_EN_RIGHT_ARROW, 0x5F },
}
}
},
{
ROCCAT_VULCAN_LAYOUT_US,
{
*ROCCAT_VULCAN_TKL_LAYOUT_KEYS_104,
85,
6,
19,
{
{ KEY_EN_ESCAPE, 0x02 },
{ KEY_EN_BACK_TICK, 0x03 },
{ KEY_EN_TAB, 0x04 },
{ KEY_EN_CAPS_LOCK, 0x05 },
{ KEY_EN_LEFT_SHIFT, 0x00 },
{ KEY_EN_LEFT_CONTROL, 0x01 },
{ KEY_EN_1, 0x08 },
{ KEY_EN_LEFT_WINDOWS, 0x07 },
{ KEY_EN_F1, 0x0D },
{ KEY_EN_2, 0x0E },
{ KEY_EN_Q, 0x09 },
{ KEY_EN_A, 0x0A },
{ KEY_EN_Z, 0x0B },
{ KEY_EN_LEFT_ALT, 0x0C },
{ KEY_EN_F2, 0x14 },
{ KEY_EN_3, 0x15 },
{ KEY_EN_W, 0x0F },
{ KEY_EN_S, 0x10 },
{ KEY_EN_X, 0x11 },
{ KEY_EN_F3, 0x19 },
{ KEY_EN_4, 0x1A },
{ KEY_EN_E, 0x16 },
{ KEY_EN_D, 0x17 },
{ KEY_EN_C, 0x18 },
{ KEY_EN_F4, 0x1E },
{ KEY_EN_5, 0x1F },
{ KEY_EN_R, 0x1B },
{ KEY_EN_F, 0x1C },
{ KEY_EN_V, 0x1D },
{ KEY_EN_6, 0x24 },
{ KEY_EN_T, 0x20 },
{ KEY_EN_G, 0x21 },
{ KEY_EN_B, 0x22 },
{ KEY_EN_SPACE, 0x23 },
{ KEY_EN_F5, 0x28 },
{ KEY_EN_7, 0x29 },
{ KEY_EN_Y, 0x25 },
{ KEY_EN_H, 0x26 },
{ KEY_EN_N, 0x27 },
{ KEY_EN_F6, 0x2F },
{ KEY_EN_8, 0x30 },
{ KEY_EN_U, 0x2A },
{ KEY_EN_J, 0x2B },
{ KEY_EN_M, 0x2C },
{ KEY_EN_F7, 0x35 },
{ KEY_EN_9, 0x36 },
{ KEY_EN_I, 0x31 },
{ KEY_EN_K, 0x32 },
{ KEY_EN_COMMA, 0x33 },
{ KEY_EN_F8, 0x3B },
{ KEY_EN_0, 0x3C },
{ KEY_EN_O, 0x37 },
{ KEY_EN_L, 0x38 },
{ KEY_EN_PERIOD, 0x39 },
{ KEY_EN_RIGHT_ALT, 0x3A },
{ KEY_EN_F9, 0x41 },
{ KEY_EN_MINUS, 0x42 },
{ KEY_EN_P, 0x3D },
{ KEY_EN_SEMICOLON, 0x3E },
{ KEY_EN_FORWARD_SLASH, 0x3F },
{ KEY_EN_RIGHT_FUNCTION, 0x40 },
{ KEY_EN_F10, 0x47 },
{ KEY_EN_EQUALS, 0x48 },
{ KEY_EN_LEFT_BRACKET, 0x43 },
{ KEY_EN_QUOTE, 0x44 },
{ KEY_EN_MENU, 0x46 },
{ KEY_EN_F11, 0x4D },
{ KEY_EN_BACKSPACE, 0x50 },
{ KEY_EN_RIGHT_BRACKET, 0x49 },
{ KEY_EN_RIGHT_SHIFT, 0x4B },
{ KEY_EN_F12, 0x4F },
{ KEY_EN_ANSI_BACK_SLASH, 0x51 }, // this one is guessed, not tested with ansi layout
{ KEY_EN_ANSI_ENTER, 0x52 },
{ KEY_EN_RIGHT_CONTROL, 0x4C },
{ KEY_EN_MEDIA_MUTE, 0x5C },
{ KEY_EN_INSERT, 0x54 },
{ KEY_EN_DELETE, 0x55 },
{ KEY_EN_LEFT_ARROW, 0x56 },
{ KEY_EN_HOME, 0x58 },
{ KEY_EN_END, 0x59 },
{ KEY_EN_UP_ARROW, 0x5A },
{ KEY_EN_DOWN_ARROW, 0x5B },
{ KEY_EN_PAGE_UP, 0x5D },
{ KEY_EN_PAGE_DOWN, 0x5E },
{ KEY_EN_RIGHT_ARROW, 0x5F },
}
}
},
};

10
OpenRGB.pro
View file

@ -724,15 +724,15 @@ HEADERS +=
Controllers/RoccatController/RGBController_RoccatKoneAimo.h \
Controllers/RoccatController/RGBController_RoccatKova.h \
Controllers/RoccatController/RGBController_RoccatSenseAimo.h \
Controllers/RoccatController/RGBController_RoccatVulcanAimo.h \
Controllers/RoccatController/RGBController_RoccatVulcanKeyboard.h \
Controllers/RoccatController/RoccatBurstController.h \
Controllers/RoccatController/RoccatEloController.h \
Controllers/RoccatController/RoccatHordeAimoController.h \
Controllers/RoccatController/RoccatKoneAimoController.h \
Controllers/RoccatController/RoccatKovaController.h \
Controllers/RoccatController/RoccatSenseAimoController.h \
Controllers/RoccatController/RoccatVulcanAimoController.h \
Controllers/RoccatController/RoccatVulcanAimoLayouts.h \
Controllers/RoccatController/RoccatVulcanKeyboardController.h \
Controllers/RoccatController/RoccatVulcanKeyboardLayouts.h \
Controllers/SapphireGPUController/SapphireNitroGlowV1Controller.h \
Controllers/SapphireGPUController/SapphireNitroGlowV3Controller.h \
Controllers/SapphireGPUController/RGBController_SapphireNitroGlowV1.h \
@ -1449,14 +1449,14 @@ SOURCES +=
Controllers/RoccatController/RGBController_RoccatKoneAimo.cpp \
Controllers/RoccatController/RGBController_RoccatKova.cpp \
Controllers/RoccatController/RGBController_RoccatSenseAimo.cpp \
Controllers/RoccatController/RGBController_RoccatVulcanAimo.cpp \
Controllers/RoccatController/RGBController_RoccatVulcanKeyboard.cpp \
Controllers/RoccatController/RoccatBurstController.cpp \
Controllers/RoccatController/RoccatEloController.cpp \
Controllers/RoccatController/RoccatHordeAimoController.cpp \
Controllers/RoccatController/RoccatKoneAimoController.cpp \
Controllers/RoccatController/RoccatKovaController.cpp \
Controllers/RoccatController/RoccatSenseAimoController.cpp \
Controllers/RoccatController/RoccatVulcanAimoController.cpp \
Controllers/RoccatController/RoccatVulcanKeyboardController.cpp \
Controllers/RoccatController/RoccatControllerDetect.cpp \
Controllers/SapphireGPUController/SapphireNitroGlowV1Controller.cpp \
Controllers/SapphireGPUController/SapphireNitroGlowV3Controller.cpp \