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

Add support for ZET Blade Optical

Browse source
This commit is contained in:
Vaker 2022-01-24 21:29:48 +00:00 • committed by Adam Honse
parent 36382b6526
commit ce71a3d566
7 changed files with 945 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

535
Controllers/ZETKeyboardController/RGBController_ZETBladeOptical.cpp Normal file
View file

@ -0,0 +1,535 @@
/*-----------------------------------------*\
| RGBController_ZETBladeOptical.cpp |
| |
| Generic RGB Interface for ZET Blade |
| Optical Keyboard |
| |
| Based on HyperX Alloy Elite2 impl by |
| KundaPanda |
| |
| Moon_darker (Vaker) 23/01/2022 |
\*-----------------------------------------*/
#include "RGBController_ZETBladeOptical.h"
//0xFFFFFFFF indicates an unused entry in matrix
#define NA 0xFFFFFFFF
static unsigned int matrix_map[ZET_BLADE_OPTICAL_ROWS][ZET_BLADE_OPTICAL_COLUMNS] =
{
{ 0, NA, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, NA, 13, 14, 15, NA, NA, NA, NA }, // Skipped: 1, 17, 18, 19, 20
{ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, NA, 30, 31, 32, 33, 34, 35, 36 },
{ 37, NA, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57 },
{ 58, NA, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, NA, NA, NA, NA, 71, 72, 73, NA }, // Skipped: 75, 77, 78, 79, 83
{ 74, NA, NA, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, NA, NA, 86, NA, 87, 88, 89, 90 }, // Skipped: 85, 96, 98, 100
{ 91, 92, 93, NA, NA, NA, NA, 94, NA, NA, NA, 95, 96, 97, 98, 99, 100, 101, 102, NA, 103, NA } // Skipped: 108, 109, 111, 112, 113, 116, 123, 125
};
static const char* zone_names[] =
{
"Keyboard",
};
static zone_type zone_types[] =
{
ZONE_TYPE_MATRIX,
};
static const unsigned int zone_sizes[] =
{
104,
};
static const char *led_names[] =
{
"Key: Escape",
// Skip index 1
"Key: F1",
"Key: F2",
"Key: F3",
"Key: F4",
"Key: F5",
"Key: F6",
"Key: F7",
"Key: F8",
"Key: F9",
"Key: F10",
"Key: F11",
"Key: F12",
"Key: Print Screen",
"Key: Scroll Lock",
"Key: Pause/Break",
// Skip index 17
// Skip index 18
// Skip index 19
// Skip index 20
"Key: `",
"Key: 1",
"Key: 2",
"Key: 3",
"Key: 4",
"Key: 5",
"Key: 6",
"Key: 7",
"Key: 8",
"Key: 9",
"Key: 0",
"Key: -",
"Key: =",
"Key: Backspace",
"Key: Insert",
"Key: Home",
"Key: Page Up",
"Key: Num Lock",
"Key: Number Pad /",
"Key: Number Pad *",
"Key: Number Pad -",
"Key: Tab",
"Key: Q",
"Key: W",
"Key: E",
"Key: R",
"Key: T",
"Key: Y",
"Key: U",
"Key: I",
"Key: O",
"Key: P",
"Key: [",
"Key: ]",
"Key: \\ (ANSI)",
"Key: Delete",
"Key: End",
"Key: Page Down",
"Key: Number Pad 7",
"Key: Number Pad 8",
"Key: Number Pad 9",
"Key: Number Pad +",
"Key: Caps Lock",
"Key: A",
"Key: S",
"Key: D",
"Key: F",
"Key: G",
"Key: H",
"Key: J",
"Key: K",
"Key: L",
"Key: ;",
"Key: '",
// Skip index 75
"Key: Enter",
// Skip index 77
// Skip index 78
// Skip index 79
"Key: Number Pad 4",
"Key: Number Pad 5",
"Key: Number Pad 6",
// Skip index 83
"Key: Left Shift",
// Skip index 85
"Key: Z",
"Key: X",
"Key: C",
"Key: V",
"Key: B",
"Key: N",
"Key: M",
"Key: ,",
"Key: .",
"Key: /",
// Skip index 96
"Key: Right Shift",
// Skip index 98
"Key: Up Arrow",
// Skip index 100
"Key: Number Pad 1",
"Key: Number Pad 2",
"Key: Number Pad 3",
"Key: Number Pad Enter",
"Key: Left Control",
"Key: Left Windows",
"Key: Left Alt",
// Skip index 108
// Skip index 109
"Key: Space",
// Skip index 111
// Skip index 112
// Skip index 113
"Key: Right Alt",
"Key: Right Fn",
// Skip index 116
"Key: Menu",
"Key: Right Control",
"Key: Left Arrow",
"Key: Down Arrow",
"Key: Right Arrow",
"Key: Number Pad 0",
// Skip index 123
"Key: Number Pad .",
};
RGBController_ZETBladeOptical::RGBController_ZETBladeOptical(ZETBladeOpticalController* controller_ptr)
{
controller = controller_ptr;
name = "ZET Blade Optical Keyboard Device";
vendor = "ZET";
type = DEVICE_TYPE_KEYBOARD;
description = "ZET Blade Optical Keyboard Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Custom;
Custom.name = "Custom";
Custom.value = ZET_BLADE_OPTICAL_MODE_CUSTOM;
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Custom.color_mode = MODE_COLORS_PER_LED;
Custom.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
Custom.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
Custom.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
modes.push_back(Custom);
mode Static;
Static.name = "Static";
Static.value = ZET_BLADE_OPTICAL_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(Static.colors_max);
Static.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
Static.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
Static.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
Static.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = ZET_BLADE_OPTICAL_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Breathing.color_mode = MODE_COLORS_RANDOM;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(Breathing.colors_max);
Breathing.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
Breathing.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
Breathing.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
Breathing.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
Breathing.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
Breathing.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(Breathing);
mode OnPress;
OnPress.name = "Reactive";
OnPress.value = ZET_BLADE_OPTICAL_MODE_ON_PRESS;
OnPress.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
OnPress.color_mode = MODE_COLORS_RANDOM;
OnPress.colors_min = 1;
OnPress.colors_max = 1;
OnPress.colors.resize(OnPress.colors_max);
OnPress.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
OnPress.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
OnPress.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
OnPress.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
OnPress.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
OnPress.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(OnPress);
mode Raindrop;
Raindrop.name = "Reactive Raindrop";
Raindrop.value = ZET_BLADE_OPTICAL_MODE_RAINDROP;
Raindrop.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Raindrop.color_mode = MODE_COLORS_RANDOM;
Raindrop.colors_min = 1;
Raindrop.colors_max = 1;
Raindrop.colors.resize(Raindrop.colors_max);
Raindrop.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
Raindrop.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
Raindrop.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
Raindrop.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
Raindrop.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
Raindrop.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(Raindrop);
mode Ripple;
Ripple.name = "Reactive Ripple";
Ripple.value = ZET_BLADE_OPTICAL_MODE_RIPPLE;
Ripple.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Ripple.color_mode = MODE_COLORS_RANDOM;
Ripple.colors_min = 1;
Ripple.colors_max = 1;
Ripple.colors.resize(Ripple.colors_max);
Ripple.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
Ripple.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
Ripple.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
Ripple.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
Ripple.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
Ripple.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(Ripple);
mode Laser;
Laser.name = "Reactive Laser";
Laser.value = ZET_BLADE_OPTICAL_MODE_LASER;
Laser.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Laser.color_mode = MODE_COLORS_RANDOM;
Laser.colors_min = 1;
Laser.colors_max = 1;
Laser.colors.resize(Laser.colors_max);
Laser.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
Laser.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
Laser.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
Laser.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
Laser.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
Laser.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(Laser);
mode Waves;
Waves.name = "Waves";
Waves.value = ZET_BLADE_OPTICAL_MODE_WAVES;
Waves.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Waves.color_mode = MODE_COLORS_RANDOM;
Waves.colors_min = 1;
Waves.colors_max = 1;
Waves.colors.resize(Waves.colors_max);
Waves.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
Waves.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
Waves.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
Waves.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
Waves.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
Waves.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(Waves);
mode Rain;
Rain.name = "Rain";
Rain.value = ZET_BLADE_OPTICAL_MODE_RAIN;
Rain.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Rain.color_mode = MODE_COLORS_NONE;
Rain.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
Rain.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
Rain.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
Rain.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
Rain.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
Rain.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(Rain);
mode Spectrum;
Spectrum.name = "Spectrum Cycle";
Spectrum.value = ZET_BLADE_OPTICAL_MODE_SPECTRUM;
Spectrum.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Spectrum.color_mode = MODE_COLORS_NONE;
Spectrum.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
Spectrum.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
Spectrum.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
Spectrum.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
Spectrum.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
Spectrum.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(Spectrum);
mode SurfingRight; // Now, you might be thinking... it'd be better to use .direction here, right? WRONG! There is no Surfing Left /._.
SurfingRight.name = "Rainbow Wave";
SurfingRight.value = ZET_BLADE_OPTICAL_MODE_SURFING_RIGHT;
SurfingRight.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
SurfingRight.color_mode = MODE_COLORS_NONE;
SurfingRight.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
SurfingRight.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
SurfingRight.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
SurfingRight.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
SurfingRight.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
SurfingRight.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(SurfingRight);
mode SurfingCenter;
SurfingCenter.name = "Rainbow Wave Center";
SurfingCenter.value = ZET_BLADE_OPTICAL_MODE_SURFING_CENTER;
SurfingCenter.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
SurfingCenter.color_mode = MODE_COLORS_NONE;
SurfingCenter.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
SurfingCenter.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
SurfingCenter.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
SurfingCenter.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
SurfingCenter.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
SurfingCenter.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(SurfingCenter);
mode SurfingCross;
SurfingCross.name = "Rainbow Wave Cross";
SurfingCross.value = ZET_BLADE_OPTICAL_MODE_SURFING_CROSS;
SurfingCross.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
SurfingCross.color_mode = MODE_COLORS_NONE;
SurfingCross.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
SurfingCross.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
SurfingCross.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
SurfingCross.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
SurfingCross.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
SurfingCross.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(SurfingCross);
mode RotateMarquee;
RotateMarquee.name = "Vortex";
RotateMarquee.value = ZET_BLADE_OPTICAL_MODE_ROTATE_MARQUEE;
RotateMarquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
RotateMarquee.color_mode = MODE_COLORS_NONE;
RotateMarquee.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
RotateMarquee.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
RotateMarquee.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
RotateMarquee.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
RotateMarquee.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
RotateMarquee.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(RotateMarquee);
mode Traffic;
Traffic.name = "Traffic";
Traffic.value = ZET_BLADE_OPTICAL_MODE_TRAFFIC;
Traffic.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Traffic.color_mode = MODE_COLORS_NONE;
Traffic.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
Traffic.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
Traffic.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
Traffic.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
Traffic.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
Traffic.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(Traffic);
mode Gradient;
Gradient.name = "Gradient";
Gradient.value = ZET_BLADE_OPTICAL_MODE_GRADIENT;
Gradient.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Gradient.color_mode = MODE_COLORS_NONE;
Gradient.brightness_min = ZET_BLADE_OPTICAL_BRIGHTNESS_MIN;
Gradient.brightness_max = ZET_BLADE_OPTICAL_BRIGHTNESS_MAX;
Gradient.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
Gradient.speed_min = ZET_BLADE_OPTICAL_SPEED_MIN;
Gradient.speed_max = ZET_BLADE_OPTICAL_SPEED_MAX;
Gradient.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
modes.push_back(Gradient);
mode Off;
Off.name = "Off";
Off.value = ZET_BLADE_OPTICAL_MODE_OFF;
Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
Off.color_mode = MODE_COLORS_NONE;
Off.speed = ZET_BLADE_OPTICAL_SPEED_DEF;
Off.brightness = ZET_BLADE_OPTICAL_BRIGHTNESS_DEF;
modes.push_back(Off);
SetupZones();
}
RGBController_ZETBladeOptical::~RGBController_ZETBladeOptical()
{
/*---------------------------------------------------------*\
| Delete the matrix map |
\*---------------------------------------------------------*/
for (unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
{
if (zones[zone_index].matrix_map != nullptr)
{
delete zones[zone_index].matrix_map;
}
}
delete controller;
}
void RGBController_ZETBladeOptical::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
unsigned int total_led_count = 0;
for (unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
{
zone new_zone;
new_zone.name = zone_names[zone_idx];
new_zone.type = zone_types[zone_idx];
new_zone.leds_min = zone_sizes[zone_idx];
new_zone.leds_max = zone_sizes[zone_idx];
new_zone.leds_count = zone_sizes[zone_idx];
if (zone_types[zone_idx] == ZONE_TYPE_MATRIX)
{
new_zone.matrix_map = new matrix_map_type;
new_zone.matrix_map->height = ZET_BLADE_OPTICAL_ROWS;
new_zone.matrix_map->width = ZET_BLADE_OPTICAL_COLUMNS;
new_zone.matrix_map->map = (unsigned int *)&matrix_map;
}
else
{
new_zone.matrix_map = nullptr;
}
zones.push_back(new_zone);
total_led_count += zone_sizes[zone_idx];
}
for (unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
{
led new_led;
new_led.name = led_names[led_idx];
leds.push_back(new_led);
}
SetupColors();
}
void RGBController_ZETBladeOptical::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_ZETBladeOptical::DeviceUpdateLEDs()
{
UpdateSingleLED(-1);
}
void RGBController_ZETBladeOptical::UpdateZoneLEDs(int /*zone*/)
{
UpdateSingleLED(-1);
}
void RGBController_ZETBladeOptical::UpdateSingleLED(int led)
{
last_update_time = std::chrono::steady_clock::now();
if (active_mode == 0)
{
controller->SetLEDDirect(colors, modes[active_mode].brightness, led);
}
}
void RGBController_ZETBladeOptical::SetCustomMode()
{
active_mode = 0;
}
void RGBController_ZETBladeOptical::DeviceUpdateMode()
{
bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM || modes[active_mode].color_mode == MODE_COLORS_NONE);
unsigned char mode_colors[3];
mode_colors[0] = 0;
mode_colors[1] = 0;
mode_colors[2] = 0;
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
{
mode_colors[0] = RGBGetRValue(modes[active_mode].colors[0]);
mode_colors[1] = RGBGetGValue(modes[active_mode].colors[0]);
mode_colors[2] = RGBGetBValue(modes[active_mode].colors[0]);
}
controller->SetEffect(modes[active_mode].value,
modes[active_mode].speed,
modes[active_mode].brightness,
random,
mode_colors[0],
mode_colors[1],
mode_colors[2]);
std::this_thread::sleep_for(std::chrono::milliseconds(15));
}

44
Controllers/ZETKeyboardController/RGBController_ZETBladeOptical.h Normal file
View file

@ -0,0 +1,44 @@
/*-----------------------------------------*\
| RGBController_ZETBladeOptical.cpp |
| |
| Generic RGB Interface for ZET Blade |
| Optical Keyboard |
| |
| Based on HyperX Alloy Elite2 impl by |
| KundaPanda |
| |
| Moon_darker (Vaker) 23/01/2022 |
\*-----------------------------------------*/
#pragma once
#include <atomic>
#include <chrono>
#include <thread>
#include "RGBController.h"
#include "ZETBladeOpticalController.h"
#define ZET_BLADE_OPTICAL_ROWS 6
#define ZET_BLADE_OPTICAL_COLUMNS 22
class RGBController_ZETBladeOptical : public RGBController
{
public:
RGBController_ZETBladeOptical(ZETBladeOpticalController* controller_ptr);
~RGBController_ZETBladeOptical();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
ZETBladeOpticalController* controller;
std::chrono::time_point<std::chrono::steady_clock> last_update_time;
};

260
Controllers/ZETKeyboardController/ZETBladeOpticalController.cpp Normal file
View file

@ -0,0 +1,260 @@
/*-----------------------------------------*\
| ZETBladeOpticalController.cpp |
| |
| Driver for ZET Blade Optical Keyboard |
| |
| Based on HyperX Alloy Elite2 impl by |
| KundaPanda |
| |
| Moon_darker (Vaker) 23/01/2022 |
\*-----------------------------------------*/
#include "ZETBladeOpticalController.h"
#include <cstring>
#include "dependencies/dmiinfo.h"
using namespace std::chrono_literals;
//0xFFFFFFFF indicates an unused entry in matrix
#define NA 0xFFFFFFFF
/*-----------------------------------------*\
| Skip these indices in the color output |
\*-----------------------------------------*/
static const unsigned int SKIP_INDICES[] = { 1, 17, 18, 19, 20, 75, 77, 78, 79, 83, 85, 96, 98, 100, 108, 109, 111, 112, 113, 116, 123, 125 };
ZETBladeOpticalController::ZETBladeOpticalController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
effect_mode = ZET_BLADE_OPTICAL_MODE_STATIC;
}
ZETBladeOpticalController::~ZETBladeOpticalController()
{
hid_close(dev);
}
std::string ZETBladeOpticalController::GetDeviceLocation()
{
return("HID " + location);
}
std::string ZETBladeOpticalController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if (ret != 0)
{
return("");
}
std::wstring return_wstring = serial_string;
std::string return_string(return_wstring.begin(), return_wstring.end());
return(return_string);
}
void ZETBladeOpticalController::PrepareHeader(unsigned char* packet, unsigned char brightness)
{
PrepareHeader(packet, 0x1C, 0x02, brightness, 0xFF); // Custom 2, 2, -, separator
}
void ZETBladeOpticalController::PrepareHeader(unsigned char* packet, unsigned char mode, unsigned char speed, unsigned char brightness, unsigned char color)
{
/*-----------------------------------------------------*\
| Prepare packet header |
\*-----------------------------------------------------*/
packet[0x00] = 0x04; // Report ID
packet[0x01] = 0xAE; // RGB Control Packet (KB = 0xA0)
packet[0x02] = 0x01; // unk
packet[0x05] = mode; // Mode
packet[0x06] = speed; // Speed, 0-4
packet[0x07] = brightness; // Brightness, 0-4
packet[0x08] = color; // Separator FF or Color, 0-7 (0-6 in static color mode) (Rainbow,) R, G, B, Y, M, C, W
}
void ZETBladeOpticalController::SetLEDDirect(const std::vector<RGBColor>& colors, unsigned char brightness, int led)
{
unsigned char buf[65];
/*-----------------------------------------------------*\
| Zero out buffer and prepare packet header |
\*-----------------------------------------------------*/
memset(buf, 0x00, sizeof(buf));
PrepareHeader(buf, brightness);
/*-----------------------------------------------------*\
| Variables to keep track of color sending and skipping |
\*-----------------------------------------------------*/
size_t buf_idx = ZET_BLADE_OPTICAL_HEADER_LEN;
size_t color_idx = 0;
size_t packets_sent = 0;
size_t skipped = 0;
const unsigned int* skip_idx = &SKIP_INDICES[0];
bool last_color = false;
bool ending_flag = false;
/*-----------------------------------------------------*\
| Continue filling and sending packets while color data |
| remains |
\*-----------------------------------------------------*/
while (color_idx < colors.size())
{
/*-------------------------------------------------*\
| If at a skipped index, increment skipped count |
| and index |
\*-------------------------------------------------*/
if (*skip_idx == color_idx + skipped)
{
skip_idx++;
if (skip_idx >= SKIP_INDICES + sizeof(SKIP_INDICES) / sizeof(unsigned int))
{
skip_idx = SKIP_INDICES;
}
skipped++;
continue;
}
/*-------------------------------------------------*\
| Packets have colors in groups of 4 bytes, with |
| the first byte being key id and then R, G, B. |
\*-------------------------------------------------*/
buf[buf_idx] = color_idx + skipped + ZET_BLADE_OPTICAL_KEY_OFFSET;
buf[buf_idx + 1] = RGBGetRValue(colors[color_idx]);
buf[buf_idx + 2] = RGBGetGValue(colors[color_idx]);
buf[buf_idx + 3] = RGBGetBValue(colors[color_idx]);
/*-------------------------------------------------*\
| Increment packet buffer index by 4 bytes |
\*-------------------------------------------------*/
buf_idx += ZET_BLADE_OPTICAL_COLOR_LEN;
color_idx++;
last_color = (color_idx == colors.size());
/*-------------------------------------------------*\
| If the packet buffer is full, send it and reset |
| buffer indexing |
| OR |
| If all colors have been filled into the buffer, |
| send the packet |
\*-------------------------------------------------*/
if ((buf_idx + ZET_BLADE_OPTICAL_HEADER_LEN >= sizeof(buf)) || last_color)
{
/*---------------------------------------------*\
| If we still have place for an |
| ending sequence - squeeze it in! |
\*---------------------------------------------*/
if (last_color && (buf_idx + ZET_BLADE_OPTICAL_COLOR_LEN < sizeof(buf)))
{
buf[buf_idx] = 0xFF;
ending_flag = true;
}
/*---------------------------------------------*\
| Send packet |
\*---------------------------------------------*/
hid_write(dev, buf, sizeof(buf));
/*---------------------------------------------*\
| Wait for the poor slowpoke to process packet |
\*---------------------------------------------*/
std::this_thread::sleep_for(ZET_BLADE_OPTICAL_DELAY);
/*---------------------------------------------*\
| Zero out buffer, reset index, prepare header |
\*---------------------------------------------*/
memset(buf, 0x00, sizeof(buf));
buf_idx = ZET_BLADE_OPTICAL_HEADER_LEN;
PrepareHeader(buf, brightness);
/*---------------------------------------------*\
| Increment packet counter |
\*---------------------------------------------*/
packets_sent++;
}
}
/*---------------------------------------------*\
| If there's anything left to send - send it |
\*---------------------------------------------*/
if (!ending_flag)
{
buf[buf_idx] = 0xFF;
hid_write(dev, buf, sizeof(buf));
std::this_thread::sleep_for(ZET_BLADE_OPTICAL_DELAY);
}
}
unsigned char ZETBladeOpticalController::RGBToPalette(unsigned char red,
unsigned char grn,
unsigned char blu
)
{
/*------------------------*\
| 0 0 1 (1) -> (1) Red |
| 0 1 0 (2) -> (2) Green |
| 0 1 1 (3) -> (4) Yellow |
| 1 0 0 (4) -> (3) Blue |
| 1 0 1 (5) -> (5) Magenta |
| 1 1 0 (6) -> (6) Cyan |
| 1 1 1 (7) -> (7) White |
\*------------------------*/
unsigned char color_mask = ((blu > 127) << 2 & 4) | ((grn > 127) << 1 & 2) | ((red > 127) & 1);
switch (color_mask) // (Rainbow/Off,) R, G, B, Y, M, C, W
{
case 3:
return 4;
case 4:
return 3;
default:
return color_mask;
}
}
void ZETBladeOpticalController::SetEffect(unsigned char mode,
unsigned char speed,
unsigned char brightness,
bool random,
unsigned char red,
unsigned char grn,
unsigned char blu
)
{
/*-------------------------------------------------------------*\
| Prep some status variables and return if we're in custom mode |
\*-------------------------------------------------------------*/
bool static_mode = (mode == ZET_BLADE_OPTICAL_MODE_STATIC);
effect_mode = mode;
custom_mode = (effect_mode == ZET_BLADE_OPTICAL_MODE_CUSTOM);
if (custom_mode) return;
unsigned char color = RGBToPalette(red, grn, blu);
unsigned char buf[65];
/*-----------------------------------------------------*\
| Zero out buffer and prepare packet |
\*-----------------------------------------------------*/
memset(buf, 0x00, sizeof(buf));
brightness = (static_mode && color == 0) ? 0 : brightness;
color = (static_mode && color > 0) ? (color - 1) : color;
color = random ? 0 : color;
PrepareHeader(buf, mode, speed, brightness, color);
/*---------------------------------------------*\
| Send packet... and wait |
\*---------------------------------------------*/
hid_write(dev, buf, sizeof(buf));
std::this_thread::sleep_for(ZET_BLADE_OPTICAL_DELAY);
}

