diff --git a/Controllers/RoccatController/RoccatControllerDetect.cpp b/Controllers/RoccatController/RoccatControllerDetect.cpp index 7b2706c0..a3cb3f1a 100644 --- a/Controllers/RoccatController/RoccatControllerDetect.cpp +++ b/Controllers/RoccatController/RoccatControllerDetect.cpp @@ -1,8 +1,18 @@ +/*---------------------------------------------------------*\ +| RoccatControllerDetect.cpp | +| | +| Detector for Roccat devices | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + #include "Detector.h" #include "RoccatBurstController.h" #include "RoccatBurstProAirController.h" #include "RoccatKoneAimoController.h" #include "RoccatKoneProController.h" +#include "RoccatKoneProAirController.h" #include "RoccatSenseAimoController.h" #include "RoccatVulcanKeyboardController.h" #include "RoccatKovaController.h" @@ -13,6 +23,7 @@ #include "RGBController_RoccatHordeAimo.h" #include "RGBController_RoccatKoneAimo.h" #include "RGBController_RoccatKonePro.h" +#include "RGBController_RoccatKoneProAir.h" #include "RGBController_RoccatSenseAimo.h" #include "RGBController_RoccatVulcanKeyboard.h" #include "RGBController_RoccatKova.h" @@ -31,13 +42,15 @@ /*-----------------------------------------------------------------*\ | MICE | \*-----------------------------------------------------------------*/ -#define ROCCAT_BURST_CORE_PID 0x2DE6 -#define ROCCAT_BURST_PRO_PID 0x2DE1 -#define ROCCAT_BURST_PRO_AIR_PID 0x2CA6 -#define ROCCAT_KONE_AIMO_PID 0x2E27 -#define ROCCAT_KONE_AIMO_16K_PID 0x2E2C -#define ROCCAT_KONE_PRO_PID 0x2C88 -#define ROCCAT_KOVA_PID 0x2CEE +#define ROCCAT_BURST_CORE_PID 0x2DE6 +#define ROCCAT_BURST_PRO_PID 0x2DE1 +#define ROCCAT_BURST_PRO_AIR_PID 0x2CA6 +#define ROCCAT_KONE_AIMO_PID 0x2E27 +#define ROCCAT_KONE_AIMO_16K_PID 0x2E2C +#define ROCCAT_KONE_PRO_PID 0x2C88 +#define ROCCAT_KONE_PRO_AIR_PID 0x2C8E +#define ROCCAT_KONE_PRO_AIR_WIRED_PID 0x2C92 +#define ROCCAT_KOVA_PID 0x2CEE /*-----------------------------------------------------------------*\ | MOUSEMATS | @@ -224,6 +237,19 @@ void DetectRoccatKoneProControllers(hid_device_info* info, const std::string& na } } +void DetectRoccatKoneProAirControllers(hid_device_info* info, const std::string& name) +{ + hid_device* dev = hid_open_path(info->path); + + if(dev) + { + RoccatKoneProAirController * controller = new RoccatKoneProAirController(dev, *info); + RGBController_RoccatKoneProAir * rgb_controller = new RGBController_RoccatKoneProAir(controller); + rgb_controller->name = name; + ResourceManager::get()->RegisterRGBController(rgb_controller); + } +} + void DetectRoccatKovaControllers(hid_device_info* info, const std::string& name) { hid_device* dev = hid_open_path(info->path); @@ -289,6 +315,8 @@ REGISTER_HID_DETECTOR_IPU("Roccat Kone Aimo", DetectRoccatMouseCon REGISTER_HID_DETECTOR_IPU("Roccat Kone Aimo 16K", DetectRoccatMouseControllers, ROCCAT_VID, ROCCAT_KONE_AIMO_16K_PID, 0, 0x0B, 0 ); REGISTER_HID_DETECTOR_IPU("Roccat Kone Pro", DetectRoccatKoneProControllers, ROCCAT_VID, ROCCAT_KONE_PRO_PID, 3, 0xFF01, 1 ); +REGISTER_HID_DETECTOR_IPU("Roccat Kone Pro Air", DetectRoccatKoneProAirControllers, ROCCAT_VID, ROCCAT_KONE_PRO_AIR_PID, 2, 0xFF00, 1 ); +REGISTER_HID_DETECTOR_IPU("Roccat Kone Pro Air (Wired)", DetectRoccatKoneProAirControllers, ROCCAT_VID, ROCCAT_KONE_PRO_AIR_WIRED_PID, 1, 0xFF13, 1 ); REGISTER_HID_DETECTOR_IPU("Roccat Kova", DetectRoccatKovaControllers, ROCCAT_VID, ROCCAT_KOVA_PID, 0, 0x0B, 0 ); diff --git a/Controllers/RoccatController/RoccatKoneProAirController/RGBController_RoccatKoneProAir.cpp b/Controllers/RoccatController/RoccatKoneProAirController/RGBController_RoccatKoneProAir.cpp new file mode 100644 index 00000000..1d7eaba0 --- /dev/null +++ b/Controllers/RoccatController/RoccatKoneProAirController/RGBController_RoccatKoneProAir.cpp @@ -0,0 +1,194 @@ +/*---------------------------------------------------------*\ +| RGBController_RoccatKoneProAir.cpp | +| | +| RGBController for Roccat Kone Pro Air | +| | +| Plunti 10 Jun 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#include "RGBController_RoccatKoneProAir.h" + +/**------------------------------------------------------------------*\ + @name Roccat Kone Pro Air Mouse + @category Mouse + @type USB + @save :robot: + @direct :white_check_mark: + @effects :white_check_mark: + @detectors DetectRoccatKoneProAirControllers + @comment +\*-------------------------------------------------------------------*/ + +RGBController_RoccatKoneProAir::RGBController_RoccatKoneProAir(RoccatKoneProAirController* controller_ptr) +{ + controller = controller_ptr; + + name = "Roccat Kone Pro Air"; + vendor = "Roccat"; + type = DEVICE_TYPE_MOUSE; + description = "Roccat Kone Pro Air Mouse"; + serial = controller->GetSerialString(); + location = controller->GetDeviceLocation(); + version = controller->GetFirmwareVersion(); + + mode Direct; + Direct.name = "Direct"; + Direct.value = ROCCAT_KONE_PRO_AIR_DIRECT_MODE_VALUE; + Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; + Direct.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Direct); + + mode Off; + Off.name = "Off"; + Off.value = ROCCAT_KONE_PRO_AIR_OFF_MODE_VALUE; + Off.flags = MODE_FLAG_AUTOMATIC_SAVE; + Off.color_mode = MODE_COLORS_NONE; + modes.push_back(Off); + + mode Static; + Static.name = "Static"; + Static.value = ROCCAT_KONE_PRO_AIR_STATIC_MODE_VALUE; + Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS; + Static.color_mode = MODE_COLORS_PER_LED; + Static.brightness = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; + Static.brightness_min = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MIN; + Static.brightness_max = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; + modes.push_back(Static); + + mode RainbowWave; + RainbowWave.name = "Rainbow Wave"; + RainbowWave.value = ROCCAT_KONE_PRO_AIR_RAINBOW_WAVE_MODE_VALUE; + RainbowWave.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + RainbowWave.color_mode = MODE_COLORS_NONE; + RainbowWave.brightness = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; + RainbowWave.brightness_min = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MIN; + RainbowWave.brightness_max = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; + RainbowWave.speed = ROCCAT_KONE_PRO_AIR_SPEED_MID; + RainbowWave.speed_min = ROCCAT_KONE_PRO_AIR_SPEED_MIN; + RainbowWave.speed_max = ROCCAT_KONE_PRO_AIR_SPEED_MAX; + modes.push_back(RainbowWave); + + mode Heartbeat; + Heartbeat.name = "Heartbeat"; + Heartbeat.value = ROCCAT_KONE_PRO_AIR_HEARTBEAT_MODE_VALUE; + Heartbeat.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Heartbeat.color_mode = MODE_COLORS_PER_LED; + Heartbeat.brightness = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; + Heartbeat.brightness_min = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MIN; + Heartbeat.brightness_max = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; + Heartbeat.speed = ROCCAT_KONE_PRO_AIR_SPEED_MID; + Heartbeat.speed_min = ROCCAT_KONE_PRO_AIR_SPEED_MIN; + Heartbeat.speed_max = ROCCAT_KONE_PRO_AIR_SPEED_MAX; + modes.push_back(Heartbeat); + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = ROCCAT_KONE_PRO_AIR_BREATHING_MODE_VALUE; + Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Breathing.color_mode = MODE_COLORS_PER_LED; + Breathing.brightness = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; + Breathing.brightness_min = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MIN; + Breathing.brightness_max = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; + Breathing.speed = ROCCAT_KONE_PRO_AIR_SPEED_MID; + Breathing.speed_min = ROCCAT_KONE_PRO_AIR_SPEED_MIN; + Breathing.speed_max = ROCCAT_KONE_PRO_AIR_SPEED_MAX; + modes.push_back(Breathing); + + mode Flashing; + Flashing.name = "Flashing"; + Flashing.value = ROCCAT_KONE_PRO_AIR_FLASHING_MODE_VALUE; + Flashing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Flashing.color_mode = MODE_COLORS_PER_LED; + Flashing.brightness = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; + Flashing.brightness_min = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MIN; + Flashing.brightness_max = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; + Flashing.speed = ROCCAT_KONE_PRO_AIR_SPEED_MID; + Flashing.speed_min = ROCCAT_KONE_PRO_AIR_SPEED_MIN; + Flashing.speed_max = ROCCAT_KONE_PRO_AIR_SPEED_MAX; + modes.push_back(Flashing); + + mode Battery; + Battery.name = "Battery"; + Battery.value = ROCCAT_KONE_PRO_AIR_BATTERY_MODE_VALUE; + Battery.flags = MODE_FLAG_AUTOMATIC_SAVE; + Battery.color_mode = MODE_COLORS_NONE; + modes.push_back(Battery); + + SetupZones(); +} + +RGBController_RoccatKoneProAir::~RGBController_RoccatKoneProAir() +{ + delete controller; +} + +void RGBController_RoccatKoneProAir::SetupZones() +{ + zone new_zone; + new_zone.name = "Mouse"; + new_zone.type = ZONE_TYPE_LINEAR; + new_zone.leds_min = ROCCAT_KONE_PRO_AIR_LED_COUNT; + new_zone.leds_max = ROCCAT_KONE_PRO_AIR_LED_COUNT; + new_zone.leds_count = ROCCAT_KONE_PRO_AIR_LED_COUNT; + new_zone.matrix_map = NULL; + zones.push_back(new_zone); + + std::string led_names[2] = + { + "Left Button", + "Right Button" + }; + + for(unsigned int i = 0; i < ROCCAT_KONE_PRO_AIR_LED_COUNT; i++) + { + led new_led; + new_led.name = led_names[i]; + leds.push_back(new_led); + } + + SetupColors(); +} + +void RGBController_RoccatKoneProAir::ResizeZone(int /*zone*/, int /*new_size*/) +{ + /*---------------------------------------------------------*\ + | This device does not support resizing zones | + \*---------------------------------------------------------*/ +} + +void RGBController_RoccatKoneProAir::DeviceUpdateLEDs() +{ + const mode& active = modes[active_mode]; + + if(active.value == ROCCAT_KONE_PRO_AIR_DIRECT_MODE_VALUE) + { + controller->SendDirect(colors); + } + else + { + controller->SetMode(colors, active.value, active.speed, active.brightness, active.flags); + } +} + +void RGBController_RoccatKoneProAir::UpdateZoneLEDs(int /*zone_idx*/) +{ + DeviceUpdateLEDs(); +} + +void RGBController_RoccatKoneProAir::UpdateSingleLED(int /*led_idx*/) +{ + DeviceUpdateLEDs(); +} + +void RGBController_RoccatKoneProAir::DeviceUpdateMode() +{ + const mode& active = modes[active_mode]; + + if(!(active.flags & MODE_FLAG_HAS_PER_LED_COLOR)) + { + DeviceUpdateLEDs(); + } +} diff --git a/Controllers/RoccatController/RoccatKoneProAirController/RGBController_RoccatKoneProAir.h b/Controllers/RoccatController/RoccatKoneProAirController/RGBController_RoccatKoneProAir.h new file mode 100644 index 00000000..f007a454 --- /dev/null +++ b/Controllers/RoccatController/RoccatKoneProAirController/RGBController_RoccatKoneProAir.h @@ -0,0 +1,34 @@ +/*---------------------------------------------------------*\ +| RGBController_RoccatKoneProAir.h | +| | +| RGBController for Roccat Kone Pro Air | +| | +| Plunti 10 Jun 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#pragma once + +#include "RGBController.h" +#include "RoccatKoneProAirController.h" + +class RGBController_RoccatKoneProAir : public RGBController +{ +public: + RGBController_RoccatKoneProAir(RoccatKoneProAirController* controller_ptr); + ~RGBController_RoccatKoneProAir(); + + void SetupZones(); + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void DeviceUpdateMode(); + +private: + RoccatKoneProAirController* controller; +}; diff --git a/Controllers/RoccatController/RoccatKoneProAirController/RoccatKoneProAirController.cpp b/Controllers/RoccatController/RoccatKoneProAirController/RoccatKoneProAirController.cpp new file mode 100644 index 00000000..6dd280e8 --- /dev/null +++ b/Controllers/RoccatController/RoccatKoneProAirController/RoccatKoneProAirController.cpp @@ -0,0 +1,123 @@ +/*---------------------------------------------------------*\ +| RoccatKoneProAirController.cpp | +| | +| Driver for Roccat Kone Pro Air | +| | +| Plunti 10 Jun 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#include +#include "RoccatKoneProAirController.h" + +RoccatKoneProAirController::RoccatKoneProAirController(hid_device* dev_handle, const hid_device_info& info) +{ + dev = dev_handle; + version = ""; + location = info.path; + + wchar_t serial_string[128]; + int ret = hid_get_serial_number_string(dev, serial_string, 128); + + if(ret != 0) + { + serial_number = ""; + } + else + { + std::wstring return_wstring = serial_string; + serial_number = std::string(return_wstring.begin(), return_wstring.end()); + } +} + +RoccatKoneProAirController::~RoccatKoneProAirController() +{ + hid_close(dev); +} + +std::string RoccatKoneProAirController::GetFirmwareVersion() +{ + return version; +} + +std::string RoccatKoneProAirController::GetSerialString() +{ + return serial_number; +} + +std::string RoccatKoneProAirController::GetDeviceLocation() +{ + return("HID: " + location); +} + +void RoccatKoneProAirController::SendDirect(std::vector colors) +{ + SendRGB(true, colors, ROCCAT_KONE_PRO_AIR_DIRECT_MODE_VALUE, ROCCAT_KONE_PRO_AIR_SPEED_MAX, ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX); +} + +void RoccatKoneProAirController::SetMode(std::vector colors, unsigned char mode_value, unsigned char speed, unsigned char brightness, unsigned int mode_flags) +{ + /*---------------------------------------------------------*\ + | 1. Read settings | + \*---------------------------------------------------------*/ + unsigned char active_settings[ROCCAT_KONE_PRO_AIR_SETTINGS_READ_PACKET_LENGTH]; + + unsigned char settings_request[] = {0x00, 0x90, 0x00, 0x04, 0x00, 0x18, 0x25, 0x51, 0x32}; + hid_write(dev, settings_request, sizeof(settings_request)); + + do + { + hid_read(dev, active_settings, ROCCAT_KONE_PRO_AIR_SETTINGS_READ_PACKET_LENGTH); + } while( (active_settings[0] != 0x90) || (active_settings[2] != 0x26) ); + + /*---------------------------------------------------------*\ + | 2. Send settings and select profile | + \*---------------------------------------------------------*/ + unsigned char usb_buf[ROCCAT_KONE_PRO_AIR_SETTINGS_WRITE_PACKET_LENGTH]; + memset(usb_buf, 0x00, ROCCAT_KONE_PRO_AIR_SETTINGS_WRITE_PACKET_LENGTH); + + usb_buf[1] = 0x10; + usb_buf[2] = 0x50; + usb_buf[3] = 0x14; + memcpy(usb_buf + 5, active_settings + 10, 19); + usb_buf[24] = active_settings[41]; + + hid_write(dev, usb_buf, ROCCAT_KONE_PRO_AIR_SETTINGS_WRITE_PACKET_LENGTH); + + /*---------------------------------------------------------*\ + | 3. Send RGB | + \*---------------------------------------------------------*/ + SendRGB(false, + colors, + mode_value, + mode_flags & MODE_FLAG_HAS_SPEED ? speed : ROCCAT_KONE_PRO_AIR_SPEED_MAX, + mode_flags & MODE_FLAG_HAS_BRIGHTNESS ? brightness : ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX + ); +} + +void RoccatKoneProAirController::SendRGB(bool direct, std::vector colors, unsigned char mode_value, unsigned char speed, unsigned char brightness) +{ + unsigned char usb_buf[ROCCAT_KONE_PRO_AIR_RGB_PACKET_LENGTH]; + memset(usb_buf, 0x00, ROCCAT_KONE_PRO_AIR_RGB_PACKET_LENGTH); + + usb_buf[1] = 0x10; + usb_buf[2] = direct ? 0x10 : 0x50; + usb_buf[3] = 0x0B; + usb_buf[4] = direct ? 0x00 : 0x01; + usb_buf[5] = mode_value; + usb_buf[6] = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; // Explicit brightness for first LED, not used by OpenRGB + usb_buf[7] = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; // Explicit brightness for second LED, not used by OpenRGB + usb_buf[8] = brightness; + usb_buf[9] = speed; + + for(unsigned int i = 0; i < colors.size(); i++) + { + usb_buf[10 + 3 * i] = RGBGetRValue(colors[i]); + usb_buf[11 + 3 * i] = RGBGetGValue(colors[i]); + usb_buf[12 + 3 * i] = RGBGetBValue(colors[i]); + } + + hid_write(dev, usb_buf, ROCCAT_KONE_PRO_AIR_RGB_PACKET_LENGTH); +} diff --git a/Controllers/RoccatController/RoccatKoneProAirController/RoccatKoneProAirController.h b/Controllers/RoccatController/RoccatKoneProAirController/RoccatKoneProAirController.h new file mode 100644 index 00000000..775165f7 --- /dev/null +++ b/Controllers/RoccatController/RoccatKoneProAirController/RoccatKoneProAirController.h @@ -0,0 +1,63 @@ +/*---------------------------------------------------------*\ +| RoccatKoneProAirController.h | +| | +| Driver for Roccat Kone Pro Air | +| | +| Plunti 10 Jun 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#pragma once + +#include +#include "RGBController.h" + +#define ROCCAT_KONE_PRO_AIR_RGB_PACKET_LENGTH 16 +#define ROCCAT_KONE_PRO_AIR_SETTINGS_WRITE_PACKET_LENGTH 25 +#define ROCCAT_KONE_PRO_AIR_SETTINGS_READ_PACKET_LENGTH 42 +#define ROCCAT_KONE_PRO_AIR_LED_COUNT 2 + +enum +{ + ROCCAT_KONE_PRO_AIR_DIRECT_MODE_VALUE = 0x09, + ROCCAT_KONE_PRO_AIR_OFF_MODE_VALUE = 0x00, + ROCCAT_KONE_PRO_AIR_STATIC_MODE_VALUE = 0x01, + ROCCAT_KONE_PRO_AIR_RAINBOW_WAVE_MODE_VALUE = 0x06, + ROCCAT_KONE_PRO_AIR_HEARTBEAT_MODE_VALUE = 0x05, + ROCCAT_KONE_PRO_AIR_BREATHING_MODE_VALUE = 0x02, + ROCCAT_KONE_PRO_AIR_FLASHING_MODE_VALUE = 0x08, + ROCCAT_KONE_PRO_AIR_BATTERY_MODE_VALUE = 0x0A +}; + +enum +{ + ROCCAT_KONE_PRO_AIR_SPEED_MIN = 0x01, + ROCCAT_KONE_PRO_AIR_SPEED_MAX = 0x0B, + ROCCAT_KONE_PRO_AIR_SPEED_MID = (ROCCAT_KONE_PRO_AIR_SPEED_MAX - ROCCAT_KONE_PRO_AIR_SPEED_MIN) / 2, + ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MIN = 0x00, + ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX = 0x64 +}; + +class RoccatKoneProAirController +{ +public: + RoccatKoneProAirController(hid_device* dev_handle, const hid_device_info& info); + ~RoccatKoneProAirController(); + + std::string GetSerialString(); + std::string GetDeviceLocation(); + std::string GetFirmwareVersion(); + + void SendDirect(std::vector colors); + void SetMode(std::vector colors, unsigned char mode_value, unsigned char speed, unsigned char brightness, unsigned int mode_flags); + +private: + hid_device* dev; + std::string location; + std::string serial_number; + std::string version; + + void SendRGB(bool direct, std::vector colors, unsigned char mode_value, unsigned char speed, unsigned char brightness); +};