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

Initial commit of standalone Razer controller

Browse Source
This commit is contained in:
Adam Honse
2021-01-22 12:59:00 -06:00
parent 4fa5b413ee
commit 6969542e2d
7 changed files with 6587 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

226
Controllers/RazerController/RGBController_Razer.cpp Normal file
View File

@@ -0,0 +1,226 @@
#include "RGBController_Razer.h"
#include "RazerDevices.h"
RGBController_Razer::RGBController_Razer(RazerController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
vendor = "Razer";
type = controller->GetDeviceType();
description = "Razer Device";
location = controller->GetDeviceLocation();
version = controller->GetFirmwareString();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = RAZER_MODE_DIRECT;
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 = RAZER_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Static;
Static.name = "Static";
Static.value = RAZER_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(1);
modes.push_back(Static);
// Breathing disabled, not yet implemented
//mode Breathing;
//Breathing.name = "Breathing";
//Breathing.value = RAZER_MODE_BREATHING;
//Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
//Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
//Breathing.colors_min = 1;
//Breathing.colors_max = 2;
//Breathing.colors.resize(1);
//modes.push_back(Breathing);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = RAZER_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = 0;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
// Wave disabled until proper detection
//mode Wave;
//Wave.name = "Wave";
//Wave.value = RAZER_MODE_WAVE;
//Wave.flags = 0;
//Wave.color_mode = MODE_COLORS_NONE;
//modes.push_back(Wave);
// Reactive disabled, not yet implemented
//mode Reactive;
//Reactive.name = "Reactive";
//Reactive.value = RAZER_MODE_REACTIVE;
//Reactive.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
//Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
//Reactive.colors_min = 1;
//Reactive.colors_max = 1;
//Reactive.colors.resize(1);
//modes.push_back(Reactive);
SetupZones();
}
RGBController_Razer::~RGBController_Razer()
{
}
void RGBController_Razer::SetupZones()
{
unsigned int device_index = controller->GetDeviceIndex();
/*---------------------------------------------------------*\
| Fill in zone information based on device table |
\*---------------------------------------------------------*/
for(unsigned int zone_id = 0; zone_id < RAZER_MAX_ZONES; zone_id++)
{
if(device_list[device_index]->zones[zone_id] != NULL)
{
zone new_zone;
new_zone.name = device_list[device_index]->zones[zone_id]->name;
new_zone.type = device_list[device_index]->zones[zone_id]->type;
new_zone.leds_count = device_list[device_index]->zones[zone_id]->rows * device_list[device_index]->zones[zone_id]->cols;
new_zone.leds_min = new_zone.leds_count;
new_zone.leds_max = new_zone.leds_count;
if(new_zone.type == ZONE_TYPE_MATRIX)
{
matrix_map_type * new_map = new matrix_map_type;
new_zone.matrix_map = new_map;
new_map->height = device_list[device_index]->zones[zone_id]->rows;
new_map->width = device_list[device_index]->zones[zone_id]->cols;
new_map->map = new unsigned int[new_map->height * new_map->width];
for(unsigned int y = 0; y < new_map->height; y++)
{
for(unsigned int x = 0; x < new_map->width; x++)
{
new_map->map[(y * new_map->width) + x] = (y * new_map->width) + x;
}
}
}
else
{
new_zone.matrix_map = NULL;
}
zones.push_back(new_zone);
}
}
for(unsigned int zone_id = 0; zone_id < zones.size(); zone_id++)
{
for (unsigned int row_id = 0; row_id < device_list[device_index]->zones[zone_id]->rows; row_id++)
{
for (unsigned int col_id = 0; col_id < device_list[device_index]->zones[zone_id]->cols; col_id++)
{
led* new_led = new led();
new_led->name = device_list[device_index]->zones[zone_id]->name;
if(zones[zone_id].leds_count > 1)
{
new_led->name.append(" LED ");
new_led->name.append(std::to_string(col_id + 1));
}
if(device_list[device_index]->keymap != NULL)
{
for(unsigned int i = 0; i < device_list[device_index]->keymap_size; i++)
{
if(zone_id == device_list[device_index]->keymap[i].zone &&
row_id == device_list[device_index]->keymap[i].row &&
col_id == device_list[device_index]->keymap[i].col)
{
new_led->name = device_list[device_index]->keymap[i].name;
}
}
}
leds.push_back(*new_led);
}
}
}
SetupColors();
}
void RGBController_Razer::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_Razer::DeviceUpdateLEDs()
{
controller->SetLEDs(&colors[0]);
}
void RGBController_Razer::UpdateZoneLEDs(int zone)
{
DeviceUpdateLEDs();
}
void RGBController_Razer::UpdateSingleLED(int led)
{
DeviceUpdateLEDs();
}
void RGBController_Razer::SetCustomMode()
{
active_mode = 0;
}
void RGBController_Razer::DeviceUpdateMode()
{
switch(modes[active_mode].value)
{
case RAZER_MODE_OFF:
controller->SetModeOff();
break;
case RAZER_MODE_STATIC:
if(modes[active_mode].colors.size() == 1)
{
unsigned char red = RGBGetRValue(modes[active_mode].colors[0]);
unsigned char grn = RGBGetGValue(modes[active_mode].colors[0]);
unsigned char blu = RGBGetBValue(modes[active_mode].colors[0]);
controller->SetModeStatic(red, grn, blu);
}
break;
case RAZER_MODE_BREATHING:
break;
case RAZER_MODE_SPECTRUM_CYCLE:
controller->SetModeSpectrumCycle();
break;
case RAZER_MODE_WAVE:
controller->SetModeWave();
break;
}
}

