732 lines
No EOL
22 KiB
C++
732 lines
No EOL
22 KiB
C++
/*-----------------------------------------*\
|
|
| RGBController_OpenRazer.cpp |
|
|
| |
|
|
| Generic RGB Interface for OpenRazer |
|
|
| kernel drivers for Chroma peripherals |
|
|
| |
|
|
| Adam Honse (CalcProgrammer1) 6/15/2019 |
|
|
\*-----------------------------------------*/
|
|
|
|
#include "RGBController_OpenRazer.h"
|
|
|
|
#include <fstream>
|
|
|
|
int RGBController_OpenRazer::GetMode()
|
|
{
|
|
return(0);
|
|
}
|
|
|
|
void RGBController_OpenRazer::SetMode(int mode)
|
|
{
|
|
char update_value = 1;
|
|
|
|
switch(type)
|
|
{
|
|
case RAZER_TYPE_MATRIX_FRAME:
|
|
case RAZER_TYPE_MATRIX_NOFRAME:
|
|
{
|
|
switch(mode)
|
|
{
|
|
case RAZER_MODE_CUSTOM:
|
|
matrix_effect_custom.write(&update_value, 1);
|
|
matrix_effect_custom.flush();
|
|
break;
|
|
|
|
case RAZER_MODE_OFF:
|
|
matrix_effect_none.write(&update_value, 1);
|
|
matrix_effect_none.flush();
|
|
break;
|
|
|
|
case RAZER_MODE_STATIC:
|
|
break;
|
|
|
|
case RAZER_MODE_BREATHING:
|
|
break;
|
|
|
|
case RAZER_MODE_SPECTRUM_CYCLE:
|
|
matrix_effect_spectrum.write(&update_value, 1);
|
|
matrix_effect_spectrum.flush();
|
|
break;
|
|
|
|
case RAZER_MODE_WAVE:
|
|
matrix_effect_wave.write(&update_value, 1);
|
|
matrix_effect_wave.flush();
|
|
break;
|
|
|
|
case RAZER_MODE_REACTIVE:
|
|
matrix_effect_reactive.write(&update_value, 1);
|
|
matrix_effect_reactive.flush();
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case RAZER_TYPE_NOMATRIX:
|
|
{
|
|
switch(mode)
|
|
{
|
|
case RAZER_MODE_CUSTOM:
|
|
update_value = 0;
|
|
logo_led_effect.write(&update_value, 1);
|
|
scroll_led_effect.write(&update_value, 1);
|
|
logo_led_effect.flush();
|
|
scroll_led_effect.flush();
|
|
break;
|
|
|
|
case RAZER_MODE_SPECTRUM_CYCLE:
|
|
update_value = '4';
|
|
logo_led_effect.write(&update_value, 1);
|
|
scroll_led_effect.write(&update_value, 1);
|
|
logo_led_effect.flush();
|
|
scroll_led_effect.flush();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void RGBController_OpenRazer::SetCustomMode()
|
|
{
|
|
SetMode(RAZER_MODE_CUSTOM);
|
|
}
|
|
|
|
void RGBController_OpenRazer::Output()
|
|
{
|
|
switch(type)
|
|
{
|
|
case RAZER_TYPE_MATRIX_FRAME:
|
|
case RAZER_TYPE_MATRIX_NOFRAME:
|
|
{
|
|
unsigned int output_array_size;
|
|
unsigned int output_offset;
|
|
|
|
if(type == RAZER_TYPE_MATRIX_NOFRAME)
|
|
{
|
|
output_array_size = 3;
|
|
output_offset = 0;
|
|
}
|
|
else
|
|
{
|
|
output_array_size = 3 + (color_buffer.size() * 3);
|
|
output_offset = 3;
|
|
}
|
|
|
|
char output_array[output_array_size];
|
|
char update_value = 1;
|
|
|
|
if(type != RAZER_TYPE_MATRIX_NOFRAME)
|
|
{
|
|
output_array[0] = 0;
|
|
output_array[1] = 0;
|
|
output_array[2] = color_buffer.size() - 1;
|
|
}
|
|
|
|
for(int i = 0; i < color_buffer.size(); i++)
|
|
{
|
|
output_array[(i * 3) + 0 + output_offset] = (char)RGBGetRValue(color_buffer[i]);
|
|
output_array[(i * 3) + 1 + output_offset] = (char)RGBGetGValue(color_buffer[i]);
|
|
output_array[(i * 3) + 2 + output_offset] = (char)RGBGetBValue(color_buffer[i]);
|
|
}
|
|
|
|
if(type == RAZER_TYPE_MATRIX_NOFRAME)
|
|
{
|
|
matrix_effect_custom.write(output_array, output_array_size);
|
|
matrix_effect_custom.flush();
|
|
}
|
|
else
|
|
{
|
|
matrix_custom_frame.write(output_array, output_array_size);
|
|
matrix_custom_frame.flush();
|
|
matrix_effect_custom.write(&update_value, 1);
|
|
matrix_effect_custom.flush();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case RAZER_TYPE_NOMATRIX:
|
|
{
|
|
unsigned int output_array_size = 3;
|
|
char output_array[output_array_size];
|
|
char update_value = 0;
|
|
|
|
output_array[0] = (char)RGBGetRValue(color_buffer[0]);
|
|
output_array[1] = (char)RGBGetGValue(color_buffer[0]);
|
|
output_array[2] = (char)RGBGetBValue(color_buffer[0]);
|
|
logo_led_rgb.write(output_array, output_array_size);
|
|
|
|
output_array[0] = (char)RGBGetRValue(color_buffer[1]);
|
|
output_array[1] = (char)RGBGetGValue(color_buffer[1]);
|
|
output_array[2] = (char)RGBGetBValue(color_buffer[1]);
|
|
scroll_led_rgb.write(output_array, output_array_size);
|
|
|
|
logo_led_rgb.flush();
|
|
scroll_led_rgb.flush();
|
|
|
|
logo_led_effect.write(&update_value, 1);
|
|
scroll_led_effect.write(&update_value, 1);
|
|
logo_led_effect.flush();
|
|
scroll_led_effect.flush();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void RGBController_OpenRazer::SetAllLEDs(RGBColor color)
|
|
{
|
|
for(int i = 0; i < color_buffer.size(); i++)
|
|
{
|
|
color_buffer[i] = color;
|
|
}
|
|
|
|
Output();
|
|
}
|
|
|
|
void RGBController_OpenRazer::SetAllZoneLEDs(int zone, RGBColor color)
|
|
{
|
|
for (int x = 0; x < zones[zone].map.size(); x++)
|
|
{
|
|
for (int y = 0; y < zones[zone].map[x].size(); y++)
|
|
{
|
|
color_buffer[zones[zone].map[x][y]] = color;
|
|
}
|
|
}
|
|
|
|
Output();
|
|
}
|
|
|
|
void RGBController_OpenRazer::SetLED(int led, RGBColor color)
|
|
{
|
|
color_buffer[led] = color;
|
|
|
|
Output();
|
|
}
|
|
|
|
static std::string GetDeviceTypeString(std::string dev_path)
|
|
{
|
|
// Read device_type for device name string
|
|
std::string dev_type_path = dev_path + "/device_type";
|
|
std::ifstream dev_type_file;
|
|
std::string ret_str;
|
|
|
|
dev_type_file.open(dev_type_path);
|
|
std::getline(dev_type_file, ret_str);
|
|
dev_type_file.close();
|
|
|
|
return(ret_str);
|
|
}
|
|
|
|
unsigned int RGBController_OpenRazer::GetTypeFromDeviceName(std::string dev_name)
|
|
{
|
|
if(dev_name == "Razer Mamba Tournament Edition")
|
|
{
|
|
return(RAZER_MAMBA_TOURNAMENT_EDITION_CHROMA);
|
|
}
|
|
|
|
else if(dev_name == "Razer DeathAdder Chroma")
|
|
{
|
|
return(RAZER_DEATHADDER_CHROMA);
|
|
}
|
|
|
|
else if(dev_name == "Razer Diamondback Chroma")
|
|
{
|
|
return(RAZER_DIAMONDBACK_CHROMA);
|
|
}
|
|
|
|
else if(dev_name == "Razer DeathStalker Chroma")
|
|
{
|
|
return(RAZER_DEATHSTALKER_CHROMA);
|
|
}
|
|
|
|
else if(dev_name == "Razer Tartarus Chroma")
|
|
{
|
|
return(RAZER_TARTARUS_CHROMA);
|
|
}
|
|
|
|
else if(dev_name == "Razer Core")
|
|
{
|
|
return(RAZER_CORE);
|
|
}
|
|
|
|
else if(dev_name == "Razer Firefly")
|
|
{
|
|
return(RAZER_FIREFLY_CHROMA);
|
|
}
|
|
|
|
else if(dev_name == "Razer Goliathus Extended")
|
|
{
|
|
return(RAZER_GOLIATHUS_EXTENDED_CHROMA);
|
|
}
|
|
|
|
else if(dev_name == "Razer Chroma Mug Holder")
|
|
{
|
|
return(RAZER_MUG_HOLDER);
|
|
}
|
|
|
|
else if(dev_name == "Razer Kraken 7.1 Chroma")
|
|
{
|
|
return(RAZER_KRAKEN_V1);
|
|
}
|
|
|
|
else if(dev_name == "Razer Kraken 7.1 V2")
|
|
{
|
|
return(RAZER_KRAKEN_V2);
|
|
}
|
|
|
|
else
|
|
{
|
|
return(RAZER_NO_DEVICE);
|
|
}
|
|
}
|
|
|
|
void RGBController_OpenRazer::SetupMatrixDevice(std::string dev_path)
|
|
{
|
|
matrix_custom_frame.open(dev_path + "/matrix_custom_frame");
|
|
matrix_effect_custom.open(dev_path + "/matrix_effect_custom");
|
|
matrix_effect_breath.open(dev_path + "/matrix_effect_breath");
|
|
matrix_effect_none.open(dev_path + "/matrix_effect_none");
|
|
matrix_effect_reactive.open(dev_path + "/matrix_effect_reactive");
|
|
matrix_effect_spectrum.open(dev_path + "/matrix_effect_spectrum");
|
|
matrix_effect_static.open(dev_path + "/matrix_effect_static");
|
|
matrix_effect_wave.open(dev_path + "/matrix_effect_wave");
|
|
|
|
if(!matrix_custom_frame)
|
|
{
|
|
type = RAZER_TYPE_MATRIX_NOFRAME;
|
|
}
|
|
else
|
|
{
|
|
type = RAZER_TYPE_MATRIX_FRAME;
|
|
}
|
|
}
|
|
|
|
void RGBController_OpenRazer::SetupNonMatrixDevice(std::string dev_path)
|
|
{
|
|
logo_led_effect.open(dev_path + "/logo_led_effect");
|
|
logo_led_rgb.open(dev_path + "/logo_led_rgb");
|
|
scroll_led_effect.open(dev_path + "/scroll_led_effect");
|
|
scroll_led_rgb.open(dev_path + "/scroll_led_rgb");
|
|
|
|
type = RAZER_TYPE_NOMATRIX;
|
|
}
|
|
|
|
RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
|
|
{
|
|
name = GetDeviceTypeString(dev_path);
|
|
|
|
device = GetTypeFromDeviceName(name);
|
|
|
|
mode razer_modes[RAZER_NUM_MODES];
|
|
|
|
razer_modes[0].name = "Custom";
|
|
razer_modes[1].name = "Off";
|
|
razer_modes[2].name = "Static";
|
|
razer_modes[3].name = "Breathing";
|
|
razer_modes[4].name = "Spectrum Cycle";
|
|
razer_modes[5].name = "Wave";
|
|
razer_modes[6].name = "Reactive";
|
|
|
|
for (int i = 0; i < RAZER_NUM_MODES; i++)
|
|
{
|
|
modes.push_back(razer_modes[i]);
|
|
}
|
|
|
|
switch(device)
|
|
{
|
|
case RAZER_MAMBA_TOURNAMENT_EDITION_CHROMA:
|
|
{
|
|
SetupMatrixDevice(dev_path);
|
|
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
RGBColor new_color = 0x00000000;
|
|
color_buffer.push_back(new_color);
|
|
}
|
|
|
|
for (int i = 0; i < 7; i++)
|
|
{
|
|
led* new_led = new led();
|
|
new_led->name = "Left Strip";
|
|
leds.push_back(*new_led);
|
|
}
|
|
for (int i = 7; i < 14; i++)
|
|
{
|
|
led* new_led = new led();
|
|
new_led->name = "Right Strip";
|
|
leds.push_back(*new_led);
|
|
}
|
|
|
|
{
|
|
led* new_led = new led();
|
|
new_led->name = "Logo";
|
|
leds.push_back(*new_led);
|
|
}
|
|
|
|
{
|
|
led* new_led = new led();
|
|
new_led->name = "Mouse Wheel";
|
|
leds.push_back(*new_led);
|
|
}
|
|
|
|
zone left_zone;
|
|
left_zone.name = "Left Strip";
|
|
left_zone.type = ZONE_TYPE_LINEAR;
|
|
std::vector<int> left_zone_map;
|
|
for(int i = 0; i < 7; i++)
|
|
{
|
|
left_zone_map.push_back(i);
|
|
}
|
|
left_zone.map.push_back(left_zone_map);
|
|
zones.push_back(left_zone);
|
|
|
|
zone right_zone;
|
|
right_zone.name = "Right Strip";
|
|
right_zone.type = ZONE_TYPE_LINEAR;
|
|
std::vector<int> right_zone_map;
|
|
for(int i = 7; i < 14; i++)
|
|
{
|
|
right_zone_map.push_back(i);
|
|
}
|
|
right_zone.map.push_back(right_zone_map);
|
|
zones.push_back(right_zone);
|
|
|
|
zone logo_zone;
|
|
logo_zone.name = "Logo";
|
|
logo_zone.type = ZONE_TYPE_SINGLE;
|
|
std::vector<int> logo_zone_map;
|
|
logo_zone_map.push_back(14);
|
|
logo_zone.map.push_back(logo_zone_map);
|
|
zones.push_back(logo_zone);
|
|
|
|
zone wheel_zone;
|
|
wheel_zone.name = "Mouse Wheel";
|
|
wheel_zone.type = ZONE_TYPE_SINGLE;
|
|
std::vector<int> wheel_zone_map;
|
|
wheel_zone_map.push_back(15);
|
|
wheel_zone.map.push_back(wheel_zone_map);
|
|
zones.push_back(wheel_zone);
|
|
}
|
|
break;
|
|
|
|
case RAZER_DIAMONDBACK_CHROMA:
|
|
{
|
|
SetupMatrixDevice(dev_path);
|
|
|
|
for (int i = 0; i < 21; i++)
|
|
{
|
|
RGBColor new_color = 0x00000000;
|
|
color_buffer.push_back(new_color);
|
|
}
|
|
|
|
for (int i = 0; i < 9; i++)
|
|
{
|
|
led* new_led = new led();
|
|
new_led->name = "Left Strip";
|
|
leds.push_back(*new_led);
|
|
}
|
|
for (int i = 7; i < 19; i++)
|
|
{
|
|
led* new_led = new led();
|
|
new_led->name = "Right Strip";
|
|
leds.push_back(*new_led);
|
|
}
|
|
|
|
{
|
|
led* new_led = new led();
|
|
new_led->name = "Logo";
|
|
leds.push_back(*new_led);
|
|
}
|
|
|
|
{
|
|
led* new_led = new led();
|
|
new_led->name = "Mouse Wheel";
|
|
leds.push_back(*new_led);
|
|
}
|
|
|
|
zone left_zone;
|
|
left_zone.name = "Left Strip";
|
|
left_zone.type = ZONE_TYPE_LINEAR;
|
|
std::vector<int> left_zone_map;
|
|
for(int i = 0; i < 9; i++)
|
|
{
|
|
left_zone_map.push_back(i);
|
|
}
|
|
left_zone.map.push_back(left_zone_map);
|
|
zones.push_back(left_zone);
|
|
|
|
zone right_zone;
|
|
right_zone.name = "Right Strip";
|
|
right_zone.type = ZONE_TYPE_LINEAR;
|
|
std::vector<int> right_zone_map;
|
|
for(int i = 7; i < 19; i++)
|
|
{
|
|
right_zone_map.push_back(i);
|
|
}
|
|
right_zone.map.push_back(right_zone_map);
|
|
zones.push_back(right_zone);
|
|
|
|
zone logo_zone;
|
|
logo_zone.name = "Logo";
|
|
logo_zone.type = ZONE_TYPE_SINGLE;
|
|
std::vector<int> logo_zone_map;
|
|
logo_zone_map.push_back(19);
|
|
logo_zone.map.push_back(logo_zone_map);
|
|
zones.push_back(logo_zone);
|
|
|
|
zone wheel_zone;
|
|
wheel_zone.name = "Mouse Wheel";
|
|
wheel_zone.type = ZONE_TYPE_SINGLE;
|
|
std::vector<int> wheel_zone_map;
|
|
wheel_zone_map.push_back(20);
|
|
wheel_zone.map.push_back(wheel_zone_map);
|
|
zones.push_back(wheel_zone);
|
|
}
|
|
break;
|
|
|
|
case RAZER_DEATHADDER_CHROMA:
|
|
{
|
|
SetupNonMatrixDevice(dev_path);
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
RGBColor new_color = 0x00000000;
|
|
color_buffer.push_back(new_color);
|
|
}
|
|
|
|
led logo_led;
|
|
logo_led.name = "Logo";
|
|
leds.push_back(logo_led);
|
|
|
|
led wheel_led;
|
|
wheel_led.name = "Mouse Wheel";
|
|
leds.push_back(wheel_led);
|
|
|
|
zone logo_zone;
|
|
logo_zone.name = "Logo";
|
|
logo_zone.type = ZONE_TYPE_SINGLE;
|
|
std::vector<int> logo_zone_map;
|
|
logo_zone_map.push_back(0);
|
|
logo_zone.map.push_back(logo_zone_map);
|
|
zones.push_back(logo_zone);
|
|
|
|
zone wheel_zone;
|
|
wheel_zone.name = "Mouse Wheel";
|
|
wheel_zone.type = ZONE_TYPE_SINGLE;
|
|
std::vector<int> wheel_zone_map;
|
|
wheel_zone_map.push_back(1);
|
|
wheel_zone.map.push_back(wheel_zone_map);
|
|
zones.push_back(wheel_zone);
|
|
}
|
|
break;
|
|
|
|
case RAZER_DEATHSTALKER_CHROMA:
|
|
{
|
|
SetupMatrixDevice(dev_path);
|
|
|
|
for(int i = 0; i < 12; i++)
|
|
{
|
|
RGBColor new_color = 0x00000000;
|
|
color_buffer.push_back(new_color);
|
|
}
|
|
|
|
for (int i = 0; i < 12; i++)
|
|
{
|
|
led* new_led = new led();
|
|
new_led->name = "Keyboard";
|
|
leds.push_back(*new_led);
|
|
}
|
|
|
|
zone keyboard_zone;
|
|
keyboard_zone.name = "Keyboard";
|
|
keyboard_zone.type = ZONE_TYPE_LINEAR;
|
|
std::vector<int> keyboard_zone_map;
|
|
for(int i = 0; i < 12; i++)
|
|
{
|
|
keyboard_zone_map.push_back(i);
|
|
}
|
|
keyboard_zone.map.push_back(keyboard_zone_map);
|
|
zones.push_back(keyboard_zone);
|
|
}
|
|
break;
|
|
|
|
case RAZER_TARTARUS_CHROMA:
|
|
{
|
|
SetupMatrixDevice(dev_path);
|
|
|
|
for (int i = 0; i < 1; i++)
|
|
{
|
|
RGBColor new_color = 0x00000000;
|
|
color_buffer.push_back(new_color);
|
|
}
|
|
|
|
led logo_led;
|
|
logo_led.name = "Keypad";
|
|
leds.push_back(logo_led);
|
|
|
|
zone logo_zone;
|
|
logo_zone.name = "Keypad";
|
|
logo_zone.type = ZONE_TYPE_SINGLE;
|
|
std::vector<int> logo_zone_map;
|
|
logo_zone_map.push_back(0);
|
|
logo_zone.map.push_back(logo_zone_map);
|
|
zones.push_back(logo_zone);
|
|
}
|
|
break;
|
|
|
|
case RAZER_CORE:
|
|
{
|
|
SetupMatrixDevice(dev_path);
|
|
|
|
for(int i = 0; i < 9; i++)
|
|
{
|
|
RGBColor new_color = 0x00000000;
|
|
color_buffer.push_back(new_color);
|
|
}
|
|
|
|
for (int i = 0; i < 1; i++)
|
|
{
|
|
led* new_led = new led();
|
|
new_led->name = "GPU Lighting";
|
|
leds.push_back(*new_led);
|
|
}
|
|
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
led* new_led = new led();
|
|
new_led->name = "LED Strip";
|
|
leds.push_back(*new_led);
|
|
}
|
|
|
|
zone zone_1;
|
|
zone_1.name = "GPU Lighting";
|
|
zone_1.type = ZONE_TYPE_SINGLE;
|
|
std::vector<int> zone_1_map;
|
|
for(int i = 0; i < 1; i++)
|
|
{
|
|
zone_1_map.push_back(i);
|
|
}
|
|
zone_1.map.push_back(zone_1_map);
|
|
zones.push_back(zone_1);
|
|
|
|
zone zone_2;
|
|
zone_2.name = "LED Strip";
|
|
zone_2.type = ZONE_TYPE_LINEAR;
|
|
std::vector<int> zone_2_map;
|
|
for(int i = 0; i < 8; i++)
|
|
{
|
|
zone_2_map.push_back(i);
|
|
}
|
|
zone_2.map.push_back(zone_2_map);
|
|
zones.push_back(zone_2);
|
|
}
|
|
break;
|
|
|
|
case RAZER_FIREFLY_CHROMA:
|
|
{
|
|
SetupMatrixDevice(dev_path);
|
|
|
|
for(int i = 0; i < 15; i++)
|
|
{
|
|
RGBColor new_color = 0x00000000;
|
|
color_buffer.push_back(new_color);
|
|
}
|
|
|
|
for (int i = 0; i < 15; i++)
|
|
{
|
|
led* new_led = new led();
|
|
new_led->name = "LED Strip";
|
|
leds.push_back(*new_led);
|
|
}
|
|
|
|
zone zone_1;
|
|
zone_1.name = "LED Strip";
|
|
zone_1.type = ZONE_TYPE_LINEAR;
|
|
std::vector<int> zone_1_map;
|
|
for(int i = 0; i < 15; i++)
|
|
{
|
|
zone_1_map.push_back(i);
|
|
}
|
|
zone_1.map.push_back(zone_1_map);
|
|
zones.push_back(zone_1);
|
|
}
|
|
break;
|
|
|
|
case RAZER_GOLIATHUS_EXTENDED_CHROMA:
|
|
{
|
|
SetupMatrixDevice(dev_path);
|
|
|
|
for (int i = 0; i < 1; i++)
|
|
{
|
|
RGBColor new_color = 0x00000000;
|
|
color_buffer.push_back(new_color);
|
|
}
|
|
|
|
led logo_led;
|
|
logo_led.name = "Logo";
|
|
leds.push_back(logo_led);
|
|
|
|
zone logo_zone;
|
|
logo_zone.name = "Logo";
|
|
logo_zone.type = ZONE_TYPE_SINGLE;
|
|
std::vector<int> logo_zone_map;
|
|
logo_zone_map.push_back(0);
|
|
logo_zone.map.push_back(logo_zone_map);
|
|
zones.push_back(logo_zone);
|
|
}
|
|
break;
|
|
|
|
case RAZER_MUG_HOLDER:
|
|
{
|
|
SetupMatrixDevice(dev_path);
|
|
|
|
for(int i = 0; i < 15; i++)
|
|
{
|
|
RGBColor new_color = 0x00000000;
|
|
color_buffer.push_back(new_color);
|
|
}
|
|
|
|
for (int i = 0; i < 15; i++)
|
|
{
|
|
led* new_led = new led();
|
|
new_led->name = "LED Strip";
|
|
leds.push_back(*new_led);
|
|
}
|
|
|
|
zone keyboard_zone;
|
|
keyboard_zone.name = "LED Strip";
|
|
keyboard_zone.type = ZONE_TYPE_LINEAR;
|
|
std::vector<int> keyboard_zone_map;
|
|
for(int i = 0; i < 15; i++)
|
|
{
|
|
keyboard_zone_map.push_back(i);
|
|
}
|
|
keyboard_zone.map.push_back(keyboard_zone_map);
|
|
zones.push_back(keyboard_zone);
|
|
}
|
|
break;
|
|
|
|
case RAZER_KRAKEN_V1:
|
|
case RAZER_KRAKEN_V2:
|
|
{
|
|
SetupMatrixDevice(dev_path);
|
|
|
|
for (int i = 0; i < 1; i++)
|
|
{
|
|
RGBColor new_color = 0x00000000;
|
|
color_buffer.push_back(new_color);
|
|
}
|
|
|
|
led logo_led;
|
|
logo_led.name = "Logo";
|
|
leds.push_back(logo_led);
|
|
|
|
zone logo_zone;
|
|
logo_zone.name = "Logo";
|
|
logo_zone.type = ZONE_TYPE_SINGLE;
|
|
std::vector<int> logo_zone_map;
|
|
logo_zone_map.push_back(0);
|
|
logo_zone.map.push_back(logo_zone_map);
|
|
zones.push_back(logo_zone);
|
|
}
|
|
break;
|
|
}
|
|
} |