Salastil/OpenRGB
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implemented a qmk rgb matrix controller

Browse Source
This commit is contained in:
Kasper
2020-11-11 04:14:40 +02:00
parent f106e83c94
commit f7af8a432e
6 changed files with 1280 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Controllers/QMKRGBMatrixController/QMKRGBMatrixController.cpp
+465
View File
@@ -0,0 +1,465 @@
/*-------------------------------------------------------------------*\
| QMKRGBMatrixController.cpp |
| |
| Driver for QMK keybaords using RGB Matrix |
| |
| Kasper 10th Octobber 2020 |
| |
\*-------------------------------------------------------------------*/
#include "QMKRGBMatrixController.h"
QMKRGBMatrixController::QMKRGBMatrixController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
}
QMKRGBMatrixController::~QMKRGBMatrixController()
{
hid_close(dev);
}
void QMKRGBMatrixController::SetSingleLED(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_SET_SINGLE_LED;
usb_buf[0x02] = led;
usb_buf[0x03] = red;
usb_buf[0x04] = green;
usb_buf[0x05] = blue;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
hid_read(dev, usb_buf, 65);
}
void QMKRGBMatrixController::SetLEDs(RGBColor* colors, unsigned int num_colors)
{
unsigned int leds_sent = 0;
while(leds_sent < num_colors)
{
unsigned int leds_to_send = 2;
if((num_colors - leds_sent) < leds_to_send)
{
leds_to_send = num_colors - leds_sent;
}
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_SET_LEDS;
usb_buf[0x02] = leds_sent;
usb_buf[0x03] = leds_to_send;
for(unsigned int led_idx = 0; led_idx < leds_to_send; led_idx++)
{
usb_buf[(led_idx * 3) + 4] = RGBGetRValue(colors[led_idx + leds_sent]);
usb_buf[(led_idx * 3) + 5] = RGBGetGValue(colors[led_idx + leds_sent]);
usb_buf[(led_idx * 3) + 6] = RGBGetBValue(colors[led_idx + leds_sent]);
}
hid_write(dev, usb_buf, 65);
leds_sent += leds_to_send;
}
}
void QMKRGBMatrixController::SetMode(unsigned char mode)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_SET_MODE;
usb_buf[0x02] = QMK_RGBMATRIX_EEPROM_DONT_SAVE;
usb_buf[0x03] = mode;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
hid_read(dev, usb_buf, 65);
}
void QMKRGBMatrixController::SetModeAndSpeed(unsigned char mode, unsigned char speed)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_SET_MODE_AND_SPEED;
usb_buf[0x02] = QMK_RGBMATRIX_EEPROM_DONT_SAVE;
usb_buf[0x03] = mode;
usb_buf[0x04] = speed;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
hid_read(dev, usb_buf, 65);
}
void QMKRGBMatrixController::SetColorModeAndSpeed(hsv_t hsv_color, unsigned char mode, unsigned char speed)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_SET_COLOR_MODE_AND_SPEED;
usb_buf[0x02] = QMK_RGBMATRIX_EEPROM_DONT_SAVE;
// qmk hue range is between 0-255, instead of the regular 0-359, so hue needs to be converted
unsigned int oldRange = 359;
unsigned int newRange = 255;
unsigned int convertedHue = (hsv_color.hue * newRange / oldRange);
usb_buf[0x03] = convertedHue;
usb_buf[0x04] = hsv_color.saturation;
usb_buf[0x05] = hsv_color.value;
usb_buf[0x06] = mode;
usb_buf[0x07] = speed;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
hid_read(dev, usb_buf, 65);
}
std::string QMKRGBMatrixController::GetLocation()
{
return location;
}
std::string QMKRGBMatrixController::GetVersion()
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_GET_QMK_VERSION;
hid_write(dev, (unsigned char*)usb_buf, 65);
hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
int i = 1;
std::string name;
while(usb_buf[i] != 0)
{
name.push_back(usb_buf[i]);
i++;
}
return name;
}
std::string QMKRGBMatrixController::GetName()
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_GET_DEVICE_NAME;
hid_write(dev, (unsigned char*)usb_buf, 65);
hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
int i = 1;
std::string name;
while(usb_buf[i] != 0)
{
name.push_back(usb_buf[i]);
i++;
}
return name;
}
unsigned int QMKRGBMatrixController::GetZonesCount()
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_GET_ZONES_COUNT;
hid_write(dev, (unsigned char*)usb_buf, 65);
hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
return usb_buf[1];
}
std::string QMKRGBMatrixController::GetZoneName(int zone)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_GET_ZONE_NAME;
usb_buf[0x02] = zone;
hid_write(dev, (unsigned char*)usb_buf, 65);
hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
int i = 1;
std::string name;
while(usb_buf[i] != 0)
{
name.push_back(usb_buf[i]);
i++;
}
return name;
}
unsigned int QMKRGBMatrixController::GetZoneType(int zone)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_GET_ZONE_TYPE;
usb_buf[0x02] = zone;
hid_write(dev, (unsigned char*)usb_buf, 65);
hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
return usb_buf[1];
}
unsigned int QMKRGBMatrixController::GetZoneSize(int zone)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_GET_ZONE_SIZE;
usb_buf[0x02] = zone;
hid_write(dev, (unsigned char*)usb_buf, 65);
hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
return usb_buf[1];
}
std::string QMKRGBMatrixController::GetLEDName(int led)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_GET_LED_NAME;
usb_buf[0x02] = led;
hid_write(dev, (unsigned char*)usb_buf, 65);
hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
int i = 1;
std::string name;
while(usb_buf[i] != 0)
{
name.push_back(usb_buf[i]);
i++;
}
return name;
}
unsigned int QMKRGBMatrixController::GetLEDMatirxRows()
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_GET_LED_MATRIX_ROWS;
hid_write(dev, (unsigned char*)usb_buf, 65);
hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
return usb_buf[1];
}
unsigned int QMKRGBMatrixController::GetLEDMatirxColumns()
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_GET_LED_MATRIX_COLUMNS;
hid_write(dev, (unsigned char*)usb_buf, 65);
hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
return usb_buf[1];
}
unsigned int QMKRGBMatrixController::GetLEDValueInMatrix(int column, int row)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_GET_LED_VALUE_IN_MATRIX;
usb_buf[0x02] = column;
usb_buf[0x03] = row;
hid_write(dev, (unsigned char*)usb_buf, 65);
hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
return usb_buf[1];
}
RGBColor QMKRGBMatrixController::GetLEDColor(unsigned int led)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_GET_LED_COLOR;
usb_buf[0x02] = led;
hid_write(dev, (unsigned char*)usb_buf, 65);
hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
return ToRGBColor(usb_buf[1], usb_buf[2], usb_buf[3]);
}
unsigned int QMKRGBMatrixController::GetHSV()
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = QMK_RGBMATRIX_GET_HSV;
hid_write(dev, (unsigned char*)usb_buf, 65);
hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
// qmk hue range is between 0-255, instead of the regular 0-359, so hue needs to be converted
unsigned int oldRange = 255;
unsigned int newRange = 359;
unsigned int convertedHue = (usb_buf[1] * newRange / oldRange);
hsv_t hsv;
hsv.hue = convertedHue;
hsv.saturation = usb_buf[2];
hsv.value = usb_buf[3];
return hsv2rgb(&hsv);
}
Controllers/QMKRGBMatrixController/QMKRGBMatrixController.h
+129
View File
@@ -0,0 +1,129 @@
/*-------------------------------------------------------------------*\
| QMKRGBMatrixController.h |
| |
| Driver for QMK keybaords using RGB Matrix |
| |
| Kasper 10th Octobber 2020 |
| |
\*-------------------------------------------------------------------*/
#include <string>
#include <array>
#include <hidapi/hidapi.h>
#include "RGBController.h"
#include "hsv.h"
#pragma once
enum CommandsId
{
QMK_RGBMATRIX_SET_SINGLE_LED = 3,
QMK_RGBMATRIX_SET_LEDS,
QMK_RGBMATRIX_SET_MODE,
QMK_RGBMATRIX_SET_MODE_AND_SPEED,
QMK_RGBMATRIX_SET_COLOR_MODE_AND_SPEED,
QMK_RGBMATRIX_GET_QMK_VERSION,
QMK_RGBMATRIX_GET_DEVICE_NAME,
QMK_RGBMATRIX_GET_ZONES_COUNT,
QMK_RGBMATRIX_GET_ZONE_NAME,
QMK_RGBMATRIX_GET_ZONE_TYPE,
QMK_RGBMATRIX_GET_ZONE_SIZE,
QMK_RGBMATRIX_GET_LED_NAME,
QMK_RGBMATRIX_GET_LED_MATRIX_COLUMNS,
QMK_RGBMATRIX_GET_LED_MATRIX_ROWS,
QMK_RGBMATRIX_GET_LED_VALUE_IN_MATRIX,
QMK_RGBMATRIX_GET_LED_COLOR,
QMK_RGBMATRIX_GET_HSV
};
enum EEPROMCommands
{
QMK_RGBMATRIX_EEPROM_SAVE,
QMK_RGBMATRIX_EEPROM_DONT_SAVE
};
enum ModeCommands
{
QMK_RGBMATRIX_MODE_HID_DIRECT = 1,
QMK_RGBMATRIX_MODE_STATIC,
QMK_RGBMATRIX_MODE_ALPHA_MOD,
QMK_RGBMATRIX_MODE_STATIC_GRADIENT_LEFT_RIGHT,
QMK_RGBMATRIX_MODE_STATIC_GRADIENT_UP_DOWN,
QMK_RGBMATRIX_MODE_BREATHING,
QMK_RGBMATRIX_MODE_BAND_SAT,
QMK_RGBMATRIX_MODE_BAND_VAL,
QMK_RGBMATRIX_MODE_BAND_PINWHEEL_SAT,
QMK_RGBMATRIX_MODE_BAND_PINWHEEL_VAL,
QMK_RGBMATRIX_MODE_BAND_SPIRAL_SAT,
QMK_RGBMATRIX_MODE_BAND_SPIRAL_VAL,
QMK_RGBMATRIX_MODE_CYCLE_ALL,
QMK_RGBMATRIX_MODE_CYCLE_LEFT_RIGHT,
QMK_RGBMATRIX_MODE_CYCLE_UP_DOWN,
QMK_RGBMATRIX_MODE_CYCLE_OUT_IN,
QMK_RGBMATRIX_MODE_CYCLE_OUT_IN_DUAL,
QMK_RGBMATRIX_MODE_RAINBOW_MOVING_CHEVRON,
QMK_RGBMATRIX_MODE_DUAL_BEACON,
QMK_RGBMATRIX_MODE_CYCLE_PINWHEEL,
QMK_RGBMATRIX_MODE_CYCLE_SPIRAL,
QMK_RGBMATRIX_MODE_RAINBOW_BEACON,
QMK_RGBMATRIX_MODE_RAINBOW_PINWHEELS,
QMK_RGBMATRIX_MODE_RAINDROPS,
QMK_RGBMATRIX_MODE_JELLYBEAN_RAINDROPS,
QMK_RGBMATRIX_MODE_TYPING_HEATMAP,
QMK_RGBMATRIX_MODE_DIGITAL_RAIN,
QMK_RGBMATRIX_MODE_SOLID_REACTIVE,
QMK_RGBMATRIX_MODE_SOLID_REACTIVE_SIMPLE,
QMK_RGBMATRIX_MODE_SOLID_REACTIVE_WIDE,
QMK_RGBMATRIX_MODE_SOLID_REACTIVE_MULTIWIDE,
QMK_RGBMATRIX_MODE_SOLID_REACTIVE_CROSS,
QMK_RGBMATRIX_MODE_SOLID_REACTIVE_MULTICROSS,
QMK_RGBMATRIX_MODE_SOLID_REACTIVE_NEXUS,
QMK_RGBMATRIX_MODE_SOLID_REACTIVE_MULTINEXUS,
QMK_RGBMATRIX_MODE_SPLASH,
QMK_RGBMATRIX_MODE_MULTISPLASH,
QMK_RGBMATRIX_MODE_SOLID_SPLASH,
QMK_RGBMATRIX_MODE_SOLID_MULTISPLASH,
};
enum SpeedCommands
{
QMK_RGBMATRIX_SPEED_SLOWEST = 0x00, /* Slowest speed */
QMK_RGBMATRIX_SPEED_NORMAL = 0x7F, /* Normal speed */
QMK_RGBMATRIX_SPEED_FASTEST = 0xFF, /* Fastest speed */
};
class QMKRGBMatrixController
{
public:
QMKRGBMatrixController(hid_device* dev_handle, const char* path);
~QMKRGBMatrixController();
void SetSingleLED(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
void SetLEDs(RGBColor* colors, unsigned int num_colors);
void SetMode(unsigned char mode);
void SetModeAndSpeed(unsigned char mode, unsigned char speed);
void SetColorModeAndSpeed(hsv_t hsv_color, unsigned char mode, unsigned char speed);
std::string GetLocation();
std::string GetVersion();
std::string GetName();
unsigned int GetZonesCount();
std::string GetZoneName(int zone);
unsigned int GetZoneType(int zone);
unsigned int GetZoneSize(int zone);
std::string GetLEDName(int led);
unsigned int GetLEDMatirxRows();
unsigned int GetLEDMatirxColumns();
unsigned int GetLEDValueInMatrix(int column, int row);
RGBColor GetLEDColor(unsigned int led);
unsigned int GetHSV();
protected:
hid_device* dev;
private:
std::string location;
};
Controllers/QMKRGBMatrixController/QMKRGBMatrixControllerDetect.cpp
+81
View File
@@ -0,0 +1,81 @@
/*-------------------------------------------------------------------*\
| QMKRGBMatrixControllerDetect.cpp |
| |
| Driver for QMK keybaords using RGB Matrix |
| |
| Kasper24 11th November 2020 |
| |
\*-------------------------------------------------------------------*/
#include "Detector.h"
#include "QMKRGBMatrixController.h"
#include "RGBController.h"
#include "RGBController_QMKRGBMatrix.h"
#include <hidapi/hidapi.h>
#define MASSDROP_VID 0x04D8
#define MASSDROP_ALT_PID 0xEED3
#define MASSDROP_CTRL_PID 0xEED2
typedef struct
{
unsigned short usb_vid;
unsigned short usb_pid;
unsigned char usb_interface;
const char * name;
} qmk_rgb_matrix_device;
#define QMK_RGB_MATRIX_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
static const qmk_rgb_matrix_device device_list[] =
{
{ MASSDROP_VID, MASSDROP_ALT_PID, 1, "Massdrop Alt" },
{ MASSDROP_VID, MASSDROP_CTRL_PID, 1, "Massdrop Ctrl" },
};
/******************************************************************************************\
* *
* DetectQMKRGBMatrixControllers *
* *
* Tests the USB address to see if any QMK RGB Matrix controllers exists there. *
* *
\******************************************************************************************/
void DetectQMKRGBMatrixControllers(std::vector<RGBController*>& rgb_controllers)
{
hid_device_info* info;
hid_device* dev = NULL;
hid_init();
for(std::size_t device_idx = 0; device_idx < QMK_RGB_MATRIX_NUM_DEVICES; device_idx++)
{
dev = NULL;
info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
while(info)
{
if
(
info->vendor_id == device_list[device_idx].usb_vid &&
info->product_id == device_list[device_idx].usb_pid &&
info->interface_number == device_list[device_idx].usb_interface
)
{
dev = hid_open_path(info->path);
if(dev)
{
QMKRGBMatrixController* controller = new QMKRGBMatrixController(dev, info->path);
RGBController_QMKRGBMatrix* rgb_controller = new RGBController_QMKRGBMatrix(controller);
rgb_controllers.push_back(rgb_controller);
}
}
info = info->next;
}
}
}
REGISTER_DETECTOR("QMKRGBMatrix", DetectQMKRGBMatrixControllers);
Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.cpp
+568
View File
@@ -0,0 +1,568 @@
/*-------------------------------------------------------------------*\
| RGBController_QMKRGBMatrix.cpp |
| |
| Driver for QMK keybaords using RGB Matrix |
| |
| Kasper24 11th November 2020 |
| |
\*-------------------------------------------------------------------*/
#include "hsv.h"
#include "RGBController_QMKRGBMatrix.h"
RGBController_QMKRGBMatrix::RGBController_QMKRGBMatrix(QMKRGBMatrixController* qmk_rgb_matrix_ptr)
{
qmk_rgb_matrix = qmk_rgb_matrix_ptr;
name = qmk_rgb_matrix_ptr->GetName();
description = "QMK RGB Matrix Device";
type = DEVICE_TYPE_KEYBOARD;
location = qmk_rgb_matrix_ptr->GetLocation();
version = qmk_rgb_matrix_ptr->GetVersion();
mode Direct;
Direct.name = "Direct";
Direct.value = QMK_RGBMATRIX_MODE_HID_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Static;
Static.name = "Static";
Static.value = QMK_RGBMATRIX_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
Static.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
Static.colors_min = 1;
Static.colors_max = 1;
Static.speed = QMK_RGBMATRIX_SPEED_NORMAL;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
Static.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(Static);
/*mode AlphaMod;
AlphaMod.name = "Alpha Mod";
AlphaMod.value = QMK_RGBMATRIX_MODE_ALPHA_MOD;
AlphaMod.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED;
AlphaMod.color_mode = MODE_COLORS_PER_LED;
AlphaMod.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
AlphaMod.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
AlphaMod.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(AlphaMod);
mode StaticHorizontalGradient;
StaticHorizontalGradient.name = "Static Horizontal Gradient";
StaticHorizontalGradient.value = QMK_RGBMATRIX_MODE_STATIC_GRADIENT_LEFT_RIGHT;
StaticHorizontalGradient.flags = 0;
modes.push_back(StaticHorizontalGradient);
mode StaticVerticalGradient;
StaticVerticalGradient.name = "Static Vertical Gradient";
StaticVerticalGradient.value = QMK_RGBMATRIX_MODE_STATIC_GRADIENT_UP_DOWN;
StaticVerticalGradient.flags = 0;
modes.push_back(StaticVerticalGradient);*/
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = QMK_RGBMATRIX_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Breathing.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
Breathing.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.speed = QMK_RGBMATRIX_SPEED_NORMAL;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize(1);
Breathing.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(Breathing);
mode ScrollOnWhite;
ScrollOnWhite.name = "Scroll On White";
ScrollOnWhite.value = QMK_RGBMATRIX_MODE_BAND_SAT;
ScrollOnWhite.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
ScrollOnWhite.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
ScrollOnWhite.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
ScrollOnWhite.colors_min = 1;
ScrollOnWhite.colors_max = 1;
ScrollOnWhite.speed = QMK_RGBMATRIX_SPEED_NORMAL;
ScrollOnWhite.color_mode = MODE_COLORS_MODE_SPECIFIC;
ScrollOnWhite.colors.resize(1);
ScrollOnWhite.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(ScrollOnWhite);
mode Scroll;
Scroll.name = "Scroll";
Scroll.value = QMK_RGBMATRIX_MODE_BAND_VAL;
Scroll.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Scroll.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
Scroll.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
Scroll.colors_min = 1;
Scroll.colors_max = 1;
Scroll.speed = QMK_RGBMATRIX_SPEED_NORMAL;
Scroll.color_mode = MODE_COLORS_MODE_SPECIFIC;
Scroll.colors.resize(1);
Scroll.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(Scroll);
mode PinWheelSpinOnWhite;
PinWheelSpinOnWhite.name = "PinWheel Spin On White";
PinWheelSpinOnWhite.value = QMK_RGBMATRIX_MODE_BAND_PINWHEEL_SAT;
PinWheelSpinOnWhite.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
PinWheelSpinOnWhite.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
PinWheelSpinOnWhite.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
PinWheelSpinOnWhite.colors_min = 1;
PinWheelSpinOnWhite.colors_max = 1;
PinWheelSpinOnWhite.speed = QMK_RGBMATRIX_SPEED_NORMAL;
PinWheelSpinOnWhite.color_mode = MODE_COLORS_MODE_SPECIFIC;
PinWheelSpinOnWhite.colors.resize(1);
PinWheelSpinOnWhite.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(PinWheelSpinOnWhite);
mode PinWheelSpin;
PinWheelSpin.name = "PinWheel Spin";
PinWheelSpin.value = QMK_RGBMATRIX_MODE_BAND_PINWHEEL_VAL;
PinWheelSpin.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
PinWheelSpin.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
PinWheelSpin.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
PinWheelSpin.colors_min = 1;
PinWheelSpin.colors_max = 1;
PinWheelSpin.speed = QMK_RGBMATRIX_SPEED_NORMAL;
PinWheelSpin.color_mode = MODE_COLORS_MODE_SPECIFIC;
PinWheelSpin.colors.resize(1);
PinWheelSpin.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(PinWheelSpin);
mode SpiralSpinOnWhite;
SpiralSpinOnWhite.name = "Spiral Spin On White";
SpiralSpinOnWhite.value = QMK_RGBMATRIX_MODE_BAND_SPIRAL_SAT;
SpiralSpinOnWhite.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
SpiralSpinOnWhite.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
SpiralSpinOnWhite.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
SpiralSpinOnWhite.colors_min = 1;
SpiralSpinOnWhite.colors_max = 1;
SpiralSpinOnWhite.speed = QMK_RGBMATRIX_SPEED_NORMAL;
SpiralSpinOnWhite.color_mode = MODE_COLORS_MODE_SPECIFIC;
SpiralSpinOnWhite.colors.resize(1);
SpiralSpinOnWhite.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(SpiralSpinOnWhite);
mode SpiralSpin;
SpiralSpin.name = "Spiral Spin";
SpiralSpin.value = QMK_RGBMATRIX_MODE_BAND_SPIRAL_VAL;
SpiralSpin.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
SpiralSpin.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
SpiralSpin.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
SpiralSpin.colors_min = 1;
SpiralSpin.colors_max = 1;
SpiralSpin.speed = QMK_RGBMATRIX_SPEED_NORMAL;
SpiralSpin.color_mode = MODE_COLORS_MODE_SPECIFIC;
SpiralSpin.colors.resize(1);
SpiralSpin.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(SpiralSpin);
mode ColorCycle;
ColorCycle.name = "Color Cycle";
ColorCycle.value = QMK_RGBMATRIX_MODE_CYCLE_ALL;
ColorCycle.flags = MODE_FLAG_HAS_SPEED;
ColorCycle.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
ColorCycle.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
ColorCycle.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(ColorCycle);
mode RainbowHorizontal;
RainbowHorizontal.name = "Rainbow Horizontal";
RainbowHorizontal.value = QMK_RGBMATRIX_MODE_CYCLE_LEFT_RIGHT;
RainbowHorizontal.flags = MODE_FLAG_HAS_SPEED;
RainbowHorizontal.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
RainbowHorizontal.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
RainbowHorizontal.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(RainbowHorizontal);
mode RainbowVertical;
RainbowVertical.name = "Rainbow Vertical";
RainbowVertical.value = QMK_RGBMATRIX_MODE_CYCLE_UP_DOWN;
RainbowVertical.flags = MODE_FLAG_HAS_SPEED;
RainbowVertical.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
RainbowVertical.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
RainbowVertical.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(RainbowVertical);
mode RainbowOutIn;
RainbowOutIn.name = "Rainbow Out In";
RainbowOutIn.value = QMK_RGBMATRIX_MODE_CYCLE_OUT_IN;
RainbowOutIn.flags = MODE_FLAG_HAS_SPEED;
RainbowOutIn.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
RainbowOutIn.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
RainbowOutIn.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(RainbowOutIn);
mode RainbowOutInDual;
RainbowOutInDual.name = "Rainbow Out In Dual";
RainbowOutInDual.value = QMK_RGBMATRIX_MODE_CYCLE_OUT_IN_DUAL;
RainbowOutInDual.flags = MODE_FLAG_HAS_SPEED;
RainbowOutInDual.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
RainbowOutInDual.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
RainbowOutInDual.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(RainbowOutInDual);
mode RainbowMovingChevron;
RainbowMovingChevron.name = "Rainbow Moving Chevron";
RainbowMovingChevron.value = QMK_RGBMATRIX_MODE_RAINBOW_MOVING_CHEVRON;
RainbowMovingChevron.flags = MODE_FLAG_HAS_SPEED;
RainbowMovingChevron.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
RainbowMovingChevron.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
RainbowMovingChevron.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(RainbowMovingChevron);
mode RainbowDualBeacon;
RainbowDualBeacon.name = "Rainbow Dual Beacons";
RainbowDualBeacon.value = QMK_RGBMATRIX_MODE_DUAL_BEACON;
RainbowDualBeacon.flags = MODE_FLAG_HAS_SPEED;
RainbowDualBeacon.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
RainbowDualBeacon.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
RainbowDualBeacon.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(RainbowDualBeacon);
mode RainbowPinWheel;
RainbowPinWheel.name = "Rainbow Pin Wheel";
RainbowPinWheel.value = QMK_RGBMATRIX_MODE_CYCLE_PINWHEEL;
RainbowPinWheel.flags = MODE_FLAG_HAS_SPEED;
RainbowPinWheel.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
RainbowPinWheel.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
RainbowPinWheel.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(RainbowPinWheel);
mode RainbowCycleSpiral;
RainbowCycleSpiral.name = "Rainbow Spiral";
RainbowCycleSpiral.value = QMK_RGBMATRIX_MODE_CYCLE_SPIRAL;
RainbowCycleSpiral.flags = MODE_FLAG_HAS_SPEED;
RainbowCycleSpiral.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
RainbowCycleSpiral.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
RainbowCycleSpiral.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(RainbowCycleSpiral);
mode RainbowBeacon;
RainbowBeacon.name = "Rainbow Beacon";
RainbowBeacon.value = QMK_RGBMATRIX_MODE_RAINBOW_BEACON;
RainbowBeacon.flags = MODE_FLAG_HAS_SPEED;
RainbowBeacon.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
RainbowBeacon.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
RainbowBeacon.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(RainbowBeacon);
mode RainbowDualPinWheels;
RainbowDualPinWheels.name = "Rainbow Dual Pin Wheels";
RainbowDualPinWheels.value = QMK_RGBMATRIX_MODE_RAINBOW_PINWHEELS;
RainbowDualPinWheels.flags = MODE_FLAG_HAS_SPEED;
RainbowDualPinWheels.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
RainbowDualPinWheels.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
RainbowDualPinWheels.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(RainbowDualPinWheels);
mode Raindrops;
Raindrops.name = "Raindrops";
Raindrops.value = QMK_RGBMATRIX_MODE_RAINDROPS;
Raindrops.flags = 0;
modes.push_back(Raindrops);
mode JellybeanRaindrops;
JellybeanRaindrops.name = "Jellybean Raindrops";
JellybeanRaindrops.value = QMK_RGBMATRIX_MODE_JELLYBEAN_RAINDROPS;
JellybeanRaindrops.flags = 0;
modes.push_back(JellybeanRaindrops);
mode TypingHeatmap;
TypingHeatmap.name = "Typing Heatmap";
TypingHeatmap.value = QMK_RGBMATRIX_MODE_TYPING_HEATMAP;
TypingHeatmap.flags = 0;
modes.push_back(TypingHeatmap);
mode DigitalRain;
DigitalRain.name = "Digital Rain";
DigitalRain.value = QMK_RGBMATRIX_MODE_DIGITAL_RAIN;
DigitalRain.flags = 0;
modes.push_back(DigitalRain);
mode SolidReactive;
SolidReactive.name = "Solid Reactive";
SolidReactive.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE;
SolidReactive.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
SolidReactive.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
SolidReactive.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
SolidReactive.colors_min = 1;
SolidReactive.colors_max = 1;
SolidReactive.speed = QMK_RGBMATRIX_SPEED_NORMAL;
SolidReactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
SolidReactive.colors.resize(1);
SolidReactive.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(SolidReactive);
mode SolidReactiveSimple;
SolidReactiveSimple.name = "Solid Reactive Simple";
SolidReactiveSimple.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE_SIMPLE;
SolidReactiveSimple.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
SolidReactiveSimple.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
SolidReactiveSimple.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
SolidReactiveSimple.colors_min = 1;
SolidReactiveSimple.colors_max = 1;
SolidReactiveSimple.speed = QMK_RGBMATRIX_SPEED_NORMAL;
SolidReactiveSimple.color_mode = MODE_COLORS_MODE_SPECIFIC;
SolidReactiveSimple.colors.resize(1);
SolidReactiveSimple.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(SolidReactiveSimple);
mode SolidReactiveWide;
SolidReactiveWide.name = "Solid Reactive Wide";
SolidReactiveWide.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE_WIDE;
SolidReactiveWide.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
SolidReactiveWide.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
SolidReactiveWide.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
SolidReactiveWide.colors_min = 1;
SolidReactiveWide.colors_max = 1;
SolidReactiveWide.speed = QMK_RGBMATRIX_SPEED_NORMAL;
SolidReactiveWide.color_mode = MODE_COLORS_MODE_SPECIFIC;
SolidReactiveWide.colors.resize(1);
SolidReactiveWide.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(SolidReactiveWide);
/*mode SolidReactiveMultiWide;
SolidReactiveMultiWide.name = "Solid Reactive Multi Wide";
SolidReactiveMultiWide.value = QMK_RGBMATRIX_MODE_BREATHING;
SolidReactiveMultiWide.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
SolidReactiveMultiWide.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
SolidReactiveMultiWide.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
SolidReactiveMultiWide.colors_min = 2;
SolidReactiveMultiWide.colors_max = 2;
SolidReactiveMultiWide.speed = QMK_RGBMATRIX_SPEED_NORMAL;
SolidReactiveMultiWide.color_mode = MODE_COLORS_MODE_SPECIFIC;
SolidReactiveMultiWide.colors.resize(2);
modes.push_back(SolidReactiveMultiWide);*/
mode SolidReactiveCross;
SolidReactiveCross.name = "Solid Reactive Cross";
SolidReactiveCross.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE_CROSS;
SolidReactiveCross.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
SolidReactiveCross.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
SolidReactiveCross.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
SolidReactiveCross.colors_min = 1;
SolidReactiveCross.colors_max = 1;
SolidReactiveCross.speed = QMK_RGBMATRIX_SPEED_NORMAL;
SolidReactiveCross.color_mode = MODE_COLORS_MODE_SPECIFIC;
SolidReactiveCross.colors.resize(1);
SolidReactiveCross.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(SolidReactiveCross);
/*mode SolidReactiveMultiCross;
SolidReactiveMultiCross.name = "Solid Reactive Multi Cross";
SolidReactiveMultiCross.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE_MULTICROSS;
SolidReactiveMultiCross.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
SolidReactiveMultiCross.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
SolidReactiveMultiCross.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
SolidReactiveMultiCross.colors_min = 2;
SolidReactiveMultiCross.colors_max = 2;
SolidReactiveMultiCross.speed = QMK_RGBMATRIX_SPEED_NORMAL;
SolidReactiveMultiCross.color_mode = MODE_COLORS_MODE_SPECIFIC;
SolidReactiveMultiCross.colors.resize(2);
modes.push_back(SolidReactiveMultiCross)*/
mode SolidReactiveNexus;
SolidReactiveNexus.name = "Solid Reactive Nexus";
SolidReactiveNexus.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE_NEXUS;
SolidReactiveNexus.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
SolidReactiveNexus.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
SolidReactiveNexus.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
SolidReactiveNexus.colors_min = 1;
SolidReactiveNexus.colors_max = 1;
SolidReactiveNexus.speed = QMK_RGBMATRIX_SPEED_NORMAL;
SolidReactiveNexus.color_mode = MODE_COLORS_MODE_SPECIFIC;
SolidReactiveNexus.colors.resize(1);
SolidReactiveNexus.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(SolidReactiveNexus);
/*mode SolidReactiveMultiNexus;
SolidReactiveMultiNexus.name = "Solid Reactive Multi Nexus";
SolidReactiveMultiNexus.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE_MULTINEXUS;
SolidReactiveMultiNexus.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
SolidReactiveMultiNexus.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
SolidReactiveMultiNexus.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
SolidReactiveMultiNexus.colors_min = 2;
SolidReactiveMultiNexus.colors_max = 2;
SolidReactiveMultiNexus.speed = QMK_RGBMATRIX_SPEED_NORMAL;
SolidReactiveMultiNexus.color_mode = MODE_COLORS_MODE_SPECIFIC;
SolidReactiveMultiNexus.colors.resize(2);
modes.push_back(SolidReactiveMultiNexus);*/
mode Splash;
Splash.name = "Rainbow Reactive Splash";
Splash.value = QMK_RGBMATRIX_MODE_SPLASH;
Splash.flags = MODE_FLAG_HAS_SPEED;
Splash.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
Splash.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
Splash.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(Splash);
/*mode MultiSplash;
MultiSplash.name = "Rainbow Reactive Multi Splash";
MultiSplash.value = QMK_RGBMATRIX_MODE_MULTISPLASH;
MultiSplash.flags = MODE_FLAG_HAS_SPEED;
MultiSplash.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
MultiSplash.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
MultiSplash.speed = QMK_RGBMATRIX_SPEED_NORMAL;
modes.push_back(MultiSplash);*/
mode SolidSplash;
SolidSplash.name = "Solid Reactive Splash";
SolidSplash.value = QMK_RGBMATRIX_MODE_SOLID_SPLASH;
SolidSplash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
SolidSplash.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
SolidSplash.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
SolidSplash.colors_min = 1;
SolidSplash.colors_max = 1;
SolidSplash.speed = QMK_RGBMATRIX_SPEED_NORMAL;
SolidSplash.color_mode = MODE_COLORS_MODE_SPECIFIC;
SolidSplash.colors.resize(1);
SolidSplash.colors[0] = qmk_rgb_matrix->GetHSV();
modes.push_back(SolidSplash);
/*mode SolidMultiSplash;
SolidMultiSplash.name = "Solid Reactive Multi Splash";
SolidMultiSplash.value = QMK_RGBMATRIX_MODE_SOLID_MULTISPLASH;
SolidMultiSplash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
SolidMultiSplash.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST;
SolidMultiSplash.speed_max = QMK_RGBMATRIX_SPEED_FASTEST;
SolidMultiSplash.colors_min = 2;
SolidMultiSplash.colors_max = 2;
SolidMultiSplash.speed = QMK_RGBMATRIX_SPEED_NORMAL;
SolidMultiSplash.color_mode = MODE_COLORS_MODE_SPECIFIC;
SolidMultiSplash.colors.resize(2);
modes.push_back(SolidMultiSplash);*/
SetupZones();
}
RGBController_QMKRGBMatrix::~RGBController_QMKRGBMatrix()
{
for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
{
if(zones[zone_index].matrix_map != NULL)
{
delete zones[zone_index].matrix_map;
}
}
}
void RGBController_QMKRGBMatrix::SetupZones()
{
int led_index = 0;
int zone_count = qmk_rgb_matrix->GetZonesCount();
for(int i = 0; i < zone_count; i++)
{
unsigned int zone_led_count = qmk_rgb_matrix->GetZoneSize(i);
zone keyboard_zone;
keyboard_zone.name = qmk_rgb_matrix->GetZoneName(i);
keyboard_zone.type = qmk_rgb_matrix->GetZoneType(i);
keyboard_zone.leds_min = zone_led_count;
keyboard_zone.leds_max = zone_led_count;
keyboard_zone.leds_count = zone_led_count;
if(keyboard_zone.type == ZONE_TYPE_MATRIX)
{
unsigned int led_matrix_columns = qmk_rgb_matrix->GetLEDMatirxColumns();
unsigned int led_matrix_rows = qmk_rgb_matrix->GetLEDMatirxRows();
keyboard_zone.matrix_map = new matrix_map_type;
keyboard_zone.matrix_map->height = led_matrix_columns;
keyboard_zone.matrix_map->width = led_matrix_rows;
unsigned int* matrix_map = new unsigned int[led_matrix_rows * led_matrix_columns];
for(unsigned int y = 0; y < led_matrix_columns; y++)
{
for(unsigned int x = 0; x < led_matrix_rows; x++)
{
matrix_map[led_matrix_rows * y + x] = qmk_rgb_matrix->GetLEDValueInMatrix(y, x);
}
}
keyboard_zone.matrix_map->map = matrix_map;
}
else
{
keyboard_zone.matrix_map = NULL;
}
zones.push_back(keyboard_zone);
for(std::size_t led_idx = 0; led_idx < zone_led_count; led_idx++)
{
led keyboard_led;
keyboard_led.name = qmk_rgb_matrix->GetLEDName(led_index);
leds.push_back(keyboard_led);
led_index++;
}
}
SetupColors();
for(int i = 0; i < led_index; i++)
{
colors[i] = qmk_rgb_matrix->GetLEDColor(i);
}
}
void RGBController_QMKRGBMatrix::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_QMKRGBMatrix::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
qmk_rgb_matrix->SetLEDs(zones[zone_idx].colors, zones[zone_idx].leds_count);
}
}
void RGBController_QMKRGBMatrix::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_QMKRGBMatrix::UpdateSingleLED(int led)
{
RGBColor color = colors[led];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
qmk_rgb_matrix->SetSingleLED(led, red, grn, blu);
}
void RGBController_QMKRGBMatrix::SetCustomMode()
{
active_mode = 0;
}
void RGBController_QMKRGBMatrix::DeviceUpdateMode()
{
if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
{
qmk_rgb_matrix->SetMode(modes[active_mode].value);
}
else if(modes[active_mode].color_mode == MODE_COLORS_NONE)
{
qmk_rgb_matrix->SetModeAndSpeed(modes[active_mode].value, modes[active_mode].speed);
}
else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
{
RGBColor color = modes[active_mode].colors[0];
hsv_t hsv_color;
rgb2hsv(color, &hsv_color);
qmk_rgb_matrix->SetColorModeAndSpeed(hsv_color, modes[active_mode].value, modes[active_mode].speed);
}
}
Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.h
+31
View File
@@ -0,0 +1,31 @@
/*-------------------------------------------------------------------*\
| RGBController_QMKRGBMatrix.h |
| |
| Driver for QMK keybaords using RGB Matrix |
| |
| Kasper24 11th November 2020 |
| |
\*-------------------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "QMKRGBMatrixController.h"
class RGBController_QMKRGBMatrix : public RGBController
{
public:
RGBController_QMKRGBMatrix(QMKRGBMatrixController* qmk_rgb_matrix_ptr);
~RGBController_QMKRGBMatrix();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
QMKRGBMatrixController* qmk_rgb_matrix;
};
OpenRGB.pro
+6
View File
@@ -90,6 +90,7 @@ INCLUDEPATH +=
Controllers/PhilipsWizController/ \
Controllers/PolychromeController/ \
Controllers/PoseidonZRGBController/ \
Controllers/QMKRGBMatrixController/ \
Controllers/RedragonController/ \
Controllers/RGBFusionController/ \
Controllers/RGBFusion2DRAMController/ \
@@ -234,6 +235,8 @@ HEADERS +=
Controllers/PolychromeController/RGBController_Polychrome.h \
Controllers/PoseidonZRGBController/PoseidonZRGBController.h \
Controllers/PoseidonZRGBController/RGBController_PoseidonZRGB.h \
Controllers/QMKRGBMatrixController/QMKRGBMatrixController.h \
Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.h \
Controllers/RedragonController/RedragonK556Controller.h \
Controllers/RedragonController/RedragonM711Controller.h \
Controllers/RedragonController/RGBController_RedragonK556.h \
@@ -437,6 +440,9 @@ SOURCES +=
Controllers/PoseidonZRGBController/PoseidonZRGBController.cpp \
Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp \
Controllers/PoseidonZRGBController/RGBController_PoseidonZRGB.cpp \
Controllers/QMKRGBMatrixController/QMKRGBMatrixController.cpp \
Controllers/QMKRGBMatrixController/QMKRGBMatrixControllerDetect.cpp \
Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.cpp \
Controllers/RedragonController/RedragonK556Controller.cpp \
Controllers/RedragonController/RedragonM711Controller.cpp \
Controllers/RedragonController/RedragonControllerDetect.cpp \