43
Controllers/RazerController/RGBController_Razer.h Normal file
View File

@@ -0,0 +1,43 @@
/*-----------------------------------------*\
| RGBController_Razer.h |
| |
| Generic RGB Interface for Razer devices |
| |
| Adam Honse (CalcProgrammer1) 1/22/2021 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "RazerController.h"
enum
{
RAZER_MODE_DIRECT,
RAZER_MODE_OFF,
RAZER_MODE_STATIC,
RAZER_MODE_BREATHING,
RAZER_MODE_SPECTRUM_CYCLE,
RAZER_MODE_WAVE,
RAZER_MODE_REACTIVE,
};
class RGBController_Razer : public RGBController
{
public:
RGBController_Razer(RazerController* controller_ptr);
~RGBController_Razer();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
RazerController* controller;
};

1064
Controllers/RazerController/RazerController.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

209
Controllers/RazerController/RazerController.h Normal file
View File

@@ -0,0 +1,209 @@
/*-----------------------------------------*\
| RazerController.h |
| |
| Definitions and types for Razer devices |
| |
| Adam Honse (CalcProgrammer1) 1/22/2021 |
\*-----------------------------------------*/
#include "RGBController.h"
#include <string>
#include <hidapi/hidapi.h>
#pragma once
/*---------------------------------------------------------*\
| Struct packing macro for GCC and MSVC |
\*---------------------------------------------------------*/
#ifdef __GNUC__
#define PACK( __Declaration__ ) __Declaration__ __attribute__((__packed__))
#endif
#ifdef _MSC_VER
#define PACK( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop))
#endif
/*---------------------------------------------------------*\
| Razer Command IDs |
\*---------------------------------------------------------*/
enum
{
/*-----------------------------------------------------*\
| Set Commands |
\*-----------------------------------------------------*/
RAZER_COMMAND_ID_SET_LED_STATE = 0x00,
RAZER_COMMAND_ID_SET_DEVICE_MODE = 0x04,
/*-----------------------------------------------------*\
| Get Commands |
\*-----------------------------------------------------*/
RAZER_COMMAND_ID_GET_LED_STATE = 0x80,
RAZER_COMMAND_ID_GET_FIRMWARE_VERSION = 0x81,
RAZER_COMMAND_ID_GET_SERIAL_STRING = 0x82,
RAZER_COMMAND_ID_GET_DEVICE_MODE = 0x84,
};
/*---------------------------------------------------------*\
| Razer Storage Flags |
\*---------------------------------------------------------*/
enum
{
RAZER_STORAGE_NO_SAVE = 0x00,
RAZER_STORAGE_SAVE = 0x01,
};
/*---------------------------------------------------------*\
| Razer LED IDs |
\*---------------------------------------------------------*/
enum
{
RAZER_LED_ID_ZERO = 0x00,
RAZER_LED_ID_SCROLL_WHEEL = 0x01,
RAZER_LED_ID_BATTERY = 0x03,
RAZER_LED_ID_LOGO = 0x04,
RAZER_LED_ID_BACKLIGHT = 0x05,
RAZER_LED_ID_MACRO = 0x07,
RAZER_LED_ID_GAME = 0x08,
RAZER_LED_ID_PROFILE_RED = 0x0C,
RAZER_LED_ID_PROFILE_GREEN = 0x0D,
RAZER_LED_ID_PROFILE_BLUE = 0x0E,
RAZER_LED_ID_RIGHT_SIDE = 0x10,
RAZER_LED_ID_LEFT_SIDE = 0x11,
};
/*---------------------------------------------------------*\
| Razer Report Type (taken from OpenRazer) |
\*---------------------------------------------------------*/
struct razer_rgb
{
unsigned char r,g,b;
};
union transaction_id_union
{
unsigned char id;
struct transaction_parts
{
unsigned char device : 3;
unsigned char id : 5;
} parts;
};
union command_id_union
{
unsigned char id;
struct command_id_parts
{
unsigned char direction : 1;
unsigned char id : 7;
} parts;
};
PACK(typedef struct razer_report
{
unsigned char report_id;
unsigned char status;
union transaction_id_union transaction_id;
unsigned short remaining_packets;
unsigned char protocol_type;
unsigned char data_size;
unsigned char command_class;
union command_id_union command_id;
unsigned char arguments[80];
unsigned char crc;
unsigned char reserved;
};)
class RazerController
{
public:
RazerController(hid_device* dev_handle, const char* path, unsigned short pid, std::string dev_name);
~RazerController();
unsigned int GetDeviceIndex();
device_type GetDeviceType();
std::string GetDeviceLocation();
std::string GetFirmwareString();
std::string GetName();
std::string GetSerialString();
void SetLEDs(RGBColor* colors);
void SetModeOff();
void SetModeSpectrumCycle();
void SetModeStatic(unsigned char red, unsigned char grn, unsigned char blu);
void SetModeWave();
private:
hid_device* dev;
unsigned short dev_pid;
/*---------------------------------------------------------*\
| Device-specific protocol settings |
\*---------------------------------------------------------*/
unsigned char dev_transaction_id;
unsigned char dev_led_id;
/*---------------------------------------------------------*\
| Device information strings |
\*---------------------------------------------------------*/
std::string firmware_version;
std::string location;
std::string name;
device_type type;
/*---------------------------------------------------------*\
| Index of device in Razer device list |
\*---------------------------------------------------------*/
unsigned int device_index;
/*---------------------------------------------------------*\
| HID report index for request and response |
\*---------------------------------------------------------*/
unsigned char report_index;
unsigned char response_index;
/*---------------------------------------------------------*\
| Private functions based on OpenRazer |
\*---------------------------------------------------------*/
unsigned char razer_calculate_crc(razer_report* report);
razer_report razer_create_report(unsigned char command_class, unsigned char command_id, unsigned char data_size);
razer_report razer_create_response();
razer_report razer_create_brightness_extended_matrix_report(unsigned char variable_storage, unsigned char led_id, unsigned char brightness);
razer_report razer_create_brightness_standard_report(unsigned char variable_storage, unsigned char led_id, unsigned char brightness);
razer_report razer_create_custom_frame_linear_report(unsigned char start_col, unsigned char stop_col, unsigned char* rgb_data);
razer_report razer_create_custom_frame_extended_matrix_report(unsigned char row_index, unsigned char start_col, unsigned char stop_col, unsigned char* rgb_data);
razer_report razer_create_custom_frame_standard_matrix_report(unsigned char row_index, unsigned char start_col, unsigned char stop_col, unsigned char* rgb_data);
razer_report razer_create_mode_custom_extended_matrix_report();
razer_report razer_create_mode_custom_standard_matrix_report(unsigned char variable_storage);
razer_report razer_create_mode_none_extended_matrix_report(unsigned char variable_storage, unsigned char led_id);
razer_report razer_create_mode_none_standard_matrix_report(unsigned char variable_storage, unsigned char led_id);
razer_report razer_create_mode_spectrum_cycle_extended_matrix_report(unsigned char variable_storage, unsigned char led_id);
razer_report razer_create_mode_spectrum_cycle_standard_matrix_report(unsigned char variable_storage, unsigned char led_id);
razer_report razer_create_mode_static_extended_matrix_report(unsigned char variable_storage, unsigned char led_id, unsigned char red, unsigned char grn, unsigned char blu);
razer_report razer_create_mode_static_standard_matrix_report(unsigned char variable_storage, unsigned char led_id, unsigned char red, unsigned char grn, unsigned char blu);
razer_report razer_create_mode_wave_extended_matrix_report(unsigned char variable_storage, unsigned char led_id, unsigned char direction);
razer_report razer_create_mode_wave_standard_matrix_report(unsigned char variable_storage, unsigned char led_id, unsigned char direction);
razer_report razer_create_set_led_effect_report(unsigned char variable_storage, unsigned char led_id, unsigned char effect);
razer_report razer_create_set_led_rgb_report(unsigned char variable_storage, unsigned char led_id, unsigned char* rgb_data);
std::string razer_get_firmware();
std::string razer_get_serial();
void razer_set_brightness(unsigned char brightness);
void razer_set_custom_frame(unsigned char row_index, unsigned char start_col, unsigned char stop_col, unsigned char* rgb_data);
void razer_set_mode_breathing();
void razer_set_mode_custom();
void razer_set_mode_none();
void razer_set_mode_spectrum_cycle();
void razer_set_mode_static(unsigned char red, unsigned char grn, unsigned char blu);
void razer_set_mode_wave();
int razer_usb_receive(razer_report* report);
int razer_usb_send(razer_report* report);
};

