mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-07-29 06:26:15 -04:00
Code Issues Packages Projects Releases Wiki Activity

Split HyperX keyboard detector file into individual detector files

Browse Source
This commit is contained in:
Adam Honse
2026-07-22 00:42:16 -05:00
parent 878f32fccf
commit 56df76dbfc
9 changed files with 375 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
Controllers/HyperXKeyboardController/HyperXAlloyElite2Controller/HyperXAlloyElite2ControllerDetect.cpp Normal file
View File

@@ -0,0 +1,51 @@
/*---------------------------------------------------------*\
| HyperXAlloyElite2ControllerDetect.cpp |
| |
| Driver for HyperX Alloy Elite 2 keyboards |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "DetectionManager.h"
#include "HyperXAlloyElite2Controller.h"
#include "RGBController_HyperXAlloyElite2.h"
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs |
\*---------------------------------------------------------*/
#define HYPERX_KEYBOARD_VID 0x0951
#define HYPERX_ALLOY_ELITE_2_PID 0x1711
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs (HP) |
\*---------------------------------------------------------*/
#define HP_KEYBOARD_VID 0x03F0
#define HYPERX_ALLOY_ELITE_2_HP_PID 0x058F
DetectedControllers DetectHyperXAlloyElite2(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXAlloyElite2Controller* controller = new HyperXAlloyElite2Controller(dev, info->path, name);
RGBController_HyperXAlloyElite2* rgb_controller = new RGBController_HyperXAlloyElite2(controller);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
#ifdef _WIN32
REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2", DetectHyperXAlloyElite2, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID, 3, 0xFF90);
REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2 (HP)", DetectHyperXAlloyElite2, HP_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_HP_PID, 3, 0xFF90);
#else
REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2", DetectHyperXAlloyElite2, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID, 0);
REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2 (HP)", DetectHyperXAlloyElite2, HP_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_HP_PID, 0);
#endif

39
Controllers/HyperXKeyboardController/HyperXAlloyEliteController/HyperXAlloyEliteControllerDetect.cpp Normal file
View File

@@ -0,0 +1,39 @@
/*---------------------------------------------------------*\
| HyperXAlloyEliteControllerDetect.cpp |
| |
| Driver for HyperX Alloy Elite keyboards |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "DetectionManager.h"
#include "HyperXAlloyEliteController.h"
#include "RGBController_HyperXAlloyElite.h"
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs |
\*---------------------------------------------------------*/
#define HYPERX_KEYBOARD_VID 0x0951
#define HYPERX_ALLOY_ELITE_PID 0x16BE
DetectedControllers DetectHyperXAlloyElite(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXAlloyEliteController* controller = new HyperXAlloyEliteController(dev, info->path, name);
RGBController_HyperXAlloyElite* rgb_controller = new RGBController_HyperXAlloyElite(controller);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite RGB", DetectHyperXAlloyElite, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID, 2, 0xFF01);

39
Controllers/HyperXKeyboardController/HyperXAlloyFPSController/HyperXAlloyFPSControllerDetect.cpp Normal file
View File

@@ -0,0 +1,39 @@
/*---------------------------------------------------------*\
| HyperXAlloyFPSControllerDetect.cpp |
| |
| Driver for HyperX Alloy FPS keyboards |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "DetectionManager.h"
#include "HyperXAlloyFPSController.h"
#include "RGBController_HyperXAlloyFPS.h"
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs |
\*---------------------------------------------------------*/
#define HYPERX_KEYBOARD_VID 0x0951
#define HYPERX_ALLOY_FPS_RGB_PID 0x16DC
DetectedControllers DetectHyperXAlloyFPS(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXAlloyFPSController* controller = new HyperXAlloyFPSController(dev, info->path, name);
RGBController_HyperXAlloyFPS* rgb_controller = new RGBController_HyperXAlloyFPS(controller);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
REGISTER_HID_DETECTOR_IP("HyperX Alloy FPS RGB", DetectHyperXAlloyFPS, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_FPS_RGB_PID, 2, 0xFF01);

71
Controllers/HyperXKeyboardController/HyperXAlloyOrigins60and65Controller/HyperXAlloyOrigins60and65ControllerDetect.cpp Normal file
View File

@@ -0,0 +1,71 @@
/*---------------------------------------------------------*\
| HyperXAlloyOrigins60and65ControllerDetect.cpp |
| |
| Driver for HyperX Alloy Origins 60 and 65 keyboards |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "DetectionManager.h"
#include "HyperXAlloyOrigins60and65Controller.h"
#include "RGBController_HyperXAlloyOrigins60and65.h"
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs |
\*---------------------------------------------------------*/
#define HYPERX_KEYBOARD_VID 0x0951
#define HYPERX_ALLOY_ORIGINS_60_PID 0x1734
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs (HP) |
\*---------------------------------------------------------*/
#define HP_KEYBOARD_VID 0x03F0
#define HYPERX_ALLOY_ORIGINS_60_HP_PID 0x0C8E
#define HYPERX_ALLOY_ORIGINS_65_HP_PID 0x038F
AlloyOrigins60and65MappingLayoutType GetAlloyOrigins60and65MappingLayoutType(int pid)
{
switch(pid)
{
case HYPERX_ALLOY_ORIGINS_60_PID:
case HYPERX_ALLOY_ORIGINS_60_HP_PID:
return ALLOY_ORIGINS_60_LAYOUT;
case HYPERX_ALLOY_ORIGINS_65_HP_PID:
return ALLOY_ORIGINS_65_LAYOUT;
default:
return ALLOY_ORIGINS_60_LAYOUT;
}
}
DetectedControllers DetectHyperXAlloyOrigins60and65(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXAlloyOrigins60and65Controller* controller = new HyperXAlloyOrigins60and65Controller(dev, info->path, name);
AlloyOrigins60and65MappingLayoutType layout = GetAlloyOrigins60and65MappingLayoutType(info->product_id);
RGBController_HyperXAlloyOrigins60and65* rgb_controller = new RGBController_HyperXAlloyOrigins60and65(controller, layout);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
#ifdef _WIN32
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60", DetectHyperXAlloyOrigins60and65, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_60_PID, 3);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60 (HP)", DetectHyperXAlloyOrigins60and65, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_60_HP_PID, 3);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 65 (HP)", DetectHyperXAlloyOrigins60and65, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_65_HP_PID, 3);
#else
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60", DetectHyperXAlloyOrigins60and65, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_60_PID, 0);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60 (HP)", DetectHyperXAlloyOrigins60and65, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_60_HP_PID, 0);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 65 (HP)", DetectHyperXAlloyOrigins60and65, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_65_HP_PID, 0);
#endif

51
Controllers/HyperXKeyboardController/HyperXAlloyOriginsController/HyperXAlloyOriginsControllerDetect.cpp Normal file
View File

@@ -0,0 +1,51 @@
/*---------------------------------------------------------*\
| HyperXAlloyOriginsControllerDetect.cpp |
| |
| Driver for HyperX Alloy Origins keyboards |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "DetectionManager.h"
#include "HyperXAlloyOriginsController.h"
#include "RGBController_HyperXAlloyOrigins.h"
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs |
\*---------------------------------------------------------*/
#define HYPERX_KEYBOARD_VID 0x0951
#define HYPERX_ALLOY_ORIGINS_PID 0x16E5
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs (HP) |
\*---------------------------------------------------------*/
#define HP_KEYBOARD_VID 0x03F0
#define HYPERX_ALLOY_ORIGINS_HP_PID 0x0591
DetectedControllers DetectHyperXAlloyOrigins(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXAlloyOriginsController* controller = new HyperXAlloyOriginsController(dev, info->path, name);
RGBController_HyperXAlloyOrigins* rgb_controller = new RGBController_HyperXAlloyOrigins(controller);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
#ifdef _WIN32
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins", DetectHyperXAlloyOrigins, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID, 3);
REGISTER_HID_DETECTOR_IP("HyperX Alloy Origins (HP)", DetectHyperXAlloyOrigins, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_HP_PID, 3, 0xFF90);
#else
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins", DetectHyperXAlloyOrigins, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID, 0);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins (HP)", DetectHyperXAlloyOrigins, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_HP_PID, 0);
#endif

46
Controllers/HyperXKeyboardController/HyperXAlloyOriginsCoreController/HyperXAlloyOriginsCoreControllerDetect.cpp Normal file
View File

@@ -0,0 +1,46 @@
/*---------------------------------------------------------*\
| HyperXAlloyOriginsCoreControllerDetect.cpp |
| |
| Driver for HyperX Alloy Origins Core keyboards |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "DetectionManager.h"
#include "HyperXAlloyOriginsCoreController.h"
#include "RGBController_HyperXAlloyOriginsCore.h"
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs |
\*---------------------------------------------------------*/
#define HYPERX_KEYBOARD_VID 0x0951
#define HYPERX_ALLOY_ORIGINS_CORE_PID 0x16E6
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs (HP) |
\*---------------------------------------------------------*/
#define HP_KEYBOARD_VID 0x03F0
#define HYPERX_ALLOY_ORIGINS_CORE_HP_PID 0x098F
DetectedControllers DetectHyperXAlloyOriginsCore(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXAlloyOriginsCoreController* controller = new HyperXAlloyOriginsCoreController(dev, info, name);
RGBController_HyperXAlloyOriginsCore* rgb_controller = new RGBController_HyperXAlloyOriginsCore(controller);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core", DetectHyperXAlloyOriginsCore, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_PID, 2);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core (HP)", DetectHyperXAlloyOriginsCore, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_HP_PID, 2);

39
Controllers/HyperXKeyboardController/HyperXEve1800Controller/HyperXEve1800ControllerDetect.cpp Normal file
View File

@@ -0,0 +1,39 @@
/*---------------------------------------------------------*\
| HyperXEve1800ControllerDetect.cpp |
| |
| Driver for HyperX Eve 1800 keyboards |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "DetectionManager.h"
#include "HyperXEve1800Controller.h"
#include "RGBController_HyperXEve1800.h"
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs (HP) |
\*---------------------------------------------------------*/
#define HP_KEYBOARD_VID 0x03F0
#define HYPERX_EVE_1800_HP_PID 0x08C2
DetectedControllers DetectHyperXEve1800(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXEve1800Controller* controller = new HyperXEve1800Controller(dev, info->path, name);
RGBController_HyperXEve1800* rgb_controller = new RGBController_HyperXEve1800(controller);
detected_controllers.push_back(rgb_controller);
}
return detected_controllers;
}
REGISTER_HID_DETECTOR_I("HyperX Eve 1800 (HP)", DetectHyperXEve1800, HP_KEYBOARD_VID, HYPERX_EVE_1800_HP_PID, 2);

242
Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp
View File

@@ -1,242 +0,0 @@
/*---------------------------------------------------------*\
| HyperXKeyboardControllerDetect.cpp |
| |
| Driver for HyperX keyboards |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "DetectionManager.h"
#include "HyperXAlloyEliteController.h"
#include "HyperXAlloyElite2Controller.h"
#include "HyperXAlloyFPSController.h"
#include "HyperXAlloyOriginsController.h"
#include "HyperXAlloyOriginsCoreController.h"
#include "HyperXAlloyOrigins60and65Controller.h"
#include "HyperXEve1800Controller.h"
#include "HyperXOrigins2_65Controller.h"
#include "RGBController_HyperXAlloyElite.h"
#include "RGBController_HyperXAlloyElite2.h"
#include "RGBController_HyperXAlloyFPS.h"
#include "RGBController_HyperXAlloyOrigins.h"
#include "RGBController_HyperXAlloyOriginsCore.h"
#include "RGBController_HyperXAlloyOrigins60and65.h"
#include "RGBController_HyperXEve1800.h"
#include "RGBController_HyperXOrigins2_65.h"
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs |
\*---------------------------------------------------------*/
#define HYPERX_KEYBOARD_VID 0x0951
#define HYPERX_ALLOY_ELITE_PID 0x16BE
#define HYPERX_ALLOY_ELITE_2_PID 0x1711
#define HYPERX_ALLOY_FPS_RGB_PID 0x16DC
#define HYPERX_ALLOY_ORIGINS_PID 0x16E5
#define HYPERX_ALLOY_ORIGINS_CORE_PID 0x16E6
#define HYPERX_ALLOY_ORIGINS_60_PID 0x1734
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs (HP) |
\*---------------------------------------------------------*/
#define HP_KEYBOARD_VID 0x03F0
#define HYPERX_ALLOY_ELITE_2_HP_PID 0x058F
#define HYPERX_ALLOY_ORIGINS_60_HP_PID 0x0C8E
#define HYPERX_ALLOY_ORIGINS_65_HP_PID 0x038F
#define HYPERX_ALLOY_ORIGINS_CORE_HP_PID 0x098F
#define HYPERX_ALLOY_ORIGINS_HP_PID 0x0591
#define HYPERX_EVE_1800_HP_PID 0x08C2
#define HYPERX_ORIGINS_2_65_HP_PID 0x0CC2
AlloyOrigins60and65MappingLayoutType GetAlloyOrigins60and65MappingLayoutType(int pid)
{
switch(pid)
{
case HYPERX_ALLOY_ORIGINS_60_PID:
case HYPERX_ALLOY_ORIGINS_60_HP_PID:
return ALLOY_ORIGINS_60_LAYOUT;
case HYPERX_ALLOY_ORIGINS_65_HP_PID:
return ALLOY_ORIGINS_65_LAYOUT;
default:
return ALLOY_ORIGINS_60_LAYOUT;
}
}
DetectedControllers DetectHyperXAlloyElite(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXAlloyEliteController* controller = new HyperXAlloyEliteController(dev, info->path, name);
RGBController_HyperXAlloyElite* rgb_controller = new RGBController_HyperXAlloyElite(controller);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
DetectedControllers DetectHyperXAlloyElite2(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXAlloyElite2Controller* controller = new HyperXAlloyElite2Controller(dev, info->path, name);
RGBController_HyperXAlloyElite2* rgb_controller = new RGBController_HyperXAlloyElite2(controller);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
DetectedControllers DetectHyperXAlloyFPS(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXAlloyFPSController* controller = new HyperXAlloyFPSController(dev, info->path, name);
RGBController_HyperXAlloyFPS* rgb_controller = new RGBController_HyperXAlloyFPS(controller);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
DetectedControllers DetectHyperXAlloyOrigins(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXAlloyOriginsController* controller = new HyperXAlloyOriginsController(dev, info->path, name);
RGBController_HyperXAlloyOrigins* rgb_controller = new RGBController_HyperXAlloyOrigins(controller);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
DetectedControllers DetectHyperXAlloyOriginsCore(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXAlloyOriginsCoreController* controller = new HyperXAlloyOriginsCoreController(dev, info, name);
RGBController_HyperXAlloyOriginsCore* rgb_controller = new RGBController_HyperXAlloyOriginsCore(controller);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
DetectedControllers DetectHyperXAlloyOrigins60and65(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXAlloyOrigins60and65Controller* controller = new HyperXAlloyOrigins60and65Controller(dev, info->path, name);
AlloyOrigins60and65MappingLayoutType layout = GetAlloyOrigins60and65MappingLayoutType(info->product_id);
RGBController_HyperXAlloyOrigins60and65* rgb_controller = new RGBController_HyperXAlloyOrigins60and65(controller, layout);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
DetectedControllers DetectHyperXOrigins2_65(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXOrigins2_65Controller* controller = new HyperXOrigins2_65Controller(dev, info->path, name);
RGBController_HyperXOrigins2_65* rgb_controller = new RGBController_HyperXOrigins2_65(controller);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
DetectedControllers DetectHyperXEve1800(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXEve1800Controller* controller = new HyperXEve1800Controller(dev, info->path, name);
RGBController_HyperXEve1800* rgb_controller = new RGBController_HyperXEve1800(controller);
detected_controllers.push_back(rgb_controller);
}
return detected_controllers;
}
REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite RGB", DetectHyperXAlloyElite, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("HyperX Alloy FPS RGB", DetectHyperXAlloyFPS, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_FPS_RGB_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core", DetectHyperXAlloyOriginsCore, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_PID, 2);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core (HP)", DetectHyperXAlloyOriginsCore, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_HP_PID, 2);
REGISTER_HID_DETECTOR_I("HyperX Origins 2 65 (HP)", DetectHyperXOrigins2_65, HP_KEYBOARD_VID, HYPERX_ORIGINS_2_65_HP_PID, 3);
REGISTER_HID_DETECTOR_I("HyperX Eve 1800 (HP)", DetectHyperXEve1800, HP_KEYBOARD_VID, HYPERX_EVE_1800_HP_PID, 2);
#ifdef _WIN32
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins", DetectHyperXAlloyOrigins, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID, 3);
REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2", DetectHyperXAlloyElite2, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID, 3, 0xFF90);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60", DetectHyperXAlloyOrigins60and65, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_60_PID, 3);
REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2 (HP)", DetectHyperXAlloyElite2, HP_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_HP_PID, 3, 0xFF90);
REGISTER_HID_DETECTOR_IP("HyperX Alloy Origins (HP)", DetectHyperXAlloyOrigins, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_HP_PID, 3, 0xFF90);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60 (HP)", DetectHyperXAlloyOrigins60and65, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_60_HP_PID, 3);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 65 (HP)", DetectHyperXAlloyOrigins60and65, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_65_HP_PID, 3);
#else
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins", DetectHyperXAlloyOrigins, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID, 0);
REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2", DetectHyperXAlloyElite2, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID, 0);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60", DetectHyperXAlloyOrigins60and65, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_60_PID, 0);
REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2 (HP)", DetectHyperXAlloyElite2, HP_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_HP_PID, 0);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins (HP)", DetectHyperXAlloyOrigins, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_HP_PID, 0);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60 (HP)", DetectHyperXAlloyOrigins60and65, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_60_HP_PID, 0);
REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 65 (HP)", DetectHyperXAlloyOrigins60and65, HP_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_65_HP_PID, 0);
#endif

39
Controllers/HyperXKeyboardController/HyperXOrigins2_65Controller/HyperXOrigins2_65ControllerDetect.cpp Normal file
View File

@@ -0,0 +1,39 @@
/*---------------------------------------------------------*\
| HyperXOrigins2_65ControllerDetect.cpp |
| |
| Driver for HyperX Origins 2 65 keyboards |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "DetectionManager.h"
#include "HyperXOrigins2_65Controller.h"
#include "RGBController_HyperXOrigins2_65.h"
/*---------------------------------------------------------*\
| HyperX keyboard vendor and product IDs (HP) |
\*---------------------------------------------------------*/
#define HP_KEYBOARD_VID 0x03F0
#define HYPERX_ORIGINS_2_65_HP_PID 0x0CC2
DetectedControllers DetectHyperXOrigins2_65(hid_device_info* info, const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev;
dev = hid_open_path(info->path);
if(dev)
{
HyperXOrigins2_65Controller* controller = new HyperXOrigins2_65Controller(dev, info->path, name);
RGBController_HyperXOrigins2_65* rgb_controller = new RGBController_HyperXOrigins2_65(controller);
detected_controllers.push_back(rgb_controller);
}
return(detected_controllers);
}
REGISTER_HID_DETECTOR_I("HyperX Origins 2 65 (HP)", DetectHyperXOrigins2_65, HP_KEYBOARD_VID, HYPERX_ORIGINS_2_65_HP_PID, 3);