69
Controllers/ZETKeyboardController/ZETBladeOpticalController.h Normal file
View file

@ -0,0 +1,69 @@
/*-----------------------------------------*\
| ZETBladeOpticalController.h |
| |
| Definitions and types for ZET Blade |
| Optical Keyboard lighting controller |
| |
| Based on HyperX Alloy Elite2 impl by |
| KundaPanda |
| |
| Moon_darker (Vaker) 23/01/2022 |
\*-----------------------------------------*/
#include "RGBController.h"
#include <string>
#include <hidapi/hidapi.h>
#pragma once
#define ZET_BLADE_OPTICAL_DELAY 12ms
#define ZET_BLADE_OPTICAL_HEADER_LEN 9
#define ZET_BLADE_OPTICAL_COLOR_LEN 4
#define ZET_BLADE_OPTICAL_KEY_OFFSET 0x80
#define ZET_BLADE_OPTICAL_SPEED_MIN 0
#define ZET_BLADE_OPTICAL_SPEED_MAX 4
#define ZET_BLADE_OPTICAL_SPEED_DEF 2
#define ZET_BLADE_OPTICAL_BRIGHTNESS_MIN 0
#define ZET_BLADE_OPTICAL_BRIGHTNESS_MAX 4
#define ZET_BLADE_OPTICAL_BRIGHTNESS_DEF 4
#define ZET_BLADE_OPTICAL_MODE_OFF 0x01
#define ZET_BLADE_OPTICAL_MODE_CUSTOM 0x1C
#define ZET_BLADE_OPTICAL_MODE_STATIC 0x02
#define ZET_BLADE_OPTICAL_MODE_BREATHING 0x03
#define ZET_BLADE_OPTICAL_MODE_ON_PRESS 0x04
#define ZET_BLADE_OPTICAL_MODE_RAINDROP 0x05
#define ZET_BLADE_OPTICAL_MODE_RIPPLE 0x06
#define ZET_BLADE_OPTICAL_MODE_LASER 0x07
#define ZET_BLADE_OPTICAL_MODE_WAVES 0x08
#define ZET_BLADE_OPTICAL_MODE_RAIN 0x09
#define ZET_BLADE_OPTICAL_MODE_SPECTRUM 0x0A
#define ZET_BLADE_OPTICAL_MODE_SURFING_RIGHT 0x0B
#define ZET_BLADE_OPTICAL_MODE_SURFING_CENTER 0x0D
#define ZET_BLADE_OPTICAL_MODE_SURFING_CROSS 0x0F
#define ZET_BLADE_OPTICAL_MODE_ROTATE_MARQUEE 0x0C
#define ZET_BLADE_OPTICAL_MODE_TRAFFIC 0x0E
#define ZET_BLADE_OPTICAL_MODE_GRADIENT 0x15
class ZETBladeOpticalController
{
public:
ZETBladeOpticalController(hid_device* dev_handle, const char* path);
~ZETBladeOpticalController();
std::string GetDeviceLocation();
std::string GetSerialString();
void SetLEDDirect(const std::vector<RGBColor>& colors, unsigned char brightness, int led);
void SetEffect(unsigned char mode, unsigned char speed, unsigned char brightness, bool random, unsigned char red1, unsigned char grn1, unsigned char blu1);
private:
hid_device* dev;
std::string location;
unsigned int effect_mode;
bool custom_mode;
void PrepareHeader(unsigned char *packet, unsigned char brightness);
void PrepareHeader(unsigned char *packet, unsigned char mode, unsigned char speed, unsigned char brightness, unsigned char color);
unsigned char RGBToPalette(unsigned char red, unsigned char grn, unsigned char blu);
};

27
Controllers/ZETKeyboardController/ZETKeyboardControllerDetect.cpp Normal file
View file

@ -0,0 +1,27 @@
#include "Detector.h"
#include "ZETBladeOpticalController.h"
#include "RGBController.h"
#include "RGBController_ZETBladeOptical.h"
#include <hidapi/hidapi.h>
/*-----------------------------------------------------*\
| ZET keyboard VID/PID pairs |
\*-----------------------------------------------------*/
#define ZET_BLADE_OPTICAL_VID 0x2EA8
#define ZET_BLADE_OPTICAL_PID 0x2125
void DetectZETBladeOptical(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if (dev)
{
ZETBladeOpticalController* controller = new ZETBladeOpticalController(dev, info->path);
RGBController_ZETBladeOptical* rgb_controller = new RGBController_ZETBladeOptical(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR_IP("ZET Blade Optical", DetectZETBladeOptical, ZET_BLADE_OPTICAL_VID, ZET_BLADE_OPTICAL_PID, 1, 0xFF00);