134
Controllers/RazerController/RazerControllerDetect.cpp Normal file
View File

@@ -0,0 +1,134 @@
#include "Detector.h"
#include "RazerController.h"
#include "RazerDevices.h"
#include "ResourceManager.h"
#include "RGBController.h"
#include "RGBController_Razer.h"
#include <hidapi/hidapi.h>
static bool openrazer_checked = false;
static bool openrazer_enabled = false;
/******************************************************************************************\
* *
* DetectRazerControllers *
* *
* Tests the USB address to see if a Razer controller exists there. *
* *
\******************************************************************************************/
void DetectRazerControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
/*-------------------------------------------------*\
| If the OpenRazer/OpenRazer-Win32 controller is |
| enabled, don't use this controller. |
\*-------------------------------------------------*/
if(!openrazer_checked)
{
/*-------------------------------------------------*\
| Open device disable list and read in disabled |
| device strings |
\*-------------------------------------------------*/
json detector_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("Detectors");
/*-------------------------------------------------*\
| Check for OpenRazer and OpenRazer-Win32 enable |
\*-------------------------------------------------*/
if(detector_settings.contains("detectors"))
{
if(detector_settings["detectors"].contains("OpenRazer"))
{
if(detector_settings["detectors"]["OpenRazer"] == true)
{
openrazer_enabled = true;
}
}
if(detector_settings["detectors"].contains("OpenRazer-Win32"))
{
if(detector_settings["detectors"]["OpenRazer-Win32"] == true)
{
openrazer_enabled = true;
}
}
}
/*-------------------------------------------------*\
| Set OpenRazer checked flag to prevent having to do|
| the settings lookup multiple times |
\*-------------------------------------------------*/
openrazer_checked = true;
}
if(openrazer_enabled)
{
return;
}
if(dev)
{
RazerController* controller = new RazerController(dev, info->path, info->product_id, name);
RGBController_Razer* rgb_controller = new RGBController_Razer(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
} /* DetectRazerControllers() */
/*-----------------------------------------------------------------------------------------------------*\
| Keyboards |
\*-----------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_PU("Razer Blackwidow Chroma", DetectRazerControllers, RAZER_VID, RAZER_BLACKWIDOW_CHROMA_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Blackwidow Chroma V2", DetectRazerControllers, RAZER_VID, RAZER_BLACKWIDOW_CHROMA_V2_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Blackwidow Chroma Tournament Edition", DetectRazerControllers, RAZER_VID, RAZER_BLACKWIDOW_CHROMA_TE_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Blackwidow Overwatch", DetectRazerControllers, RAZER_VID, RAZER_BLACKWIDOW_OVERWATCH_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Blackwidow X Chroma", DetectRazerControllers, RAZER_VID, RAZER_BLACKWIDOW_X_CHROMA_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Blackwidow X Chroma Tournament Edition", DetectRazerControllers, RAZER_VID, RAZER_BLACKWIDOW_X_CHROMA_TE_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Cynosa Chroma", DetectRazerControllers, RAZER_VID, RAZER_CYNOSA_CHROMA_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Cynosa Chroma V2", DetectRazerControllers, RAZER_VID, RAZER_CYNOSA_V2_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Deathstalker Chroma", DetectRazerControllers, RAZER_VID, RAZER_DEATHSTALKER_CHROMA_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Huntsman", DetectRazerControllers, RAZER_VID, RAZER_HUNTSMAN_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Huntsman Elite", DetectRazerControllers, RAZER_VID, RAZER_HUNTSMAN_ELITE_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Huntsman Tournament Edition", DetectRazerControllers, RAZER_VID, RAZER_HUNTSMAN_TE_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Ornata Chroma", DetectRazerControllers, RAZER_VID, RAZER_ORNATA_CHROMA_PID, 1, 2);
/*-----------------------------------------------------------------------------------------------------*\
| Keypads |
\*-----------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_PU("Razer Orbweaver Chroma", DetectRazerControllers, RAZER_VID, RAZER_ORBWEAVER_CHROMA_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Tartarus Chroma", DetectRazerControllers, RAZER_VID, RAZER_TARTARUS_CHROMA_PID, 1, 2);
/*-----------------------------------------------------------------------------------------------------*\
| Laptops |
\*-----------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_PU("Razer Blade Pro", DetectRazerControllers, RAZER_VID, RAZER_BLADE_PRO_LATE_2016_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Blade Pro (2017)", DetectRazerControllers, RAZER_VID, RAZER_BLADE_PRO_2017_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Blade Stealth", DetectRazerControllers, RAZER_VID, RAZER_BLADE_STEALTH_PID, 1, 2);
/*-----------------------------------------------------------------------------------------------------*\
| Mice |
\*-----------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_PU("Razer Deathadder Chroma", DetectRazerControllers, RAZER_VID, RAZER_DEATHADDER_CHROMA_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Deathadder V2", DetectRazerControllers, RAZER_VID, RAZER_DEATHADDER_V2_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Diamondback", DetectRazerControllers, RAZER_VID, RAZER_DIAMONDBACK_CHROMA_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Mamba Elite", DetectRazerControllers, RAZER_VID, RAZER_MAMBA_ELITE_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Mamba Tournament Edition", DetectRazerControllers, RAZER_VID, RAZER_MAMBA_TE_WIRED_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Naga Chroma", DetectRazerControllers, RAZER_VID, RAZER_NAGA_CHROMA_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Naga Epic Chroma", DetectRazerControllers, RAZER_VID, RAZER_NAGA_EPIC_CHROMA_PID, 1, 2);
/*-----------------------------------------------------------------------------------------------------*\
| Accessories |
\*-----------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_PU("Razer Base Station Chroma", DetectRazerControllers, RAZER_VID, RAZER_CHROMA_BASE_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Base Station V2 Chroma", DetectRazerControllers, RAZER_VID, RAZER_BASE_STATION_V2_CHROMA_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Chroma HDK", DetectRazerControllers, RAZER_VID, RAZER_CHROMA_HDK_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Chroma Mug Holder", DetectRazerControllers, RAZER_VID, RAZER_CHROMA_MUG_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Core", DetectRazerControllers, RAZER_VID, RAZER_CORE_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Firefly", DetectRazerControllers, RAZER_VID, RAZER_FIREFLY_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Firefly Hyperflux", DetectRazerControllers, RAZER_VID, RAZER_FIREFLY_HYPERFLUX_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Goliathus", DetectRazerControllers, RAZER_VID, RAZER_GOLIATHUS_CHROMA_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Goliathus Extended", DetectRazerControllers, RAZER_VID, RAZER_GOLIATHUS_CHROMA_EXTENDED_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Kraken Kitty Edition", DetectRazerControllers, RAZER_VID, RAZER_KRAKEN_KITTY_EDITION_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Mouse Bungee V3 Chroma", DetectRazerControllers, RAZER_VID, RAZER_MOUSE_BUNGEE_V3_CHROMA_PID, 1, 2);
REGISTER_HID_DETECTOR_PU("Razer Nommo Chroma", DetectRazerControllers, RAZER_VID, RAZER_NOMMO_CHROMA_PID, 1, 3);
REGISTER_HID_DETECTOR_PU("Razer Nommo Pro", DetectRazerControllers, RAZER_VID, RAZER_NOMMO_PRO_PID, 1, 3);

4904
Controllers/RazerController/RazerDevices.h Normal file
View File

File diff suppressed because it is too large Load Diff

7
OpenRGB.pro
View File

@@ -96,6 +96,7 @@ INCLUDEPATH +=
Controllers/OpenRazerController/ \
Controllers/PatriotViperController/ \
Controllers/PhilipsWizController/ \
Controllers/RazerController/ \
Controllers/RedragonController/ \
Controllers/RoccatController/ \
Controllers/SapphireGPUController/ \
@@ -260,6 +261,9 @@ HEADERS +=
Controllers/PatriotViperController/RGBController_PatriotViper.h \
Controllers/PhilipsWizController/PhilipsWizController.h \
Controllers/PhilipsWizController/RGBController_PhilipsWiz.h \
Controllers/RazerController/RazerController.h \
Controllers/RazerController/RazerDevices.h \
Controllers/RazerController/RGBController_Razer.h \
Controllers/RedragonController/RedragonK556Controller.h \
Controllers/RedragonController/RedragonM711Controller.h \
Controllers/RedragonController/RGBController_RedragonK556.h \
@@ -489,6 +493,9 @@ SOURCES +=
Controllers/PhilipsWizController/PhilipsWizController.cpp \
Controllers/PhilipsWizController/PhilipsWizControllerDetect.cpp \
Controllers/PhilipsWizController/RGBController_PhilipsWiz.cpp \
Controllers/RazerController/RazerController.cpp \
Controllers/RazerController/RazerControllerDetect.cpp \
Controllers/RazerController/RGBController_Razer.cpp \
Controllers/RedragonController/RedragonK556Controller.cpp \
Controllers/RedragonController/RedragonM711Controller.cpp \
Controllers/RedragonController/RedragonControllerDetect.cpp \