Initial support for addressable headers on Asus Aura motherboards.

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "dependencies/libe131"]
 	path = dependencies/libe131
 	url = https://github.com/CalcProgrammer1/libe131
+[submodule "razer-drivers-win32"]
+	path = razer-drivers-win32
+	url = https://github.com/rsandoz/razer-drivers-win32

Controllers/AuraAddressableController/AuraAddressableController.cpp

@@ -0,0 +1,202 @@
+/*-----------------------------------------*\
+|  AuraAddressableController.cpp            |
+|                                           |
+|  Driver for ASUS Aura RGB Addressable     |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
+\*-----------------------------------------*/
+
+#include "AuraAddressableController.h"
+#include <cstring>
+
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
+AuraAddressableController::AuraAddressableController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+
+    channel_leds[0] = 40;
+}
+
+AuraAddressableController::~AuraAddressableController()
+{
+
+}
+
+void AuraAddressableController::SetLEDsDirect(std::vector<RGBColor> colors)
+{
+    unsigned char   led_data[60];
+    unsigned int    leds_sent = 0;
+
+    SendDirectBegin();
+
+    while(leds_sent < colors.size())
+    {
+        unsigned int leds_to_send = 20;
+
+        if((colors.size() - leds_sent) < leds_to_send)
+        {
+            leds_to_send = colors.size() - leds_sent;
+        }
+
+        for(int led_idx = 0; leds_to_send < 20; led_idx++)
+        {
+            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx]);
+            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx]);
+            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx]);
+        }
+
+        SendDirect
+        (
+            0,
+            leds_sent,
+            leds_to_send,
+            led_data
+        );
+    }
+
+    SendDirectApply();
+}
+
+void AuraAddressableController::SetMode
+    (
+    unsigned char mode,
+    unsigned char red,
+    unsigned char grn,
+    unsigned char blu
+    )
+{
+    SendEffect
+    (
+        mode,
+        red,
+        grn,
+        blu
+    );
+}
+
+void AuraAddressableController::SendEffect
+    (
+    unsigned char   mode,
+    unsigned char   red,
+    unsigned char   grn,
+    unsigned char   blu
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_CONTROL_MODE_EFFECT;
+    usb_buf[0x02]   = 0x00;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = mode;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x05]   = red;
+    usb_buf[0x06]   = grn;
+    usb_buf[0x07]   = blu;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, usb_buf, 64);
+}
+
+void AuraAddressableController::SendDirect
+    (
+    unsigned char   device,
+    unsigned char   start_led,
+    unsigned char   led_count,
+    unsigned char*  led_data
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
+    usb_buf[0x02]   = device;
+    usb_buf[0x03]   = start_led;
+    usb_buf[0x04]   = led_count;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x05], led_data, led_count * 3);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, usb_buf, 64);
+}
+
+void AuraAddressableController::SendDirectBegin()
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_CONTROL_MODE_EFFECT;
+    usb_buf[0x04]   = 0xFF;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, usb_buf, 64);
+}
+
+void AuraAddressableController::SendDirectApply()
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
+    usb_buf[0x02]   = 0x80;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, usb_buf, 64);
+}

Controllers/AuraAddressableController/AuraAddressableController.h

@@ -0,0 +1,84 @@
+/*-----------------------------------------*\
+|  AuraAddressableController.h              |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  Addressable RGB lighting controller      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    AURA_MODE_OFF                       = 0,        /* OFF mode                             */
+    AURA_MODE_STATIC                    = 1,        /* Static color mode                    */
+    AURA_MODE_BREATHING                 = 2,        /* Breathing effect mode                */
+    AURA_MODE_FLASHING                  = 3,        /* Flashing effect mode                 */
+    AURA_MODE_SPECTRUM_CYCLE            = 4,        /* Spectrum Cycle mode                  */
+    AURA_MODE_RAINBOW                   = 5,        /* Rainbow effect mode                  */
+    AURA_MODE_SPECTRUM_CYCLE_BREATHING  = 6,        /* Rainbow Breathing effect mode        */
+    AURA_MODE_CHASE_FADE                = 7,        /* Chase with Fade effect mode          */
+    AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE = 8,        /* Chase with Fade, Rainbow effect mode */
+    AURA_MODE_CHASE                     = 9,        /* Chase effect mode                    */
+    AURA_MODE_SPECTRUM_CYCLE_CHASE      = 10,       /* Chase with Rainbow effect mode       */
+    AURA_MODE_SPECTRUM_CYCLE_WAVE       = 11,       /* Wave effect mode                     */
+    AURA_MODE_CHASE_RAINBOW_PULSE       = 12,       /* Chase with  Rainbow Pulse effect mode*/
+    AURA_MODE_RANDOM_FLICKER            = 13,       /* Random flicker effect mode           */
+    AURA_MODE_MUSIC                     = 14,       /* Music effect mode                    */
+};
+
+enum
+{
+    AURA_CONTROL_MODE_EFFECT            = 0x3B,     /* Effect control mode                  */
+    AURA_CONTROL_MODE_DIRECT            = 0x40,     /* Direct control mode                  */
+};
+
+class AuraAddressableController
+{
+public:
+    AuraAddressableController(hid_device* dev_handle);
+    ~AuraAddressableController();
+
+    void SetLEDsDirect(std::vector<RGBColor> colors);
+
+    void SetMode
+        (
+        unsigned char mode,
+        unsigned char red,
+        unsigned char grn,
+        unsigned char blu
+        );
+    
+    unsigned int    channel_leds[1];
+
+private:
+    char                    device_name[32];
+    hid_device*             dev;
+    unsigned int            led_count;
+    
+    void SendEffect
+        (
+        unsigned char   mode,
+        unsigned char   red,
+        unsigned char   grn,
+        unsigned char   blu
+        );
+
+    void SendDirect
+        (
+        unsigned char   device,
+        unsigned char   start_led,
+        unsigned char   led_count,
+        unsigned char*  led_data
+        );
+    
+    void    SendDirectBegin();
+
+    void    SendDirectApply();
+};

Controllers/AuraAddressableController/AuraAddressableControllerDetect.cpp

@@ -0,0 +1,36 @@
+#include "AuraAddressableController.h"
+#include "RGBController.h"
+#include "RGBController_AuraAddressable.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#define AURA_ADDRESSABLE_VID 0x0B05
+#define AURA_ADDRESSABLE_PID 0x1872
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAuraAddressableControllers                                                       *
+*                                                                                          *
+*       Tests the USB address to see if an Asus Aura addressable RGB header controller     *
+*       exists there.                                                                      *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAuraAddressableControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device* dev;
+
+    //Look for Asus Aura addressable RGB header controller
+    hid_init();
+
+    dev = hid_open(AURA_ADDRESSABLE_VID, AURA_ADDRESSABLE_PID, 0);
+
+    if( dev )
+    {
+        AuraAddressableController* controller = new AuraAddressableController(dev);
+
+        RGBController_AuraAddressable* rgb_controller = new RGBController_AuraAddressable(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+}

Controllers/CorsairCmdrProController/CorsairCmdrProController.cpp

@@ -89,7 +89,10 @@ void CorsairCmdrProController::SetChannelEffect(unsigned char channel,
                                                 unsigned char blu1,
                                                 unsigned char red2,
                                                 unsigned char grn2,
-                                                unsigned char blu2
+                                                unsigned char blu2,
+                                                unsigned char red3,
+                                                unsigned char grn3,
+                                                unsigned char blu3
                                                )
 {
     /*-----------------------------------------------------*\
@@ -125,9 +128,9 @@ void CorsairCmdrProController::SetChannelEffect(unsigned char channel,
         red2,
         grn2,
         blu2,
-        0,
-        0,
-        0,
+        red3,
+        grn3,
+        blu3,
         0,
         0,
         0

Controllers/CorsairCmdrProController/CorsairCmdrProController.h

@@ -92,7 +92,10 @@ public:
                                      unsigned char blu1,
                                      unsigned char red2,
                                      unsigned char grn2,
-                                     unsigned char blu2
+                                     unsigned char blu2,
+                                     unsigned char red3,
+                                     unsigned char grn3,
+                                     unsigned char blu3
                                     );
 
     void            SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors);

Controllers/CorsairNodeProController/CorsairNodeProController.cpp

@@ -89,7 +89,10 @@ void CorsairNodeProController::SetChannelEffect(unsigned char channel,
                                                 unsigned char blu1,
                                                 unsigned char red2,
                                                 unsigned char grn2,
-                                                unsigned char blu2
+                                                unsigned char blu2,
+                                                unsigned char red3,
+                                                unsigned char grn3,
+                                                unsigned char blu3
                                                )
 {
     /*-----------------------------------------------------*\
@@ -125,9 +128,9 @@ void CorsairNodeProController::SetChannelEffect(unsigned char channel,
         red2,
         grn2,
         blu2,
-        0,
-        0,
-        0,
+        red3,
+        grn3,
+        blu3,
         0,
         0,
         0

Controllers/CorsairNodeProController/CorsairNodeProController.h

@@ -99,7 +99,10 @@ public:
                                      unsigned char blu1,
                                      unsigned char red2,
                                      unsigned char grn2,
-                                     unsigned char blu2
+                                     unsigned char blu2,
+                                     unsigned char red3,
+                                     unsigned char grn3,
+                                     unsigned char blu3
                                     );
 
     void            SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors);

Controllers/HuePlusController/HuePlusController.cpp

@@ -9,7 +9,7 @@
 #include <fstream>
 #include <iostream>
 #include <string>
-
+#include <cstring>
 
 #ifdef WIN32
 #include <Windows.h>
@@ -92,43 +92,75 @@ void HuePlusController::SetMode(unsigned char mode, unsigned char speed, bool di
     current_direction   = direction;
 }
 
+void HuePlusController::SetModeColors(unsigned char channel, std::vector<RGBColor> colors)
+{
+    unsigned char serial_buf[125];
+
+    for(int color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(serial_buf, 0x00, sizeof(serial_buf));
+
+        /*-----------------------------------------------------*\
+        | Set up main packet                                    |
+        \*-----------------------------------------------------*/
+        serial_buf[0x00]    = 0x4B;
+
+        /*-----------------------------------------------------*\
+        | Set channel in serial packet                          |
+        \*-----------------------------------------------------*/
+        serial_buf[0x01]   = channel;
+
+        /*-----------------------------------------------------*\
+        | Set mode in serial packet                             |
+        \*-----------------------------------------------------*/
+        serial_buf[0x02]   = current_mode;
+
+        /*-----------------------------------------------------*\
+        | Set options bitfield in serial packet                 |
+        \*-----------------------------------------------------*/
+        serial_buf[0x03]   = 0;
+        serial_buf[0x03]   |= current_direction ? ( 1 << 4 ) : 0;
+
+        /*-----------------------------------------------------*\
+        | Set color index and speed in serial packet            |
+        \*-----------------------------------------------------*/
+        serial_buf[0x04]   = ( color_idx << 5 ) | current_speed;
+
+        /*-----------------------------------------------------*\
+        | Fill in color data                                    |
+        \*-----------------------------------------------------*/
+        for (std::size_t idx = 0; idx < 40; idx++)
+        {
+            int pixel_idx = idx * 3;
+            RGBColor color = colors[color_idx];
+            serial_buf[pixel_idx + 0x05] = RGBGetGValue(color);
+            serial_buf[pixel_idx + 0x06] = RGBGetRValue(color);
+            serial_buf[pixel_idx + 0x07] = RGBGetBValue(color);
+        }
+
+        serialport->serial_write((char *)serial_buf, HUE_PLUS_PACKET_SIZE);
+        serialport->serial_flush_tx();
+
+        Sleep(10);
+    }
+}
+
 void HuePlusController::SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors)
 {
-    unsigned char serial_buf[] =
-    {
-        0x4B, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00
-    };
+    unsigned char serial_buf[125];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(serial_buf, 0x00, sizeof(serial_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up main packet                                    |
+    \*-----------------------------------------------------*/
+    serial_buf[0x00]    = 0x4B;
 
     /*-----------------------------------------------------*\
     | Set channel in serial packet                          |
@@ -167,4 +199,4 @@ void HuePlusController::SetChannelLEDs(unsigned char channel, std::vector<RGBCol
     serialport->serial_flush_tx();
 
     Sleep(10);
-}
+}

Controllers/HuePlusController/HuePlusController.h

@@ -75,6 +75,7 @@ public:
     unsigned int    GetLEDsOnChannel(unsigned int channel);
     void            SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors);
     void            SetMode(unsigned char mode, unsigned char speed, bool direction);
+    void            SetModeColors(unsigned char channel, std::vector<RGBColor> colors);
 
     unsigned int    channel_leds[HUE_PLUS_NUM_CHANNELS];
 

Controllers/HyperXKeyboardController/HyperXKeyboardController.cpp

@@ -46,12 +46,48 @@ HyperXKeyboardController::~HyperXKeyboardController()
 
 }
 
-void HyperXKeyboardController::SetMode(unsigned char mode, unsigned char direction, unsigned char speed)
+void HyperXKeyboardController::SetMode
+    (
+    unsigned char mode,
+    unsigned char direction,
+    unsigned char speed,
+    std::vector<RGBColor> colors
+    )
 {
+    unsigned char color_mode;
+    unsigned char mode_colors[9];
+
     active_mode = mode;
     active_direction = direction;
     active_speed = speed;
 
+    memset(mode_colors, 0x00, sizeof(mode_colors));
+
+    switch(colors.size())
+    {
+        default:
+        case 0:
+            color_mode = HYPERX_COLOR_MODE_SPECTRUM;
+            break;
+
+        case 1:
+            color_mode = HYPERX_COLOR_MODE_SINGLE;
+            mode_colors[0] = RGBGetRValue(colors[0]);
+            mode_colors[1] = RGBGetGValue(colors[0]);
+            mode_colors[2] = RGBGetBValue(colors[0]);
+            break;
+
+        case 2:
+            color_mode = HYPERX_COLOR_MODE_DUAL;
+            mode_colors[3] = RGBGetRValue(colors[0]);
+            mode_colors[4] = RGBGetGValue(colors[0]);
+            mode_colors[5] = RGBGetBValue(colors[0]);
+            mode_colors[6] = RGBGetRValue(colors[1]);
+            mode_colors[7] = RGBGetGValue(colors[1]);
+            mode_colors[8] = RGBGetBValue(colors[1]);
+            break;
+    }
+
     SendEffect
         (
         0x01,
@@ -59,8 +95,19 @@ void HyperXKeyboardController::SetMode(unsigned char mode, unsigned char directi
         active_direction,
         HYPERX_REACTIVE_MODE_NONE,
         active_speed,
-        HYPERX_COLOR_MODE_SPECTRUM
+        color_mode,
+        mode_colors[0],
+        mode_colors[1],
+        mode_colors[2],
+        mode_colors[3],
+        mode_colors[4],
+        mode_colors[5],
+        mode_colors[6],
+        mode_colors[7],
+        mode_colors[8]
         );
+
+    Sleep(100);
 }
 
 void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
@@ -202,7 +249,16 @@ void HyperXKeyboardController::SendEffect
     unsigned char   direction,
     unsigned char   reactive_mode,
     unsigned char   speed,
-    unsigned char   color_mode
+    unsigned char   color_mode,
+    unsigned char   red_single,
+    unsigned char   grn_single,
+    unsigned char   blu_single,
+    unsigned char   red_dual_1,
+    unsigned char   grn_dual_1,
+    unsigned char   blu_dual_1,
+    unsigned char   red_dual_2,
+    unsigned char   grn_dual_2,
+    unsigned char   blu_dual_2
     )
 {
     unsigned char buf[264];
@@ -243,6 +299,19 @@ void HyperXKeyboardController::SendEffect
     buf[0x21]   = reactive_mode;
     buf[0x22]   = reactive_mode;
 
+    /*-----------------------------------------------------*\
+    | Set mode-specific colors                              |
+    \*-----------------------------------------------------*/
+    buf[0x29]   = red_single;
+    buf[0x41]   = grn_single;
+    buf[0x59]   = blu_single;
+    buf[0x2A]   = red_dual_1;
+    buf[0x42]   = grn_dual_1;
+    buf[0x5A]   = blu_dual_1;
+    buf[0x2B]   = red_dual_2;
+    buf[0x43]   = grn_dual_2;
+    buf[0x5B]   = blu_dual_2;
+
     buf[0x6B]   = 0x09;
     buf[0x6C]   = 0x09;
     buf[0x6D]   = 0x05;

Controllers/HyperXKeyboardController/HyperXKeyboardController.h

@@ -68,7 +68,14 @@ public:
     HyperXKeyboardController(hid_device* dev_handle);
     ~HyperXKeyboardController();
 
-    void SetMode(unsigned char mode, unsigned char direction, unsigned char speed);
+    void SetMode
+        (
+        unsigned char mode,
+        unsigned char direction,
+        unsigned char speed,
+        std::vector<RGBColor> colors
+        );
+
     void SetLEDsDirect(std::vector<RGBColor> colors);
     void SetLEDs(std::vector<RGBColor> colors);
 
@@ -90,7 +97,16 @@ private:
                 unsigned char   direction,
                 unsigned char   reactive_mode,
                 unsigned char   speed,
-                unsigned char   color_mode
+                unsigned char   color_mode,
+                unsigned char   red_single,
+                unsigned char   grn_single,
+                unsigned char   blu_single,
+                unsigned char   red_dual_1,
+                unsigned char   grn_dual_1,
+                unsigned char   blu_dual_1,
+                unsigned char   red_dual_2,
+                unsigned char   grn_dual_2,
+                unsigned char   blu_dual_2
                 );
 
     void    SendColor

Controllers/PolychromeController/PolychromeController.cpp

@@ -25,20 +25,20 @@ PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_
 
     case FIRMWARE_VER_2_PT_00:
         led_count = 1;
-        asr_led = false;
-        strcpy(device_name, "ASRock Polychrome FW 2.00");
+        asr_led = true;
+        strcpy(device_name, "ASRock ASR LED FW 2.00");
         break;
 
     case FIRMWARE_VER_2_PT_08:
         led_count = 1;
-        asr_led = false;
-        strcpy(device_name, "ASRock Polychrome FW 2.08");
+        asr_led = true;
+        strcpy(device_name, "ASRock ASR LED FW 2.08");
         break;
 
     case FIRMWARE_VER_2_PT_10:
         led_count = 1;
         asr_led = true;
-        strcpy(device_name, "ASRock Polychrome FW 2.10");
+        strcpy(device_name, "ASRock ASR LED FW 2.10");
         break;
 
     case FIRMWARE_VER_3_PT_00:

OpenRGB.cpp

@@ -260,11 +260,11 @@ void DetectHyperXControllers(std::vector<i2c_smbus_interface*> &busses, std::vec
 void DetectPatriotViperControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
 void DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
 void DetectRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
+void DetectAuraAddressableControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectLEDStripControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectHue2Controllers(std::vector<RGBController*> &rgb_controllers);
 void DetectHuePlusControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectOpenRazerControllers(std::vector<RGBController*> &rgb_controllers);
-void DetectRazerChromaSDKControllers(std::vector<RGBController*>& rgb_controllers);
 void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers);
 void DetectAMDWraithPrismControllers(std::vector<RGBController*>& rgb_controllers);
 void DetectAorusGPUControllers(std::vector<RGBController*> &rgb_controllers);
@@ -298,6 +298,7 @@ void DetectRGBControllers(void)
     DetectPolychromeControllers(busses, rgb_controllers);
     DetectRGBFusionControllers(busses, rgb_controllers);
 
+    DetectAuraAddressableControllers(rgb_controllers);
     DetectLEDStripControllers(rgb_controllers);
     DetectHue2Controllers(rgb_controllers);
     DetectHuePlusControllers(rgb_controllers);
@@ -317,9 +318,8 @@ void DetectRGBControllers(void)
     | Windows-only devices                  |
     \*-------------------------------------*/
 #ifdef WIN32
-    DetectRazerChromaSDKControllers(rgb_controllers);
     //DetectAorusGPUControllers(rgb_controllers);
-
+    DetectOpenRazerControllers(rgb_controllers);
     /*-------------------------------------*\
     | Linux-only devices                    |
     \*-------------------------------------*/

OpenRGB.pro

@@ -13,6 +13,7 @@ INCLUDEPATH +=                                                          \
     serial_port/                                                        \
     super_io/                                                           \
     Controllers/AMDWraithPrismController/                               \
+    Controllers/AuraAddressableController/                              \
     Controllers/AuraController/                                         \
     Controllers/CorsairController/                                      \
     Controllers/CorsairCmdrProController/                               \
@@ -52,6 +53,8 @@ SOURCES +=                                                              \
     super_io/super_io.cpp                                               \
     Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp   \
     Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp \
+    Controllers/AuraAddressableController/AuraAddressableController.cpp \
+    Controllers/AuraAddressableController/AuraAddressableControllerDetect.cpp \
     Controllers/AuraController/AuraController.cpp                       \
     Controllers/AuraController/AuraControllerDetect.cpp                 \
     Controllers/CorsairController/CorsairController.cpp                 \
@@ -94,6 +97,7 @@ SOURCES +=                                                              \
     RGBController/E131ControllerDetect.cpp                              \
     RGBController/RGBController_AMDWraithPrism.cpp                      \
     RGBController/RGBController_Aura.cpp                                \
+    RGBController/RGBController_AuraAddressable.cpp                     \
     RGBController/RGBController_Corsair.cpp                             \
     RGBController/RGBController_CorsairCmdrPro.cpp                      \
     RGBController/RGBController_CorsairKeyboard.cpp                     \
@@ -128,6 +132,7 @@ HEADERS +=                                                              \
     super_io/super_io.h                                                 \
     Controllers/AMDWraithPrismController/AMDWraithPrismController.h     \
     Controllers/AuraController/AuraController.h                         \
+    Controllers/AuraAddressableController/AuraAddressableController.h   \
     Controllers/CorsairController/CorsairController.h                   \
     Controllers/CorsairCmdrProController/CorsairCmdrProController.h     \
     Controllers/CorsairKeyboardController/CorsairKeyboardController.h   \
@@ -149,6 +154,7 @@ HEADERS +=                                                              \
     RGBController/RGBController.h                                       \
     RGBController/RGBController_AMDWraithPrism.h                        \
     RGBController/RGBController_Aura.h                                  \
+    RGBController/RGBController_AuraAddressable.h                       \
     RGBController/RGBController_Corsair.h                               \
     RGBController/RGBController_CorsairCmdrPro.h                        \
     RGBController/RGBController_CorsairNodePro.h                        \
@@ -183,9 +189,9 @@ FORMS += \
 #-----------------------------------------------
 win32:INCLUDEPATH +=                                                    \
     dependencies/inpout32_1501/Win32/                                   \
-    dependencies/razer-chroma-2.9.0/inc                                 \
     dependencies/libusb-1.0.22/include                                  \
     dependencies/hidapi                                                 \
+    dependencies/openrazer-win32                                        \
     wmi/                                                                \
 
 win32:SOURCES +=                                                        \
@@ -195,9 +201,9 @@ win32:SOURCES +=                                                        \
     serial_port/find_usb_serial_port_win.cpp                            \
     wmi/wmi.cpp                                                         \
     RGBController/AorusGPUDetect.cpp                                    \
+    RGBController/OpenRazerWindowsDetect.cpp                            \
     RGBController/RGBController_AorusGPU.cpp                            \
-    RGBController/RazerChromaSDKDetect.cpp                              \
-    RGBController/RGBController_RazerChromaSDK.cpp                      \
+    RGBController/RGBController_OpenRazerWindows.cpp                    \
 
 win32:HEADERS +=                                                        \
     dependencies/inpout32_1501/Win32/inpout32.h                         \
@@ -206,7 +212,7 @@ win32:HEADERS +=                                                        \
     i2c_smbus/i2c_smbus_piix4.h                                         \
     wmi/wmi.h                                                           \
     RGBController/RGBController_AorusGPU.h                              \
-    RGBController/RGBController_RazerChromaSDK.h                        \
+    RGBController/RGBController_OpenRazerWindows.h                      \
 
 win32:LIBS +=                                                           \
     -lws2_32                                                            \
@@ -224,6 +230,16 @@ win32:DEFINES +=                                                        \
     _WINSOCK_DEPRECATED_NO_WARNINGS                                     \
     WIN32_LEAN_AND_MEAN
 
+# Copy OpenRazer.dll to output directory
+win32
+{
+    copydata.commands = $(COPY_FILE) \"$$shell_path($$PWD\\dependencies\\openrazer-win32\\OpenRazer.dll)\" \"$$shell_path($$OUT_PWD)\"
+    first.depends = $(first) copydata
+    export(first.depends)
+    export(copydata.commands)
+    QMAKE_EXTRA_TARGETS += first copydata
+}
+
 #-----------------------------------------------
 # Linux specific project configuration
 #-----------------------------------------------

RGBController/OpenRazerDetect.cpp

@@ -58,7 +58,7 @@ void DetectOpenRazerControllers(std::vector<RGBController*> &rgb_controllers)
             break;
         
         case 7:
-            strcpy(driver_path, "/sys/bus/hid/drivers/razerchromahdk/");
+            strcpy(driver_path, "/sys/bus/hid/drivers/razeraccessory/");
             break;
         }
 
@@ -102,7 +102,7 @@ void DetectOpenRazerControllers(std::vector<RGBController*> &rgb_controllers)
 
                     RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(device_string);
 
-                    if(razer_rgb->device != -1)
+                    if(razer_rgb->device_index != -1)
                     {
                         rgb_controllers.push_back(razer_rgb);
                     }

RGBController/OpenRazerWindowsDetect.cpp

@@ -0,0 +1,387 @@
+#include "RGBController.h"
+#include "RGBController_OpenRazerWindows.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+#include <Windows.h>
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/hid.h>
+
+#ifdef _WIN64
+#define OPENRAZERDLL            "OpenRazer64.dll"
+#elif WIN32
+#define OPENRAZERDLL            "OpenRazer.dll"
+#endif
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectOpenRazerControllers                                                             *
+*                                                                                          *
+*       Detect devices supported by the OpenRazer kernel drivers                           *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectOpenRazerControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    static HMODULE module = LoadLibrary(OPENRAZERDLL);
+
+	if(module == nullptr)
+    {
+        return;
+    }
+
+    // map DLL calls
+	typedef unsigned int(*INITRAZERDRIVER)(struct hid_device** hdev);
+	
+	INITRAZERDRIVER init_razer_kbd_driver = reinterpret_cast<INITRAZERDRIVER>(GetProcAddress(module, "init_razer_kbd_driver"));
+    static struct device_attribute devkbd_attr_device_type         				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_device_type"));
+    static struct device_attribute devkbd_attr_device_serial       				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_device_serial"));
+    static struct device_attribute devkbd_attr_firmware_version    				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_firmware_version"));
+	static struct device_attribute devkbd_attr_matrix_effect_custom				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_custom"));
+	static struct device_attribute devkbd_attr_matrix_custom_frame 				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_custom_frame"));
+	static struct device_attribute devkbd_attr_matrix_brightness   				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_brightness"));
+	static struct device_attribute devkbd_attr_matrix_effect_none  				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_none"));
+	static struct device_attribute devkbd_attr_matrix_effect_static				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_static"));
+	static struct device_attribute devkbd_attr_matrix_effect_breath			    = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_breath"));
+	static struct device_attribute devkbd_attr_matrix_effect_spectrum			= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_spectrum"));
+	static struct device_attribute devkbd_attr_matrix_effect_reactive			= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_reactive"));
+	static struct device_attribute devkbd_attr_matrix_effect_wave				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_wave"));
+
+	INITRAZERDRIVER init_razer_mousemat_driver = reinterpret_cast<INITRAZERDRIVER>(GetProcAddress(module, "init_razer_mousemat_driver"));
+    static struct device_attribute devmousemat_attr_device_type                  = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_device_type"));
+    static struct device_attribute devmousemat_attr_device_serial                = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_device_serial"));
+    static struct device_attribute devmousemat_attr_firmware_version             = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_firmware_version"));
+	static struct device_attribute devmousemat_attr_matrix_effect_custom         = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_custom"));
+	static struct device_attribute devmousemat_attr_matrix_custom_frame          = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_custom_frame"));
+	static struct device_attribute devmousemat_attr_matrix_brightness            = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_brightness"));
+	static struct device_attribute devmousemat_attr_matrix_effect_none           = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_none"));
+	static struct device_attribute devmousemat_attr_matrix_effect_static         = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_static"));
+	static struct device_attribute devmousemat_attr_matrix_effect_breath	        = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_breath"));
+	static struct device_attribute devmousemat_attr_matrix_effect_spectrum       = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_spectrum"));
+	static struct device_attribute devmousemat_attr_matrix_effect_reactive       = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_reactive"));
+	static struct device_attribute devmousemat_attr_matrix_effect_wave           = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_wave"));
+	
+	INITRAZERDRIVER init_razer_mouse_driver = reinterpret_cast<INITRAZERDRIVER>(GetProcAddress(module, "init_razer_mouse_driver"));
+    static struct device_attribute devmouse_attr_device_type                   	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_device_type"));
+    static struct device_attribute devmouse_attr_device_serial                 	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_device_serial"));
+    static struct device_attribute devmouse_attr_firmware_version              	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_firmware_version"));
+	static struct device_attribute devmouse_attr_matrix_effect_custom          	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_custom"));
+	static struct device_attribute devmouse_attr_matrix_custom_frame           	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_custom_frame"));
+	static struct device_attribute devmouse_attr_matrix_brightness             	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_brightness"));
+	static struct device_attribute devmouse_attr_logo_led_brightness           	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_logo_led_brightness"));
+	static struct device_attribute devmouse_attr_scroll_led_brightness         	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_led_brightness"));
+	static struct device_attribute devmouse_attr_matrix_effect_none            	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_none"));
+	static struct device_attribute devmouse_attr_logo_matrix_effect_none       	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_logo_matrix_effect_none"));
+	static struct device_attribute devmouse_attr_scroll_matrix_effect_none     	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_matrix_effect_none"));
+	static struct device_attribute devmouse_attr_matrix_effect_static          	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_static"));
+	static struct device_attribute devmouse_attr_logo_matrix_effect_static     	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_logo_matrix_effect_static"));
+	static struct device_attribute devmouse_attr_scroll_matrix_effect_static   	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_matrix_effect_static"));
+	static struct device_attribute devmouse_attr_matrix_effect_breath 	        = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_breath"));
+	static struct device_attribute devmouse_attr_matrix_effect_spectrum        	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_spectrum"));
+	static struct device_attribute devmouse_attr_logo_matrix_effect_spectrum   	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_logo_matrix_effect_spectrum"));
+	static struct device_attribute devmouse_attr_scroll_matrix_effect_spectrum 	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_matrix_effect_spectrum"));
+	static struct device_attribute devmouse_attr_matrix_effect_reactive        	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_reactive"));
+	static struct device_attribute devmouse_attr_logo_matrix_effect_reactive   	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_logo_matrix_effect_reactive"));
+	static struct device_attribute devmouse_attr_scroll_matrix_effect_reactive 	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_matrix_effect_reactive"));
+	static struct device_attribute devmouse_attr_scroll_led_effect             	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_led_effect"));
+	static struct device_attribute devmouse_attr_scroll_led_rgb                	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_led_rgb"));
+	static struct device_attribute devmouse_attr_scroll_led_state              	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_led_state"));
+	static struct device_attribute devmouse_attr_matrix_effect_wave            	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_wave"));
+
+	INITRAZERDRIVER init_razer_accessory_driver = reinterpret_cast<INITRAZERDRIVER>(GetProcAddress(module, "init_razer_accessory_driver"));
+    static struct device_attribute devaccessory_attr_device_type                      = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_device_type"));
+    static struct device_attribute devaccessory_attr_device_serial                    = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_device_serial"));
+    static struct device_attribute devaccessory_attr_firmware_version                 = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_firmware_version"));
+	static struct device_attribute devaccessory_attr_matrix_effect_custom             = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_custom"));
+	static struct device_attribute devaccessory_attr_matrix_custom_frame              = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_custom_frame"));
+	static struct device_attribute devaccessory_attr_matrix_brightness                = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_brightness"));
+	static struct device_attribute devaccessory_attr_matrix_effect_none               = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_none"));
+	static struct device_attribute devaccessory_attr_matrix_effect_static             = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_static"));
+	static struct device_attribute devaccessory_attr_matrix_effect_breath	    	    = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_breath"));
+	static struct device_attribute devaccessory_attr_matrix_effect_spectrum           = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_spectrum"));
+	//static struct device_attribute devaccessory_attr_matrix_effect_reactive         = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_reactive"));
+	static struct device_attribute devaccessory_attr_matrix_effect_wave               = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_wave"));
+
+	INITRAZERDRIVER init_razer_kraken_driver = reinterpret_cast<INITRAZERDRIVER>(GetProcAddress(module, "init_razer_kraken_driver"));
+    static struct device_attribute devkraken_attr_device_type                   = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_device_type"));
+    static struct device_attribute devkraken_attr_device_serial                 = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_device_serial"));
+    static struct device_attribute devkraken_attr_firmware_version              = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_firmware_version"));
+	static struct device_attribute devkraken_attr_matrix_effect_custom          = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_effect_custom"));
+    //static struct device_attribute devkraken_attr_matrix_custom_frame           = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_custom_frame"));
+	//static struct device_attribute devkraken_attr_matrix_brightness           = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_brightness"));
+	static struct device_attribute devkraken_attr_matrix_effect_none            = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_effect_none"));
+	static struct device_attribute devkraken_attr_matrix_effect_static          = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_effect_static"));
+	static struct device_attribute devkraken_attr_matrix_effect_breath	        = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_effect_breath"));
+	static struct device_attribute devkraken_attr_matrix_effect_spectrum        = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_effect_spectrum"));
+
+	INITRAZERDRIVER init_razer_core_driver = reinterpret_cast<INITRAZERDRIVER>(GetProcAddress(module, "init_razer_core_driver"));
+    static struct device_attribute devcore_attr_device_type                     = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_device_type"));
+    static struct device_attribute devcore_attr_device_serial                   = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_device_serial"));
+    static struct device_attribute devcore_attr_firmware_version                = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_firmware_version"));
+	static struct device_attribute devcore_attr_matrix_effect_custom            = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_custom"));
+	static struct device_attribute devcore_attr_matrix_custom_frame             = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_custom_frame"));
+	static struct device_attribute devcore_attr_matrix_brightness               = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_brightness"));
+	static struct device_attribute devcore_attr_matrix_effect_none              = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_none"));
+	static struct device_attribute devcore_attr_matrix_effect_static            = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_static"));
+	static struct device_attribute devcore_attr_matrix_effect_breath	        = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_breath"));
+	static struct device_attribute devcore_attr_matrix_effect_spectrum          = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_spectrum"));
+	static struct device_attribute devcore_attr_matrix_effect_reactive          = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_reactive"));
+	static struct device_attribute devcore_attr_matrix_effect_wave              = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_wave"));
+
+	struct hid_device* hdev;
+	unsigned int num;
+
+    hdev = NULL;
+	num = init_razer_kbd_driver(&hdev);
+	for (unsigned int i = 0; i < num; i++)
+    {
+        device_fn_type* device_fn = new device_fn_type;
+        device_fn->device_type             	     = &devkbd_attr_device_type;
+        device_fn->device_serial           	     = &devkbd_attr_device_serial;
+		device_fn->firmware_version			     = &devkbd_attr_firmware_version;
+        device_fn->matrix_effect_custom    	     = &devkbd_attr_matrix_effect_custom;
+        device_fn->matrix_custom_frame     	     = &devkbd_attr_matrix_custom_frame;
+        device_fn->matrix_brightness       	     = &devkbd_attr_matrix_brightness;
+        device_fn->matrix_effect_none      	     = &devkbd_attr_matrix_effect_none;
+        device_fn->matrix_effect_static    	     = &devkbd_attr_matrix_effect_static;
+		device_fn->matrix_effect_breath	         = &devkbd_attr_matrix_effect_breath;
+        device_fn->matrix_effect_spectrum  	     = &devkbd_attr_matrix_effect_spectrum;
+        device_fn->matrix_effect_reactive  	     = &devkbd_attr_matrix_effect_reactive;
+		device_fn->matrix_effect_wave		     = &devkbd_attr_matrix_effect_wave;
+        device_fn->logo_led_brightness           = NULL;
+        device_fn->logo_matrix_effect_none       = NULL;
+        device_fn->logo_matrix_effect_static     = NULL;
+        device_fn->logo_matrix_effect_spectrum   = NULL;
+        device_fn->logo_matrix_effect_reactive   = NULL;
+        device_fn->scroll_led_brightness         = NULL;
+        device_fn->scroll_matrix_effect_none     = NULL;
+        device_fn->scroll_matrix_effect_static   = NULL;
+        device_fn->scroll_matrix_effect_spectrum = NULL;
+        device_fn->scroll_matrix_effect_reactive = NULL;
+        device_fn->scroll_led_effect             = NULL;
+        device_fn->scroll_led_rgb                = NULL;
+        RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(&hdev[i].dev, device_fn);
+
+        if(razer_rgb->device_index != -1)
+        {
+            rgb_controllers.push_back(razer_rgb);
+        }
+        else
+        {
+            delete razer_rgb;
+        }
+    }
+
+    hdev = NULL;
+	num = init_razer_mouse_driver(&hdev);
+	for (unsigned int i = 0; i < num; i++)
+    {
+        device_fn_type* device_fn = new device_fn_type;
+        device_fn->device_type             	     = &devmouse_attr_device_type;
+        device_fn->device_serial           	     = &devmouse_attr_device_serial;
+		device_fn->firmware_version			     = &devmouse_attr_firmware_version;
+        device_fn->matrix_effect_custom    	     = &devmouse_attr_matrix_effect_custom;
+        device_fn->matrix_custom_frame     	     = &devmouse_attr_matrix_custom_frame;
+        device_fn->matrix_brightness       	     = &devmouse_attr_matrix_brightness;
+        device_fn->matrix_effect_none      	     = &devmouse_attr_matrix_effect_none;
+        device_fn->matrix_effect_static    	     = &devmouse_attr_matrix_effect_static;
+		device_fn->matrix_effect_breath	         = &devmouse_attr_matrix_effect_breath;
+        device_fn->matrix_effect_spectrum  	     = &devmouse_attr_matrix_effect_spectrum;
+        device_fn->matrix_effect_reactive  	     = &devmouse_attr_matrix_effect_reactive;
+		device_fn->matrix_effect_wave		     = &devmouse_attr_matrix_effect_wave;
+        device_fn->logo_led_brightness           = NULL;
+        device_fn->logo_matrix_effect_none       = NULL;
+        device_fn->logo_matrix_effect_static     = NULL;
+        device_fn->logo_matrix_effect_spectrum   = NULL;
+        device_fn->logo_matrix_effect_reactive   = NULL;
+        device_fn->scroll_led_brightness         = NULL;
+        device_fn->scroll_matrix_effect_none     = NULL;
+        device_fn->scroll_matrix_effect_static   = NULL;
+        device_fn->scroll_matrix_effect_spectrum = NULL;
+        device_fn->scroll_matrix_effect_reactive = NULL;
+        device_fn->scroll_led_effect             = NULL;
+        device_fn->scroll_led_rgb                = NULL;
+
+        RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(&hdev[i].dev, device_fn);
+
+        if(razer_rgb->device_index != -1)
+        {
+            rgb_controllers.push_back(razer_rgb);
+        }
+        else
+        {
+            delete razer_rgb;
+        }
+    }
+
+    hdev = NULL;
+	num = init_razer_mousemat_driver(&hdev);
+	for (unsigned int i = 0; i < num; i++)
+    {
+        device_fn_type* device_fn = new device_fn_type;
+        device_fn->device_type             	     = &devmousemat_attr_device_type;
+        device_fn->device_serial           	     = &devmousemat_attr_device_serial;
+		device_fn->firmware_version			     = &devmousemat_attr_firmware_version;
+        device_fn->matrix_effect_custom    	     = &devmousemat_attr_matrix_effect_custom;
+        device_fn->matrix_custom_frame     	     = &devmousemat_attr_matrix_custom_frame;
+        device_fn->matrix_brightness       	     = &devmousemat_attr_matrix_brightness;
+        device_fn->matrix_effect_none      	     = &devmousemat_attr_matrix_effect_none;
+        device_fn->matrix_effect_static    	     = &devmousemat_attr_matrix_effect_static;
+		device_fn->matrix_effect_breath	         = &devmousemat_attr_matrix_effect_breath;
+        device_fn->matrix_effect_spectrum  	     = &devmousemat_attr_matrix_effect_spectrum;
+        device_fn->matrix_effect_reactive  	     = &devmousemat_attr_matrix_effect_reactive;
+		device_fn->matrix_effect_wave		     = &devmousemat_attr_matrix_effect_wave;
+        device_fn->logo_led_brightness           = NULL;
+        device_fn->logo_matrix_effect_none       = NULL;
+        device_fn->logo_matrix_effect_static     = NULL;
+        device_fn->logo_matrix_effect_spectrum   = NULL;
+        device_fn->logo_matrix_effect_reactive   = NULL;
+        device_fn->scroll_led_brightness         = NULL;
+        device_fn->scroll_matrix_effect_none     = NULL;
+        device_fn->scroll_matrix_effect_static   = NULL;
+        device_fn->scroll_matrix_effect_spectrum = NULL;
+        device_fn->scroll_matrix_effect_reactive = NULL;
+        device_fn->scroll_led_effect             = NULL;
+        device_fn->scroll_led_rgb                = NULL;
+
+        RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(&hdev[i].dev, device_fn);
+
+        if(razer_rgb->device_index != -1)
+        {
+            rgb_controllers.push_back(razer_rgb);
+        }
+        else
+        {
+            delete razer_rgb;
+        }
+    }
+
+    hdev = NULL;
+	num = init_razer_accessory_driver(&hdev);
+	for (unsigned int i = 0; i < num; i++)
+    {
+        device_fn_type* device_fn = new device_fn_type;
+        device_fn->device_type                   = &devaccessory_attr_device_type;
+        device_fn->device_serial                 = &devaccessory_attr_device_serial;
+		device_fn->firmware_version			     = &devaccessory_attr_firmware_version;
+        device_fn->matrix_effect_custom          = &devaccessory_attr_matrix_effect_custom;
+        device_fn->matrix_custom_frame           = &devaccessory_attr_matrix_custom_frame;
+        device_fn->matrix_brightness             = &devaccessory_attr_matrix_brightness;
+        device_fn->matrix_effect_none            = &devaccessory_attr_matrix_effect_none;
+        device_fn->matrix_effect_static          = &devaccessory_attr_matrix_effect_static;
+		device_fn->matrix_effect_breath	         = &devaccessory_attr_matrix_effect_breath;
+        device_fn->matrix_effect_spectrum        = &devaccessory_attr_matrix_effect_spectrum;
+        device_fn->matrix_effect_reactive        = NULL;//&devaccessory_attr_matrix_effect_reactive;
+		device_fn->matrix_effect_wave            = &devaccessory_attr_matrix_effect_wave;
+        device_fn->logo_led_brightness           = NULL;
+        device_fn->logo_matrix_effect_none       = NULL;
+        device_fn->logo_matrix_effect_static     = NULL;
+        device_fn->logo_matrix_effect_spectrum   = NULL;
+        device_fn->logo_matrix_effect_reactive   = NULL;
+        device_fn->scroll_led_brightness         = NULL;
+        device_fn->scroll_matrix_effect_none     = NULL;
+        device_fn->scroll_matrix_effect_static   = NULL;
+        device_fn->scroll_matrix_effect_spectrum = NULL;
+        device_fn->scroll_matrix_effect_reactive = NULL;
+        device_fn->scroll_led_effect             = NULL;
+        device_fn->scroll_led_rgb                = NULL;
+
+        RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(&hdev[i].dev, device_fn);
+
+        if(razer_rgb->device_index != -1)
+        {
+            rgb_controllers.push_back(razer_rgb);
+        }
+        else
+        {
+            delete razer_rgb;
+        }
+    }
+
+    hdev = NULL;
+	num = init_razer_kraken_driver(&hdev);
+	for (unsigned int i = 0; i < num; i++)
+    {
+        device_fn_type* device_fn = new device_fn_type;
+        device_fn->device_type                   = &devkraken_attr_device_type;
+        device_fn->device_serial                 = &devkraken_attr_device_serial;
+		device_fn->firmware_version			     = &devkraken_attr_firmware_version;
+        device_fn->matrix_effect_custom          = &devkraken_attr_matrix_effect_custom;
+        device_fn->matrix_custom_frame           = NULL;//&devkraken_attr_matrix_custom_frame;
+        device_fn->matrix_brightness             = NULL;//&devkraken_attr_matrix_brightness;
+        device_fn->matrix_effect_none            = &devkraken_attr_matrix_effect_none;
+        device_fn->matrix_effect_static          = &devkraken_attr_matrix_effect_static;
+		device_fn->matrix_effect_breath	         = &devkraken_attr_matrix_effect_breath;
+        device_fn->matrix_effect_spectrum        = &devkraken_attr_matrix_effect_spectrum;
+        device_fn->matrix_effect_reactive        = NULL;//&devkraken_attr_matrix_effect_reactive;
+		device_fn->matrix_effect_wave            = NULL;//&devkraken_attr_matrix_effect_wave;
+        device_fn->logo_led_brightness           = NULL;
+        device_fn->logo_matrix_effect_none       = NULL;
+        device_fn->logo_matrix_effect_static     = NULL;
+        device_fn->logo_matrix_effect_spectrum   = NULL;
+        device_fn->logo_matrix_effect_reactive   = NULL;
+        device_fn->scroll_led_brightness         = NULL;
+        device_fn->scroll_matrix_effect_none     = NULL;
+        device_fn->scroll_matrix_effect_static   = NULL;
+        device_fn->scroll_matrix_effect_spectrum = NULL;
+        device_fn->scroll_matrix_effect_reactive = NULL;
+        device_fn->scroll_led_effect             = NULL;
+        device_fn->scroll_led_rgb                = NULL;
+
+        RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(&hdev[i].dev, device_fn);
+
+        if(razer_rgb->device_index != -1)
+        {
+            rgb_controllers.push_back(razer_rgb);
+        }
+        else
+        {
+            delete razer_rgb;
+        }
+    }
+
+    hdev = NULL;
+	num = init_razer_core_driver(&hdev);
+	for (unsigned int i = 0; i < num; i++)
+    {
+        device_fn_type* device_fn = new device_fn_type;
+        device_fn->device_type                   = &devcore_attr_device_type;
+        device_fn->device_serial                 = &devcore_attr_device_serial;
+		device_fn->firmware_version			     = &devcore_attr_firmware_version;
+        device_fn->matrix_effect_custom          = &devcore_attr_matrix_effect_custom;
+        device_fn->matrix_custom_frame           = &devcore_attr_matrix_custom_frame;
+        device_fn->matrix_brightness             = &devcore_attr_matrix_brightness;
+        device_fn->matrix_effect_none            = &devcore_attr_matrix_effect_none;
+        device_fn->matrix_effect_static          = &devcore_attr_matrix_effect_static;
+		device_fn->matrix_effect_breath	         = &devcore_attr_matrix_effect_breath;
+        device_fn->matrix_effect_spectrum        = &devcore_attr_matrix_effect_spectrum;
+        device_fn->matrix_effect_reactive        = &devcore_attr_matrix_effect_reactive;
+		device_fn->matrix_effect_wave            = &devcore_attr_matrix_effect_wave;
+        device_fn->logo_led_brightness           = NULL;
+        device_fn->logo_matrix_effect_none       = NULL;
+        device_fn->logo_matrix_effect_static     = NULL;
+        device_fn->logo_matrix_effect_spectrum   = NULL;
+        device_fn->logo_matrix_effect_reactive   = NULL;
+        device_fn->scroll_led_brightness         = NULL;
+        device_fn->scroll_matrix_effect_none     = NULL;
+        device_fn->scroll_matrix_effect_static   = NULL;
+        device_fn->scroll_matrix_effect_spectrum = NULL;
+        device_fn->scroll_matrix_effect_reactive = NULL;
+        device_fn->scroll_led_effect             = NULL;
+        device_fn->scroll_led_rgb                = NULL;
+
+        RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(&hdev[i].dev, device_fn);
+
+        if(razer_rgb->device_index != -1)
+        {
+            rgb_controllers.push_back(razer_rgb);
+        }
+        else
+        {
+            delete razer_rgb;
+        }
+    }
+
+}   /* DetectOpenRazerControllers() */

RGBController/RGBController.h

@@ -25,14 +25,14 @@ typedef unsigned int RGBColor;
 \*------------------------------------------------------------------*/
 enum
 {
-    MODE_FLAG_HAS_SPEED         = (1 << 0), /* Mode has speed parameter         */
-    MODE_FLAG_HAS_DIRECTION_LR  = (1 << 1), /* Mode has left/right parameter    */
-    MODE_FLAG_HAS_DIRECTION_UD  = (1 << 2), /* Mode has up/down parameter       */
-    MODE_FLAG_HAS_DIRECTION_HV  = (1 << 3), /* Mode has horiz/vert parameter    */
-    MODE_FLAG_HAS_BRIGHTNESS    = (1 << 4), /* Mode has brightness parameter    */
-    MODE_FLAG_HAS_COLOR         = (1 << 5), /* Mode has custom color parameter  */
-    MODE_FLAG_RANDOM_COLOR      = (1 << 6), /* Mode has random color option     */
-    MODE_FLAG_PER_LED_COLOR     = (1 << 7), /* Mode uses device LED colors      */
+    MODE_FLAG_HAS_SPEED                 = (1 << 0), /* Mode has speed parameter         */
+    MODE_FLAG_HAS_DIRECTION_LR          = (1 << 1), /* Mode has left/right parameter    */
+    MODE_FLAG_HAS_DIRECTION_UD          = (1 << 2), /* Mode has up/down parameter       */
+    MODE_FLAG_HAS_DIRECTION_HV          = (1 << 3), /* Mode has horiz/vert parameter    */
+    MODE_FLAG_HAS_BRIGHTNESS            = (1 << 4), /* Mode has brightness parameter    */
+    MODE_FLAG_HAS_PER_LED_COLOR         = (1 << 5), /* Mode has per-LED colors          */
+    MODE_FLAG_HAS_MODE_SPECIFIC_COLOR   = (1 << 6), /* Mode has mode specific colors    */
+    MODE_FLAG_HAS_RANDOM_COLOR          = (1 << 7), /* Mode has random color option     */
 };
 
 /*------------------------------------------------------------------*\
@@ -48,6 +48,14 @@ enum
     MODE_DIRECTION_VERTICAL     = 5,        /* Mode direction vertical          */
 };
 
+enum
+{
+    MODE_COLORS_NONE            = 0,        /* Mode has no colors               */
+    MODE_COLORS_PER_LED         = 1,        /* Mode has per LED colors selected */
+    MODE_COLORS_MODE_SPECIFIC   = 2,        /* Mode specific colors selected    */
+    MODE_COLORS_RANDOM          = 3,        /* Mode has random colors selected  */
+};
+
 /*------------------------------------------------------------------*\
 | Mode Type                                                          |
 \*------------------------------------------------------------------*/
@@ -61,13 +69,17 @@ typedef struct
     unsigned int        flags;  /* Mode flags bitfield              */
     unsigned int        speed_min;  /* speed minimum value          */
     unsigned int        speed_max;  /* speed maximum value          */
+    unsigned int        colors_min; /* minimum number of mode colors*/
+    unsigned int        colors_max; /* maximum numver of mode colors*/
     
     /*--------------------------------------------------------------*\
     | Mode Settings                                                  |
     \*--------------------------------------------------------------*/
     unsigned int        speed;  /* Mode speed parameter value       */
     unsigned int        direction;  /* Mode direction value         */
-    bool                random; /* Random color mode enabled        */
+    unsigned int        color_mode; /* Mode color selection         */
+    std::vector<RGBColor>
+                        colors; /* mode-specific colors             */
 } mode;
 
 typedef struct

RGBController/RGBController_AMDWraithPrism.cpp

@@ -18,70 +18,70 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     version = wraith->GetFirmwareVersionString();
 
     mode Static;
-    Static.name   = "Static";
-    Static.value  = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
-    Static.flags  = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Static.random = false;
+    Static.name       = "Static";
+    Static.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Breathing;
-    Breathing.name      = "Breathing";
-    Breathing.value     = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING;
-    Breathing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Breathing.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Breathing.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Breathing.random    = false;
-    Breathing.speed     = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Breathing.name       = "Breathing";
+    Breathing.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Breathing.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Breathing.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
+    Breathing.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Breathing);
 
     mode ColorCycle;
-    ColorCycle.name      = "Color Cycle";
-    ColorCycle.value     = AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE;
-    ColorCycle.flags     = MODE_FLAG_HAS_SPEED;
-    ColorCycle.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    ColorCycle.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    ColorCycle.random    = false;
-    ColorCycle.speed     = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    ColorCycle.name       = "Color Cycle";
+    ColorCycle.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE;
+    ColorCycle.flags      = MODE_FLAG_HAS_SPEED;
+    ColorCycle.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    ColorCycle.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    ColorCycle.color_mode = MODE_COLORS_NONE;
+    ColorCycle.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(ColorCycle);
 
     mode Rainbow;
-    Rainbow.name      = "Rainbow";
-    Rainbow.value     = AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW;
-    Rainbow.flags     = MODE_FLAG_HAS_SPEED;
-    Rainbow.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Rainbow.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Rainbow.random    = false;
-    Rainbow.speed     = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW;
+    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Rainbow.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Rainbow.color_mode = MODE_COLORS_NONE;
+    Rainbow.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Rainbow);
 
     mode Bounce;
-    Bounce.name      = "Bounce";
-    Bounce.value     = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE;
-    Bounce.flags     = MODE_FLAG_HAS_SPEED;
-    Bounce.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Bounce.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Bounce.random    = true;
-    Bounce.speed     = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Bounce.name       = "Bounce";
+    Bounce.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE;
+    Bounce.flags      = MODE_FLAG_HAS_SPEED;
+    Bounce.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Bounce.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Bounce.color_mode = MODE_COLORS_NONE;
+    Bounce.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Bounce);
 
     mode Chase;
-    Chase.name      = "Chase";
-    Chase.value     = AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE;
-    Chase.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Chase.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Chase.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Chase.random    = false;
-    Chase.speed     = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Chase.name       = "Chase";
+    Chase.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE;
+    Chase.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Chase.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Chase.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Chase.color_mode = MODE_COLORS_PER_LED;
+    Chase.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Chase);
 
     mode Swirl;
-    Swirl.name      = "Swirl";
-    Swirl.value     = AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL;
-    Swirl.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Swirl.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Swirl.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Swirl.random    = false;
-    Swirl.speed     = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Swirl.name       = "Swirl";
+    Swirl.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL;
+    Swirl.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Swirl.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Swirl.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Swirl.color_mode = MODE_COLORS_PER_LED;
+    Swirl.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Swirl);
 
     led logo_led;
@@ -180,35 +180,37 @@ void RGBController_AMDWraithPrism::SetCustomMode()
 
 void RGBController_AMDWraithPrism::UpdateMode()
 {
-    wraith->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, modes[active_mode].random);
+    bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+
+    wraith->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, random);
 
     switch(modes[active_mode].value)
     {
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE:
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW:
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE:
-            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].random);
-            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].random);
+            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
+            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
             break;
         
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
-            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].random);
-            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].random);
+            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, random);
+            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, random);
             break;
 
         default:
-            if(modes[active_mode].random)
+            if(random)
             {
-                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].random);
-                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].random);
+                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
+                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
             }
             else
             {
-                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].random);
-                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].random);
+                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, random);
+                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, random);
             }
             break;
     }
 
     UpdateLEDs();
-}
+}

RGBController/RGBController_Aura.cpp

@@ -11,38 +11,45 @@
 
 int RGBController_Aura::GetDeviceMode()
 {
-    int  dev_mode = aura->AuraRegisterRead(AURA_REG_MODE);
-    bool random   = false;
-
-    switch(dev_mode)
-    {
-    case AURA_MODE_SPECTRUM_CYCLE_CHASE:
-        dev_mode = AURA_MODE_CHASE;
-        random   = true;
-        break;
-
-    case AURA_MODE_SPECTRUM_CYCLE_BREATHING:
-        dev_mode = AURA_MODE_BREATHING;
-        random   = true;
-        break;
-
-    case AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE:
-        dev_mode = AURA_MODE_CHASE_FADE;
-        random   = true;
-        break;
-    }
+    int  dev_mode  = aura->AuraRegisterRead(AURA_REG_MODE);
+    int color_mode = MODE_COLORS_PER_LED;
 
     if (aura->AuraRegisterRead(AURA_REG_DIRECT))
     {
         dev_mode = 0xFFFF;
     }
 
+    switch(dev_mode)
+    {
+    case AURA_MODE_OFF:
+    case AURA_MODE_RAINBOW:
+    case AURA_MODE_SPECTRUM_CYCLE:
+    case AURA_MODE_RANDOM_FLICKER:
+        color_mode = MODE_COLORS_NONE;
+        break;
+
+    case AURA_MODE_SPECTRUM_CYCLE_CHASE:
+        dev_mode   = AURA_MODE_CHASE;
+        color_mode = MODE_COLORS_RANDOM;
+        break;
+
+    case AURA_MODE_SPECTRUM_CYCLE_BREATHING:
+        dev_mode   = AURA_MODE_BREATHING;
+        color_mode = MODE_COLORS_RANDOM;
+        break;
+
+    case AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE:
+        dev_mode   = AURA_MODE_CHASE_FADE;
+        color_mode = MODE_COLORS_RANDOM;
+        break;
+    }
+
     for(int mode = 0; mode < modes.size(); mode++)
     {
         if(modes[mode].value == dev_mode)
         {
-            active_mode        = mode;
-            modes[mode].random = random;
+            active_mode            = mode;
+            modes[mode].color_mode = color_mode;
         }
     }
 
@@ -129,63 +136,73 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
     }
 
     mode Direct;
-    Direct.name  = "Direct";
-    Direct.value = 0xFFFF;
-    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Direct.name       = "Direct";
+    Direct.value      = 0xFFFF;
+    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 = AURA_MODE_OFF;
-    Off.flags = 0;
+    Off.name       = "Off";
+    Off.value      = AURA_MODE_OFF;
+    Off.flags      = 0;
+    Off.color_mode = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Static;
-    Static.name  = "Static";
-    Static.value = AURA_MODE_STATIC;
-    Static.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Static.name       = "Static";
+    Static.value      = AURA_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
     
     mode Breathing;
-    Breathing.name  = "Breathing";
-    Breathing.value = AURA_MODE_BREATHING;
-    Breathing.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Breathing.name       = "Breathing";
+    Breathing.value      = AURA_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Breathing);
 
     mode Flashing;
-    Flashing.name  = "Flashing";
-    Flashing.value = AURA_MODE_FLASHING;
-    Flashing.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Flashing.name       = "Flashing";
+    Flashing.value      = AURA_MODE_FLASHING;
+    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Flashing.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Flashing);
 
     mode SpectrumCycle;
-    SpectrumCycle.name  = "Spectrum Cycle";
-    SpectrumCycle.value = AURA_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags = 0;
+    SpectrumCycle.name       = "Spectrum Cycle";
+    SpectrumCycle.value      = AURA_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags      = 0;
+    SpectrumCycle.color_mode = MODE_COLORS_NONE;
     modes.push_back(SpectrumCycle);
 
     mode Rainbow;
-    Rainbow.name  = "Rainbow";
-    Rainbow.value = AURA_MODE_RAINBOW;
-    Rainbow.flags = 0;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = AURA_MODE_RAINBOW;
+    Rainbow.flags      = 0;
+    Rainbow.color_mode = MODE_COLORS_NONE;
     modes.push_back(Rainbow);
 
     mode ChaseFade;
-    ChaseFade.name  = "Chase Fade";
-    ChaseFade.value = AURA_MODE_CHASE_FADE;
-    ChaseFade.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR | MODE_FLAG_PER_LED_COLOR;
+    ChaseFade.name       = "Chase Fade";
+    ChaseFade.value      = AURA_MODE_CHASE_FADE;
+    ChaseFade.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
+    ChaseFade.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(ChaseFade);
 
     mode Chase;
-    Chase.name  = "Chase";
-    Chase.value = AURA_MODE_CHASE;
-    Chase.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Chase.name       = "Chase";
+    Chase.value      = AURA_MODE_CHASE;
+    Chase.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
+    Chase.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Chase);
 
     mode RandomFlicker;
-    RandomFlicker.name  = "Random Flicker";
-    RandomFlicker.value = AURA_MODE_RANDOM_FLICKER;
-    RandomFlicker.flags = 0;
+    RandomFlicker.name       = "Random Flicker";
+    RandomFlicker.value      = AURA_MODE_RANDOM_FLICKER;
+    RandomFlicker.flags      = 0;
+    RandomFlicker.color_mode = MODE_COLORS_NONE;
     modes.push_back(RandomFlicker);
 
     colors.resize(aura->GetLEDCount());
@@ -272,7 +289,7 @@ void RGBController_Aura::UpdateMode()
     {
         int new_mode = modes[active_mode].value;
 
-        if(modes[active_mode].random == true)
+        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
         {
             switch(new_mode)
             {
@@ -291,4 +308,4 @@ void RGBController_Aura::UpdateMode()
         aura->SetMode(new_mode);
         aura->SetDirect(false);
     }
-}
+}

RGBController/RGBController_AuraAddressable.cpp

@@ -0,0 +1,196 @@
+/*-----------------------------------------*\
+|  RGBController_AuraAddressable.cpp        |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  addressable controller driver            |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController_AuraAddressable.h"
+
+RGBController_AuraAddressable::RGBController_AuraAddressable(AuraAddressableController* aura_ptr)
+{
+    aura = aura_ptr;
+
+    name = "Asus Aura Addressable";
+    type = DEVICE_TYPE_MOTHERBOARD;
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0xFFFF;
+    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      = AURA_MODE_OFF;
+    Off.flags      = 0;
+    Off.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = AURA_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min = 1;
+    Static.colors_max = 1;
+    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name       = "Breathing";
+    Breathing.value      = AURA_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Breathing.colors_min = 1;
+    Breathing.colors_max = 1;
+    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);
+
+    mode Flashing;
+    Flashing.name       = "Flashing";
+    Flashing.value      = AURA_MODE_FLASHING;
+    Flashing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Flashing.colors_min = 1;
+    Flashing.colors_max = 1;
+    Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Flashing.colors.resize(1);
+    modes.push_back(Flashing);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name       = "Spectrum Cycle";
+    SpectrumCycle.value      = AURA_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags      = 0;
+    SpectrumCycle.color_mode = MODE_COLORS_NONE;
+    modes.push_back(SpectrumCycle);
+
+    mode Rainbow;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = AURA_MODE_RAINBOW;
+    Rainbow.flags      = 0;
+    Rainbow.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
+
+    mode ChaseFade;
+    ChaseFade.name       = "Chase Fade";
+    ChaseFade.value      = AURA_MODE_CHASE_FADE;
+    ChaseFade.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    ChaseFade.colors_min = 1;
+    ChaseFade.colors_max = 1;
+    ChaseFade.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ChaseFade.colors.resize(1);
+    modes.push_back(ChaseFade);
+
+    mode Chase;
+    Chase.name       = "Chase";
+    Chase.value      = AURA_MODE_CHASE;
+    Chase.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Chase.colors_min = 1;
+    Chase.colors_max = 1;
+    Chase.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Chase.colors.resize(1);
+    modes.push_back(Chase);
+
+    /*-------------------------------------------------*\
+    | Set size of colors array                          |
+    \*-------------------------------------------------*/
+    unsigned int led_count = 0;
+    for (unsigned int channel_idx = 0; channel_idx < 1; channel_idx++)
+    {
+        led_count += aura->channel_leds[channel_idx];
+    }
+    colors.resize(led_count);
+
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    unsigned int led_idx = 0;
+    for (unsigned int channel_idx = 0; channel_idx < 1; channel_idx++)
+    {
+        if(aura->channel_leds[channel_idx] > 0)
+        {
+            zone* new_zone = new zone;
+
+            char ch_idx_string[2];
+            sprintf(ch_idx_string, "%d", channel_idx + 1);
+
+            new_zone->name = "Channel ";
+            new_zone->name.append(ch_idx_string);
+            new_zone->type = ZONE_TYPE_LINEAR;
+
+            std::vector<int> *new_zone_map = new std::vector<int>();
+
+            for (unsigned int led_ch_idx = 0; led_ch_idx < aura->channel_leds[channel_idx]; led_ch_idx++)
+            {
+                char led_idx_string[3];
+                sprintf(led_idx_string, "%d", led_ch_idx + 1);
+
+                led new_led;
+                new_led.name = "Channel ";
+                new_led.name.append(ch_idx_string);
+                new_led.name.append(", LED ");
+                new_led.name.append(led_idx_string);
+
+                leds.push_back(new_led);
+                leds_channel.push_back(channel_idx + 1);
+
+                new_zone_map->push_back(led_idx);
+                led_idx++;
+            }
+
+            new_zone->map.push_back(*new_zone_map);
+            zones.push_back(*new_zone);
+            zones_channel.push_back(channel_idx + 1);
+        }
+    }
+}
+
+RGBController_AuraAddressable::~RGBController_AuraAddressable()
+{
+
+}
+
+void RGBController_AuraAddressable::UpdateLEDs()
+{
+    if(modes[active_mode].value ==  0xFFFF)
+    {
+        aura->SetLEDsDirect(colors);
+    }
+}
+
+void RGBController_AuraAddressable::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_AuraAddressable::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
+}
+
+void RGBController_AuraAddressable::SetCustomMode()
+{
+
+}
+
+void RGBController_AuraAddressable::UpdateMode()
+{
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        red = RGBGetRValue(modes[active_mode].colors[0]);
+        grn = RGBGetGValue(modes[active_mode].colors[0]);
+        blu = RGBGetBValue(modes[active_mode].colors[0]);
+    }
+
+    if(modes[active_mode].value != 0xFFFF)
+    {
+        aura->SetMode(modes[active_mode].value, red, grn, blu);
+    }
+}

RGBController/RGBController_AuraAddressable.h

@@ -0,0 +1,30 @@
+/*-----------------------------------------*\
+|  RGBController_AuraAddressable.h          |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  addressable controller driver            |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AuraAddressableController.h"
+
+class RGBController_AuraAddressable : public RGBController
+{
+public:
+    RGBController_AuraAddressable(AuraAddressableController* aura_ptr);
+    ~RGBController_AuraAddressable();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+private:
+    AuraAddressableController*  aura;
+    std::vector<unsigned int>   leds_channel;
+    std::vector<unsigned int>   zones_channel;
+};

RGBController/RGBController_Corsair.cpp

@@ -39,21 +39,24 @@ RGBController_Corsair::RGBController_Corsair(CorsairController* corsair_ptr)
     type = DEVICE_TYPE_DRAM;
 
     mode Static;
-    Static.name  = "Static";
-    Static.value = CORSAIR_VENGEANCE_RGB_MODE_SINGLE;
-    Static.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Static.name       = "Static";
+    Static.value      = CORSAIR_VENGEANCE_RGB_MODE_SINGLE;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Fade;
-    Fade.name  = "Fade";
-    Fade.value = CORSAIR_VENGEANCE_RGB_MODE_FADE;
-    Fade.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Fade.name       = "Fade";
+    Fade.value      = CORSAIR_VENGEANCE_RGB_MODE_FADE;
+    Fade.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Fade.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Fade);
 
     mode Pulse;
-    Pulse.name  = "Pulse";
-    Pulse.value = CORSAIR_VENGEANCE_RGB_MODE_PULSE;
-    Pulse.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Pulse.name       = "Pulse";
+    Pulse.value      = CORSAIR_VENGEANCE_RGB_MODE_PULSE;
+    Pulse.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Pulse.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Pulse);
 
     for (unsigned int i = 0; i < corsair->GetLEDCount(); i++)
@@ -91,4 +94,4 @@ void RGBController_Corsair::SetCustomMode()
 void RGBController_Corsair::UpdateMode()
 {
     corsair->SetMode(modes[active_mode].value);
-}
+}

RGBController/RGBController_CorsairCmdrPro.cpp

@@ -19,106 +19,145 @@ RGBController_CorsairCmdrPro::RGBController_CorsairCmdrPro(CorsairCmdrProControl
     type = DEVICE_TYPE_LEDSTRIP;
     
     mode Direct;
-    Direct.name  = "Direct";
-    Direct.value = 0xFFFF;
-    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Direct.name       = "Direct";
+    Direct.value      = 0xFFFF;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode RainbowWave;
-    RainbowWave.name      = "Rainbow Wave";
-    RainbowWave.value     = CORSAIR_CMDR_PRO_MODE_RAINBOW_WAVE;
-    RainbowWave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    RainbowWave.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    RainbowWave.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    RainbowWave.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
-    RainbowWave.direction = MODE_DIRECTION_RIGHT;
+    RainbowWave.name       = "Rainbow Wave";
+    RainbowWave.value      = CORSAIR_CMDR_PRO_MODE_RAINBOW_WAVE;
+    RainbowWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    RainbowWave.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    RainbowWave.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    RainbowWave.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    RainbowWave.direction  = MODE_DIRECTION_RIGHT;
+    RainbowWave.color_mode = MODE_COLORS_NONE;
     modes.push_back(RainbowWave);
 
     mode ColorShift;
     ColorShift.name       = "Color Shift";
     ColorShift.value      = CORSAIR_CMDR_PRO_MODE_COLOR_SHIFT;
-    ColorShift.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    ColorShift.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorShift.colors_min = 2;
+    ColorShift.colors_max = 2;
     ColorShift.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
     ColorShift.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
     ColorShift.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorShift.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorShift.colors.resize(2);
     modes.push_back(ColorShift);
 
     mode ColorPulse;
-    ColorPulse.name      = "Color Pulse";
-    ColorPulse.value     = CORSAIR_CMDR_PRO_MODE_COLOR_PULSE;
-    ColorPulse.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    ColorPulse.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    ColorPulse.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    ColorPulse.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorPulse.name       = "Color Pulse";
+    ColorPulse.value      = CORSAIR_CMDR_PRO_MODE_COLOR_PULSE;
+    ColorPulse.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorPulse.colors_min = 2;
+    ColorPulse.colors_max = 2;
+    ColorPulse.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorPulse.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorPulse.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorPulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorPulse.colors.resize(2);
     modes.push_back(ColorPulse);
 
     mode ColorWave;
-    ColorWave.name      = "Color Wave";
-    ColorWave.value     = CORSAIR_CMDR_PRO_MODE_COLOR_WAVE;
-    ColorWave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    ColorWave.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    ColorWave.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    ColorWave.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
-    ColorWave.direction = MODE_DIRECTION_RIGHT;
+    ColorWave.name       = "Color Wave";
+    ColorWave.value      = CORSAIR_CMDR_PRO_MODE_COLOR_WAVE;
+    ColorWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorWave.colors_min = 2;
+    ColorWave.colors_max = 2;
+    ColorWave.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorWave.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorWave.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorWave.direction  = MODE_DIRECTION_RIGHT;
+    ColorWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorWave.colors.resize(2);
     modes.push_back(ColorWave);
 
     mode Static;
-    Static.name  = "Static";
-    Static.value = CORSAIR_CMDR_PRO_MODE_STATIC;
-    Static.flags = MODE_FLAG_HAS_COLOR;
+    Static.name       = "Static";
+    Static.value      = CORSAIR_CMDR_PRO_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min = 1;
+    Static.colors_max = 1;
+    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
     modes.push_back(Static);
 
     mode Temperature;
-    Temperature.name  = "Temperature";
-    Temperature.value = CORSAIR_CMDR_PRO_MODE_TEMPERATURE;
-    Temperature.flags = MODE_FLAG_HAS_COLOR;
+    Temperature.name       = "Temperature";
+    Temperature.value      = CORSAIR_CMDR_PRO_MODE_TEMPERATURE;
+    Temperature.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Temperature.colors_min = 3;
+    Temperature.colors_max = 3;
+    Temperature.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Temperature.colors.resize(3);
     modes.push_back(Temperature);
 
     mode Visor;
-    Visor.name      = "Visor";
-    Visor.value     = CORSAIR_CMDR_PRO_MODE_VISOR;
-    Visor.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Visor.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    Visor.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    Visor.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Visor.name       = "Visor";
+    Visor.value      = CORSAIR_CMDR_PRO_MODE_VISOR;
+    Visor.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Visor.colors_min = 2;
+    Visor.colors_max = 2;
+    Visor.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Visor.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Visor.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Visor.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Visor.colors.resize(2);
     modes.push_back(Visor);
 
     mode Marquee;
-    Marquee.name      = "Marquee";
-    Marquee.value     = CORSAIR_CMDR_PRO_MODE_MARQUEE;
-    Marquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Marquee.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    Marquee.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    Marquee.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
-    Marquee.direction = MODE_DIRECTION_RIGHT;
+    Marquee.name       = "Marquee";
+    Marquee.value      = CORSAIR_CMDR_PRO_MODE_MARQUEE;
+    Marquee.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Marquee.colors_min = 1;
+    Marquee.colors_max = 1;
+    Marquee.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Marquee.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Marquee.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Marquee.direction  = MODE_DIRECTION_RIGHT;
+    Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Marquee.colors.resize(1);
     modes.push_back(Marquee);
 
     mode Blink;
-    Blink.name      = "Blink";
-    Blink.value     = CORSAIR_CMDR_PRO_MODE_BLINK;
-    Blink.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Blink.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    Blink.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    Blink.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Blink.name       = "Blink";
+    Blink.value      = CORSAIR_CMDR_PRO_MODE_BLINK;
+    Blink.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Blink.colors_min = 2;
+    Blink.colors_max = 2;
+    Blink.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Blink.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Blink.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Blink.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Blink.colors.resize(2);
     modes.push_back(Blink);
 
     mode Sequential;
-    Sequential.name      = "Sequential";
-    Sequential.value     = CORSAIR_CMDR_PRO_MODE_SEQUENTIAL;
-    Sequential.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Sequential.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    Sequential.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    Sequential.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
-    Sequential.direction = MODE_DIRECTION_RIGHT;
+    Sequential.name       = "Sequential";
+    Sequential.value      = CORSAIR_CMDR_PRO_MODE_SEQUENTIAL;
+    Sequential.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Sequential.colors_min = 1;
+    Sequential.colors_max = 1;
+    Sequential.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Sequential.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Sequential.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Sequential.direction  = MODE_DIRECTION_RIGHT;
+    Sequential.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Sequential.colors.resize(1);
     modes.push_back(Sequential);
 
     mode Rainbow;
-    Rainbow.name      = "Rainbow";
-    Rainbow.value     = CORSAIR_CMDR_PRO_MODE_RAINBOW;
-    Rainbow.flags     = MODE_FLAG_HAS_SPEED;
-    Rainbow.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    Rainbow.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    Rainbow.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = CORSAIR_CMDR_PRO_MODE_RAINBOW;
+    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Rainbow.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Rainbow.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Rainbow.color_mode = MODE_COLORS_NONE;
     modes.push_back(Rainbow);
 
     /*-------------------------------------------------*\
@@ -240,7 +279,7 @@ void RGBController_CorsairCmdrPro::UpdateSingleLED(int led)
 
 void RGBController_CorsairCmdrPro::SetCustomMode()
 {
-    active_mode = 9;
+    active_mode = 0;
 }
 
 void RGBController_CorsairCmdrPro::UpdateMode()
@@ -254,23 +293,39 @@ void RGBController_CorsairCmdrPro::UpdateMode()
         for(int channel = 0; channel < CORSAIR_CMDR_PRO_NUM_CHANNELS; channel++)
         {
             unsigned int direction = 0;
+            bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
 
             if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
             {
                 direction = 1;
             }
 
+            unsigned char mode_colors[9];
+
+            if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+            {
+                for(int i = 0; i < modes[active_mode].colors.size(); i++)
+                {
+                    mode_colors[(3 * i) + 0] = RGBGetRValue(modes[active_mode].colors[i]);
+                    mode_colors[(3 * i) + 1] = RGBGetGValue(modes[active_mode].colors[i]);
+                    mode_colors[(3 * i) + 2] = RGBGetBValue(modes[active_mode].colors[i]);
+                }
+            }
+
             corsair->SetChannelEffect(channel,
                                       modes[active_mode].value,
                                       modes[active_mode].speed,
                                       direction,
-                                      modes[active_mode].random,
-                                      RGBGetRValue(colors[0]),
-                                      RGBGetGValue(colors[0]),
-                                      RGBGetBValue(colors[0]),
-                                      RGBGetRValue(colors[1]),
-                                      RGBGetGValue(colors[1]),
-                                      RGBGetBValue(colors[1]));
+                                      random,
+                                      mode_colors[0],
+                                      mode_colors[1],
+                                      mode_colors[2],
+                                      mode_colors[3],
+                                      mode_colors[4],
+                                      mode_colors[5],
+                                      mode_colors[6],
+                                      mode_colors[7],
+                                      mode_colors[8]);
         }
     }
-}
+}

RGBController/RGBController_CorsairKeyboard.cpp

@@ -145,9 +145,10 @@ RGBController_CorsairKeyboard::RGBController_CorsairKeyboard(CorsairKeyboardCont
     type = DEVICE_TYPE_KEYBOARD;
 
     mode Direct;
-    Direct.name  = "Direct";
-    Direct.value = 0;
-    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     colors.resize(111);

RGBController/RGBController_CorsairNodePro.cpp

@@ -19,106 +19,145 @@ RGBController_CorsairNodePro::RGBController_CorsairNodePro(CorsairNodeProControl
     type = DEVICE_TYPE_LEDSTRIP;
 
     mode Direct;
-    Direct.name  = "Direct";
-    Direct.value = 0xFFFF;
-    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Direct.name       = "Direct";
+    Direct.value      = 0xFFFF;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode RainbowWave;
-    RainbowWave.name      = "Rainbow Wave";
-    RainbowWave.value     = CORSAIR_CMDR_PRO_MODE_RAINBOW_WAVE;
-    RainbowWave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    RainbowWave.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    RainbowWave.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    RainbowWave.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
-    RainbowWave.direction = MODE_DIRECTION_RIGHT;
+    RainbowWave.name       = "Rainbow Wave";
+    RainbowWave.value      = CORSAIR_CMDR_PRO_MODE_RAINBOW_WAVE;
+    RainbowWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    RainbowWave.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    RainbowWave.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    RainbowWave.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    RainbowWave.direction  = MODE_DIRECTION_RIGHT;
+    RainbowWave.color_mode = MODE_COLORS_NONE;
     modes.push_back(RainbowWave);
 
     mode ColorShift;
     ColorShift.name       = "Color Shift";
     ColorShift.value      = CORSAIR_CMDR_PRO_MODE_COLOR_SHIFT;
-    ColorShift.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    ColorShift.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorShift.colors_min = 2;
+    ColorShift.colors_max = 2;
     ColorShift.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
     ColorShift.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
     ColorShift.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorShift.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorShift.colors.resize(2);
     modes.push_back(ColorShift);
 
     mode ColorPulse;
-    ColorPulse.name      = "Color Pulse";
-    ColorPulse.value     = CORSAIR_CMDR_PRO_MODE_COLOR_PULSE;
-    ColorPulse.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    ColorPulse.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    ColorPulse.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    ColorPulse.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorPulse.name       = "Color Pulse";
+    ColorPulse.value      = CORSAIR_CMDR_PRO_MODE_COLOR_PULSE;
+    ColorPulse.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorPulse.colors_min = 2;
+    ColorPulse.colors_max = 2;
+    ColorPulse.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorPulse.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorPulse.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorPulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorPulse.colors.resize(2);
     modes.push_back(ColorPulse);
 
     mode ColorWave;
-    ColorWave.name      = "Color Wave";
-    ColorWave.value     = CORSAIR_CMDR_PRO_MODE_COLOR_WAVE;
-    ColorWave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    ColorWave.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    ColorWave.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    ColorWave.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
-    ColorWave.direction = MODE_DIRECTION_RIGHT;
+    ColorWave.name       = "Color Wave";
+    ColorWave.value      = CORSAIR_CMDR_PRO_MODE_COLOR_WAVE;
+    ColorWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorWave.colors_min = 2;
+    ColorWave.colors_max = 2;
+    ColorWave.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorWave.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorWave.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorWave.direction  = MODE_DIRECTION_RIGHT;
+    ColorWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorWave.colors.resize(2);
     modes.push_back(ColorWave);
 
     mode Static;
-    Static.name  = "Static";
-    Static.value = CORSAIR_CMDR_PRO_MODE_STATIC;
-    Static.flags = MODE_FLAG_HAS_COLOR;
+    Static.name       = "Static";
+    Static.value      = CORSAIR_CMDR_PRO_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min = 1;
+    Static.colors_max = 1;
+    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
     modes.push_back(Static);
 
     mode Temperature;
-    Temperature.name  = "Temperature";
-    Temperature.value = CORSAIR_CMDR_PRO_MODE_TEMPERATURE;
-    Temperature.flags = MODE_FLAG_HAS_COLOR;
+    Temperature.name       = "Temperature";
+    Temperature.value      = CORSAIR_CMDR_PRO_MODE_TEMPERATURE;
+    Temperature.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Temperature.colors_min = 3;
+    Temperature.colors_max = 3;
+    Temperature.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Temperature.colors.resize(3);
     modes.push_back(Temperature);
 
     mode Visor;
-    Visor.name      = "Visor";
-    Visor.value     = CORSAIR_CMDR_PRO_MODE_VISOR;
-    Visor.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Visor.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    Visor.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    Visor.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Visor.name       = "Visor";
+    Visor.value      = CORSAIR_CMDR_PRO_MODE_VISOR;
+    Visor.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Visor.colors_min = 2;
+    Visor.colors_max = 2;
+    Visor.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Visor.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Visor.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Visor.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Visor.colors.resize(2);
     modes.push_back(Visor);
 
     mode Marquee;
-    Marquee.name      = "Marquee";
-    Marquee.value     = CORSAIR_CMDR_PRO_MODE_MARQUEE;
-    Marquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Marquee.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    Marquee.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    Marquee.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
-    Marquee.direction = MODE_DIRECTION_RIGHT;
+    Marquee.name       = "Marquee";
+    Marquee.value      = CORSAIR_CMDR_PRO_MODE_MARQUEE;
+    Marquee.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Marquee.colors_min = 1;
+    Marquee.colors_max = 1;
+    Marquee.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Marquee.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Marquee.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Marquee.direction  = MODE_DIRECTION_RIGHT;
+    Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Marquee.colors.resize(1);
     modes.push_back(Marquee);
 
     mode Blink;
-    Blink.name      = "Blink";
-    Blink.value     = CORSAIR_CMDR_PRO_MODE_BLINK;
-    Blink.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Blink.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    Blink.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    Blink.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Blink.name       = "Blink";
+    Blink.value      = CORSAIR_CMDR_PRO_MODE_BLINK;
+    Blink.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Blink.colors_min = 2;
+    Blink.colors_max = 2;
+    Blink.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Blink.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Blink.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Blink.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Blink.colors.resize(2);
     modes.push_back(Blink);
 
     mode Sequential;
-    Sequential.name      = "Sequential";
-    Sequential.value     = CORSAIR_CMDR_PRO_MODE_SEQUENTIAL;
-    Sequential.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Sequential.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    Sequential.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    Sequential.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
-    Sequential.direction = MODE_DIRECTION_RIGHT;
+    Sequential.name       = "Sequential";
+    Sequential.value      = CORSAIR_CMDR_PRO_MODE_SEQUENTIAL;
+    Sequential.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Sequential.colors_min = 1;
+    Sequential.colors_max = 1;
+    Sequential.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Sequential.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Sequential.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Sequential.direction  = MODE_DIRECTION_RIGHT;
+    Sequential.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Sequential.colors.resize(1);
     modes.push_back(Sequential);
 
     mode Rainbow;
-    Rainbow.name      = "Rainbow";
-    Rainbow.value     = CORSAIR_CMDR_PRO_MODE_RAINBOW;
-    Rainbow.flags     = MODE_FLAG_HAS_SPEED;
-    Rainbow.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
-    Rainbow.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
-    Rainbow.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = CORSAIR_CMDR_PRO_MODE_RAINBOW;
+    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Rainbow.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Rainbow.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Rainbow.color_mode = MODE_COLORS_NONE;
     modes.push_back(Rainbow);
     
     /*-------------------------------------------------*\
@@ -240,7 +279,7 @@ void RGBController_CorsairNodePro::UpdateSingleLED(int led)
 
 void RGBController_CorsairNodePro::SetCustomMode()
 {
-    active_mode = 9;
+    active_mode = 0;
 }
 
 void RGBController_CorsairNodePro::UpdateMode()
@@ -254,23 +293,39 @@ void RGBController_CorsairNodePro::UpdateMode()
         for(int channel = 0; channel < CORSAIR_CMDR_PRO_NUM_CHANNELS; channel++)
         {
             unsigned int direction = 0;
+            bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
 
             if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
             {
                 direction = 1;
             }
 
+            unsigned char mode_colors[9];
+
+            if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+            {
+                for(int i = 0; i < modes[active_mode].colors.size(); i++)
+                {
+                    mode_colors[(3 * i) + 0] = RGBGetRValue(modes[active_mode].colors[i]);
+                    mode_colors[(3 * i) + 1] = RGBGetGValue(modes[active_mode].colors[i]);
+                    mode_colors[(3 * i) + 2] = RGBGetBValue(modes[active_mode].colors[i]);
+                }
+            }
+
             corsair->SetChannelEffect(channel,
                                       modes[active_mode].value,
                                       modes[active_mode].speed,
                                       direction,
-                                      modes[active_mode].random,
-                                      RGBGetRValue(colors[0]),
-                                      RGBGetGValue(colors[0]),
-                                      RGBGetBValue(colors[0]),
-                                      RGBGetRValue(colors[1]),
-                                      RGBGetGValue(colors[1]),
-                                      RGBGetBValue(colors[1]));
+                                      random,
+                                      mode_colors[0],
+                                      mode_colors[1],
+                                      mode_colors[2],
+                                      mode_colors[3],
+                                      mode_colors[4],
+                                      mode_colors[5],
+                                      mode_colors[6],
+                                      mode_colors[7],
+                                      mode_colors[8]);
         }
     }
-}
+}

RGBController/RGBController_CorsairPro.cpp

@@ -49,108 +49,129 @@ RGBController_CorsairPro::RGBController_CorsairPro(CorsairProController* corsair
     type = DEVICE_TYPE_DRAM;
 
     mode ColorShift;
-    ColorShift.name      = "Color Shift";
-    ColorShift.value     = CORSAIR_PRO_MODE_COLOR_SHIFT;
-    ColorShift.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    ColorShift.speed_min = CORSAIR_PRO_SPEED_SLOW;
-    ColorShift.speed_max = CORSAIR_PRO_SPEED_FAST;
-    ColorShift.random    = false;
-    ColorShift.speed     = CORSAIR_PRO_SPEED_SLOW;
+    ColorShift.name       = "Color Shift";
+    ColorShift.value      = CORSAIR_PRO_MODE_COLOR_SHIFT;
+    ColorShift.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorShift.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    ColorShift.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    ColorShift.colors_min = 2;
+    ColorShift.colors_max = 2;
+    ColorShift.speed      = CORSAIR_PRO_SPEED_SLOW;
+    ColorShift.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorShift.colors.resize(2);
     modes.push_back(ColorShift);
 
     mode ColorPulse;
-    ColorPulse.name      = "Color Pulse";
-    ColorPulse.value     = CORSAIR_PRO_MODE_COLOR_PULSE;
-    ColorPulse.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    ColorPulse.speed_min = CORSAIR_PRO_SPEED_SLOW;
-    ColorPulse.speed_max = CORSAIR_PRO_SPEED_FAST;
-    ColorPulse.random    = false;
-    ColorPulse.speed     = CORSAIR_PRO_SPEED_SLOW;
+    ColorPulse.name       = "Color Pulse";
+    ColorPulse.value      = CORSAIR_PRO_MODE_COLOR_PULSE;
+    ColorPulse.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorPulse.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    ColorPulse.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    ColorPulse.colors_min = 2;
+    ColorPulse.colors_max = 2;
+    ColorPulse.speed      = CORSAIR_PRO_SPEED_SLOW;
+    ColorPulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorPulse.colors.resize(2);
     modes.push_back(ColorPulse);
 
     mode RainbowWave;
-    RainbowWave.name      = "Rainbow Wave";
-    RainbowWave.value     = CORSAIR_PRO_MODE_RAINBOW_WAVE;
-    RainbowWave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
-    RainbowWave.speed_min = CORSAIR_PRO_SPEED_SLOW;
-    RainbowWave.speed_max = CORSAIR_PRO_SPEED_FAST;
-    RainbowWave.random    = false;
-    RainbowWave.speed     = CORSAIR_PRO_SPEED_SLOW;
-    RainbowWave.direction = MODE_DIRECTION_DOWN;
+    RainbowWave.name       = "Rainbow Wave";
+    RainbowWave.value      = CORSAIR_PRO_MODE_RAINBOW_WAVE;
+    RainbowWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    RainbowWave.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    RainbowWave.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    RainbowWave.speed      = CORSAIR_PRO_SPEED_SLOW;
+    RainbowWave.direction  = MODE_DIRECTION_DOWN;
+    RainbowWave.color_mode = MODE_COLORS_NONE;
     modes.push_back(RainbowWave);
 
     mode ColorWave;
-    ColorWave.name      = "Color Wave";
-    ColorWave.value     = CORSAIR_PRO_MODE_COLOR_WAVE;
-    ColorWave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    ColorWave.speed_min = CORSAIR_PRO_SPEED_SLOW;
-    ColorWave.speed_max = CORSAIR_PRO_SPEED_FAST;
-    ColorWave.random    = false;
-    ColorWave.speed     = CORSAIR_PRO_SPEED_SLOW;
-    ColorWave.direction = MODE_DIRECTION_DOWN;
+    ColorWave.name       = "Color Wave";
+    ColorWave.value      = CORSAIR_PRO_MODE_COLOR_WAVE;
+    ColorWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorWave.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    ColorWave.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    ColorWave.colors_min = 2;
+    ColorWave.colors_max = 2;
+    ColorWave.speed      = CORSAIR_PRO_SPEED_SLOW;
+    ColorWave.direction  = MODE_DIRECTION_DOWN;
+    ColorWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorWave.colors.resize(2);
     modes.push_back(ColorWave); 
     
     mode Visor;
-    Visor.name      = "Visor";
-    Visor.value     = CORSAIR_PRO_MODE_VISOR;
-    Visor.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Visor.speed_min = CORSAIR_PRO_SPEED_SLOW;
-    Visor.speed_max = CORSAIR_PRO_SPEED_FAST;
-    Visor.random    = false;
-    Visor.speed     = CORSAIR_PRO_SPEED_SLOW;
-    Visor.direction = MODE_DIRECTION_VERTICAL;
+    Visor.name       = "Visor";
+    Visor.value      = CORSAIR_PRO_MODE_VISOR;
+    Visor.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Visor.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    Visor.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    Visor.colors_min = 2;
+    Visor.colors_max = 2;
+    Visor.speed      = CORSAIR_PRO_SPEED_SLOW;
+    Visor.direction  = MODE_DIRECTION_VERTICAL;
+    Visor.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Visor.colors.resize(2);
     modes.push_back(Visor);
 
     mode Rain;
-    Rain.name      = "Rain";
-    Rain.value     = CORSAIR_PRO_MODE_RAIN;
-    Rain.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Rain.speed_min = CORSAIR_PRO_SPEED_SLOW;
-    Rain.speed_max = CORSAIR_PRO_SPEED_FAST;
-    Rain.random    = false;
-    Rain.speed     = CORSAIR_PRO_SPEED_SLOW;
-    Rain.direction = MODE_DIRECTION_DOWN;
+    Rain.name       = "Rain";
+    Rain.value      = CORSAIR_PRO_MODE_RAIN;
+    Rain.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Rain.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    Rain.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    Rain.colors_min = 2;
+    Rain.colors_max = 2;
+    Rain.speed      = CORSAIR_PRO_SPEED_SLOW;
+    Rain.direction  = MODE_DIRECTION_DOWN;
+    Rain.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Rain.colors.resize(2);
     modes.push_back(Rain);
 
     mode Marquee;
-    Marquee.name      = "Marquee";
-    Marquee.value     = CORSAIR_PRO_MODE_MARQUEE;
-    Marquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR;
-    Marquee.speed_min = CORSAIR_PRO_SPEED_SLOW;
-    Marquee.speed_max = CORSAIR_PRO_SPEED_FAST;
-    Marquee.random    = false;
-    Marquee.speed     = CORSAIR_PRO_SPEED_SLOW;
+    Marquee.name       = "Marquee";
+    Marquee.value      = CORSAIR_PRO_MODE_MARQUEE;
+    Marquee.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Marquee.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    Marquee.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    Marquee.colors_min = 1;
+    Marquee.colors_max = 1;
+    Marquee.speed      = CORSAIR_PRO_SPEED_SLOW;
+    Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Marquee.colors.resize(1);
     modes.push_back(Marquee);
     
     mode Rainbow;
-    Rainbow.name      = "Rainbow";
-    Rainbow.value     = CORSAIR_PRO_MODE_RAINBOW;
-    Rainbow.flags     = MODE_FLAG_HAS_SPEED;
-    Rainbow.speed_min = CORSAIR_PRO_SPEED_SLOW;
-    Rainbow.speed_max = CORSAIR_PRO_SPEED_FAST;
-    Rainbow.random    = false;
-    Rainbow.speed     = CORSAIR_PRO_SPEED_SLOW;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = CORSAIR_PRO_MODE_RAINBOW;
+    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    Rainbow.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    Rainbow.speed      = CORSAIR_PRO_SPEED_SLOW;
+    Rainbow.color_mode = MODE_COLORS_NONE;
     modes.push_back(Rainbow);
     
     mode Sequential;
-    Sequential.name      = "Sequential";
-    Sequential.value     = CORSAIR_PRO_MODE_SEQUENTIAL;
-    Sequential.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Sequential.speed_min = CORSAIR_PRO_SPEED_SLOW;
-    Sequential.speed_max = CORSAIR_PRO_SPEED_FAST;
-    Sequential.random    = false;
-    Sequential.speed     = CORSAIR_PRO_SPEED_SLOW;
-    Sequential.direction = MODE_DIRECTION_DOWN;
+    Sequential.name       = "Sequential";
+    Sequential.value      = CORSAIR_PRO_MODE_SEQUENTIAL;
+    Sequential.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Sequential.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    Sequential.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    Sequential.colors_min = 1;
+    Sequential.colors_max = 1;
+    Sequential.speed      = CORSAIR_PRO_SPEED_SLOW;
+    Sequential.direction  = MODE_DIRECTION_DOWN;
+    Sequential.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Sequential.colors.resize(1);
     modes.push_back(Sequential);
 
     mode Static;
-    Static.name      = "Static";
-    Static.value     = CORSAIR_PRO_MODE_STATIC;
-    Static.flags     = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Static.speed_min = 0;
-    Static.speed_max = 0;
-    Static.random    = false;
-    Static.speed     = 0;
+    Static.name       = "Static";
+    Static.value      = CORSAIR_PRO_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.speed_min  = 0;
+    Static.speed_max  = 0;
+    Static.speed      = 0;
+    Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     active_mode = 9;
@@ -191,6 +212,8 @@ void RGBController_CorsairPro::SetCustomMode()
 void RGBController_CorsairPro::UpdateMode()
 {
     unsigned int corsair_direction;
+    bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+    unsigned char mode_colors[6];
 
     switch(modes[active_mode].direction)
     {
@@ -214,14 +237,28 @@ void RGBController_CorsairPro::UpdateMode()
             break;
     }
 
+    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]);
+
+        if(modes[active_mode].colors.size() == 2)
+        {
+            mode_colors[3] = RGBGetRValue(modes[active_mode].colors[1]);
+            mode_colors[4] = RGBGetGValue(modes[active_mode].colors[1]);
+            mode_colors[5] = RGBGetBValue(modes[active_mode].colors[1]);
+        }
+    }
+
     corsair->SetEffect(modes[active_mode].value,
                        modes[active_mode].speed,
                        corsair_direction,
-                       modes[active_mode].random,
-                       RGBGetRValue(colors[0]),
-                       RGBGetGValue(colors[0]),
-                       RGBGetBValue(colors[0]),
-                       RGBGetRValue(colors[1]),
-                       RGBGetGValue(colors[1]),
-                       RGBGetBValue(colors[1]));
-}
+                       random,
+                       mode_colors[0],
+                       mode_colors[1],
+                       mode_colors[2],
+                       mode_colors[3],
+                       mode_colors[4],
+                       mode_colors[5]);
+}

RGBController/RGBController_Crucial.cpp

@@ -11,17 +11,24 @@
 
 void RGBController_Crucial::UpdateLEDs()
 {
-crucial->SetAllColorsDirect(&colors[0]);
+    if(modes[active_mode].value == 0xFFFF)
+    {
+        crucial->SetAllColorsDirect(&colors[0]);
+    }
+    else
+    {
+
+    }
 }
 
 void RGBController_Crucial::UpdateZoneLEDs(int zone)
 {
-crucial->SetAllColorsDirect(&colors[0]);
+    UpdateLEDs();
 }
 
 void RGBController_Crucial::UpdateSingleLED(int led)
 {
-crucial->SetAllColorsDirect(&colors[0]);
+    UpdateLEDs();
 }
 
 RGBController_Crucial::RGBController_Crucial(CrucialController * crucial_ptr)
@@ -32,28 +39,43 @@ RGBController_Crucial::RGBController_Crucial(CrucialController * crucial_ptr)
     type = DEVICE_TYPE_DRAM;
     name = "Crucial DRAM";
 
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0xFFFF;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+#if 0
     mode Shift;
-    Shift.name = "Shift";
-    Shift.value = CRUCIAL_MODE_SHIFT;
-    Shift.flags = 0;
+    Shift.name       = "Shift";
+    Shift.value      = CRUCIAL_MODE_SHIFT;
+    Shift.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Shift.colors_min = 1;
+    Shift.colors_max = 1;
+    Shift.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Shift.colors.resize(1);
     modes.push_back(Shift);
     
     mode GradientShift;
-    GradientShift.name = "Gradient Shift";
-    GradientShift.value = CRUCIAL_MODE_GRADIENT_SHIFT;
-    GradientShift.flags = 0;
+    GradientShift.name       = "Gradient Shift";
+    GradientShift.value      = CRUCIAL_MODE_GRADIENT_SHIFT;
+    GradientShift.flags      = 0;
+    GradientShift.color_mode = MODE_COLORS_NONE;
     modes.push_back(GradientShift);
 
     mode Fill;
-    Fill.name = "Fill";
-    Fill.value = CRUCIAL_MODE_FILL;
-    Fill.flags = 0;
+    Fill.name       = "Fill";
+    Fill.value      = CRUCIAL_MODE_FILL;
+    Fill.flags      = 0;
+    Fill.color_mode = MODE_COLORS_NONE;
     modes.push_back(Fill);
 
     mode Stack;
-    Stack.name = "Stack";
-    Stack.value = CRUCIAL_MODE_STACK;
-    Stack.flags = 0;
+    Stack.name       = "Stack";
+    Stack.value      = CRUCIAL_MODE_STACK;
+    Stack.flags      = 0;
+    Stack.color_mode = MODE_COLORS_NONE;
     modes.push_back(Stack);
 
     mode DoubleStack;
@@ -103,6 +125,7 @@ RGBController_Crucial::RGBController_Crucial(CrucialController * crucial_ptr)
     Static.value = CRUCIAL_MODE_STATIC;
     Static.flags = 0;
     modes.push_back(Static);
+#endif
 
     zone new_zone;
     new_zone.name = "DRAM";
@@ -134,4 +157,4 @@ void RGBController_Crucial::SetCustomMode()
 void RGBController_Crucial::UpdateMode()
 {
     crucial->SetMode(modes[active_mode].value);
-}
+}

RGBController/RGBController_E131.cpp

@@ -18,9 +18,13 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
     devices = device_list;
 
     unsigned int led_zone_idx = 0;
-    mode led_mode;
-    led_mode.name = "Custom";
-    modes.push_back(led_mode);
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
 
     sockfd = e131_socket();
 
@@ -172,4 +176,4 @@ void RGBController_E131::SetCustomMode()
 void RGBController_E131::UpdateMode()
 {
 
-}
+}

RGBController/RGBController_Faustus.cpp

@@ -10,34 +10,34 @@ RGBController_Faustus::RGBController_Faustus(const std::string& dev_path)
     type = DEVICE_TYPE_KEYBOARD;
 
     modes.resize(4);
-    modes[0].name   = "Static";
-    modes[0].value  = FAUSTUS_MODE_STATIC;
-    modes[0].flags  = MODE_FLAG_HAS_COLOR;
-    modes[0].random = false;
+    modes[0].name       = "Static";
+    modes[0].value      = FAUSTUS_MODE_STATIC;
+    modes[0].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[0].color_mode = MODE_COLORS_PER_LED;
 
-    modes[1].name      = "Breathing";
-    modes[1].value     = FAUSTUS_MODE_BREATHING;
-    modes[1].flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR;
-    modes[1].speed_min = FAUSTUS_SPEED_SLOWEST;
-    modes[1].speed_max = FAUSTUS_SPEED_FASTEST;
-    modes[1].random    = false;
-    modes[1].speed     = FAUSTUS_SPEED_NORMAL;
+    modes[1].name       = "Breathing";
+    modes[1].value      = FAUSTUS_MODE_BREATHING;
+    modes[1].flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[1].speed_min  = FAUSTUS_SPEED_SLOWEST;
+    modes[1].speed_max  = FAUSTUS_SPEED_FASTEST;
+    modes[1].color_mode = MODE_COLORS_PER_LED;
+    modes[1].speed      = FAUSTUS_SPEED_NORMAL;
 
-    modes[2].name      = "Color Cycle";
-    modes[2].value     = FAUSTUS_MODE_COLOR_CYCLE;
-    modes[2].flags     = MODE_FLAG_HAS_SPEED;
-    modes[2].speed_min = FAUSTUS_SPEED_SLOWEST;
-    modes[2].speed_max = FAUSTUS_SPEED_FASTEST;
-    modes[2].random    = false;
-    modes[2].speed     = FAUSTUS_SPEED_NORMAL;
+    modes[2].name       = "Color Cycle";
+    modes[2].value      = FAUSTUS_MODE_COLOR_CYCLE;
+    modes[2].flags      = MODE_FLAG_HAS_SPEED;
+    modes[2].speed_min  = FAUSTUS_SPEED_SLOWEST;
+    modes[2].speed_max  = FAUSTUS_SPEED_FASTEST;
+    modes[2].color_mode = MODE_COLORS_NONE;
+    modes[2].speed      = FAUSTUS_SPEED_NORMAL;
 
-    modes[3].name      = "Strobe";
-    modes[3].value     = FAUSTUS_MODE_STROBE;
-    modes[3].flags     = MODE_FLAG_HAS_SPEED;
-    modes[3].speed_min = FAUSTUS_SPEED_SLOWEST;
-    modes[3].speed_max = FAUSTUS_SPEED_FASTEST;
-    modes[3].random    = false;
-    modes[3].speed     = FAUSTUS_SPEED_NORMAL;
+    modes[3].name       = "Strobe";
+    modes[3].value      = FAUSTUS_MODE_STROBE;
+    modes[3].flags      = MODE_FLAG_HAS_SPEED;
+    modes[3].speed_min  = FAUSTUS_SPEED_SLOWEST;
+    modes[3].speed_max  = FAUSTUS_SPEED_FASTEST;
+    modes[3].color_mode = MODE_COLORS_NONE;
+    modes[3].speed      = FAUSTUS_SPEED_NORMAL;
 
     colors.resize(1);
     leds.resize(1);

RGBController/RGBController_Hue2.cpp

@@ -18,76 +18,102 @@ RGBController_Hue2::RGBController_Hue2(Hue2Controller* hue2_ptr)
     type = DEVICE_TYPE_LEDSTRIP;
     
     mode Direct;
-    Direct.name  = "Direct";
-    Direct.value = HUE_2_MODE_FIXED;
-    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Direct.name       = "Direct";
+    Direct.value      = HUE_2_MODE_FIXED;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Fading;
-    Fading.name      = "Fading";
-    Fading.value     = HUE_2_MODE_FADING;
-    Fading.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Fading.speed_min = HUE_2_SPEED_SLOWEST;
-    Fading.speed_max = HUE_2_SPEED_FASTEST;
-    Fading.speed     = HUE_2_SPEED_NORMAL;
+    Fading.name       = "Fading";
+    Fading.value      = HUE_2_MODE_FADING;
+    Fading.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Fading.speed_min  = HUE_2_SPEED_SLOWEST;
+    Fading.speed_max  = HUE_2_SPEED_FASTEST;
+    Fading.colors_min = 1;
+    Fading.colors_max = 8;
+    Fading.speed      = HUE_2_SPEED_NORMAL;
+    Fading.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Fading.colors.resize(1);
     modes.push_back(Fading);
 
     mode SpectrumCycle;
-    SpectrumCycle.name      = "Spectrum Cycle";
-    SpectrumCycle.value     = HUE_2_MODE_SPECTRUM;
-    SpectrumCycle.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    SpectrumCycle.speed_min = HUE_2_SPEED_SLOWEST;
-    SpectrumCycle.speed_max = HUE_2_SPEED_FASTEST;
-    SpectrumCycle.speed     = HUE_2_SPEED_NORMAL;
-    SpectrumCycle.direction = MODE_DIRECTION_RIGHT;
+    SpectrumCycle.name       = "Spectrum Cycle";
+    SpectrumCycle.value      = HUE_2_MODE_SPECTRUM;
+    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    SpectrumCycle.speed_min  = HUE_2_SPEED_SLOWEST;
+    SpectrumCycle.speed_max  = HUE_2_SPEED_FASTEST;
+    SpectrumCycle.speed      = HUE_2_SPEED_NORMAL;
+    SpectrumCycle.direction  = MODE_DIRECTION_RIGHT;
+    SpectrumCycle.color_mode = MODE_COLORS_NONE;
     modes.push_back(SpectrumCycle);
 
     mode Marquee;
-    Marquee.name      = "Marquee";
-    Marquee.value     = HUE_2_MODE_MARQUEE;
-    Marquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Marquee.speed_min = HUE_2_SPEED_SLOWEST;
-    Marquee.speed_max = HUE_2_SPEED_FASTEST;
-    Marquee.speed     = HUE_2_SPEED_NORMAL;
-    Marquee.direction = MODE_DIRECTION_RIGHT;
+    Marquee.name       = "Marquee";
+    Marquee.value      = HUE_2_MODE_MARQUEE;
+    Marquee.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Marquee.speed_min  = HUE_2_SPEED_SLOWEST;
+    Marquee.speed_max  = HUE_2_SPEED_FASTEST;
+    Marquee.colors_min = 1;
+    Marquee.colors_max = 1;
+    Marquee.speed      = HUE_2_SPEED_NORMAL;
+    Marquee.direction  = MODE_DIRECTION_RIGHT;
+    Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Marquee.colors.resize(1);
     modes.push_back(Marquee);
 
     mode CoverMarquee;
-    CoverMarquee.name      = "Cover Marquee";
-    CoverMarquee.value     = HUE_2_MODE_COVER_MARQUEE;
-    CoverMarquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    CoverMarquee.speed_min = HUE_2_SPEED_SLOWEST;
-    CoverMarquee.speed_max = HUE_2_SPEED_FASTEST;
-    CoverMarquee.speed     = HUE_2_SPEED_NORMAL;
-    CoverMarquee.direction = MODE_DIRECTION_RIGHT;
+    CoverMarquee.name       = "Cover Marquee";
+    CoverMarquee.value      = HUE_2_MODE_COVER_MARQUEE;
+    CoverMarquee.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    CoverMarquee.speed_min  = HUE_2_SPEED_SLOWEST;
+    CoverMarquee.speed_max  = HUE_2_SPEED_FASTEST;
+    CoverMarquee.colors_min = 1;
+    CoverMarquee.colors_max = 8;
+    CoverMarquee.speed      = HUE_2_SPEED_NORMAL;
+    CoverMarquee.direction  = MODE_DIRECTION_RIGHT;
+    CoverMarquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    CoverMarquee.colors.resize(1);
     modes.push_back(CoverMarquee);
 
     mode Alternating;
-    Alternating.name      = "Alternating";
-    Alternating.value     = HUE_2_MODE_ALTERNATING;
-    Alternating.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Alternating.speed_min = HUE_2_SPEED_SLOWEST;
-    Alternating.speed_max = HUE_2_SPEED_FASTEST;
-    Alternating.speed     = HUE_2_SPEED_NORMAL;
-    Alternating.direction = MODE_DIRECTION_RIGHT;
+    Alternating.name       = "Alternating";
+    Alternating.value      = HUE_2_MODE_ALTERNATING;
+    Alternating.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Alternating.speed_min  = HUE_2_SPEED_SLOWEST;
+    Alternating.speed_max  = HUE_2_SPEED_FASTEST;
+    Alternating.colors_min = 1;
+    Alternating.colors_max = 2;
+    Alternating.speed      = HUE_2_SPEED_NORMAL;
+    Alternating.direction  = MODE_DIRECTION_RIGHT;
+    Alternating.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Alternating.colors.resize(1);
     modes.push_back(Alternating);
 
     mode Pulsing;
-    Pulsing.name      = "Pulsing";
-    Pulsing.value     = HUE_2_MODE_PULSING;
-    Pulsing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Pulsing.speed_min = HUE_2_SPEED_SLOWEST;
-    Pulsing.speed_max = HUE_2_SPEED_FASTEST;
-    Pulsing.speed     = HUE_2_SPEED_NORMAL;
+    Pulsing.name       = "Pulsing";
+    Pulsing.value      = HUE_2_MODE_PULSING;
+    Pulsing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Pulsing.speed_min  = HUE_2_SPEED_SLOWEST;
+    Pulsing.speed_max  = HUE_2_SPEED_FASTEST;
+    Pulsing.colors_min = 1;
+    Pulsing.colors_max = 8;
+    Pulsing.speed      = HUE_2_SPEED_NORMAL;
+    Pulsing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Pulsing.colors.resize(1);
     modes.push_back(Pulsing);
 
     mode Breathing;
-    Breathing.name      = "Breathing";
-    Breathing.value     = HUE_2_MODE_BREATHING;
-    Breathing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Breathing.speed_min = HUE_2_SPEED_SLOWEST;
-    Breathing.speed_max = HUE_2_SPEED_FASTEST;
-    Breathing.speed     = HUE_2_SPEED_NORMAL;
+    Breathing.name       = "Breathing";
+    Breathing.value      = HUE_2_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.speed_min  = HUE_2_SPEED_SLOWEST;
+    Breathing.speed_max  = HUE_2_SPEED_FASTEST;
+    Breathing.colors_min = 1;
+    Breathing.colors_max = 8;
+    Breathing.speed      = HUE_2_SPEED_NORMAL;
+    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(1);
     modes.push_back(Breathing);
 
     /*-------------------------------------------------*\
@@ -238,7 +264,22 @@ void RGBController_Hue2::UpdateMode()
             }
 
             hue2->SetMode(modes[active_mode].value, modes[active_mode].speed, direction);
-            hue2->SetChannelLEDs(channel, channel_colors);
+
+            if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
+            {
+                hue2->SetChannelLEDs(channel, channel_colors);
+            }
+            else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+            {
+                hue2->SetChannelLEDs(channel, modes[active_mode].colors);
+            }
+            else if(modes[active_mode].color_mode == MODE_COLORS_NONE)
+            {
+                std::vector<RGBColor> temp_colors;
+                temp_colors.push_back(0x00000000);
+
+                hue2->SetChannelLEDs(channel, temp_colors);
+            }
         }
     }
-}
+}

RGBController/RGBController_HuePlus.cpp

@@ -20,109 +20,143 @@ RGBController_HuePlus::RGBController_HuePlus(HuePlusController* hueplus_ptr)
     location = hueplus->GetLocation();
     
     mode Direct;
-    Direct.name  = "Direct";
-    Direct.value = HUE_PLUS_MODE_FIXED;
-    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Direct.name       = "Direct";
+    Direct.value      = HUE_PLUS_MODE_FIXED;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
-// Fading mode is currently disabled because it doesn't appear to work
-//    mode Fading;
-//    Fading.name      = "Fading";
-//    Fading.value     = HUE_PLUS_MODE_FADING;
-//    Fading.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-//    Fading.speed_min = HUE_PLUS_SPEED_SLOWEST;
-//    Fading.speed_max = HUE_PLUS_SPEED_FASTEST;
-//    Fading.speed     = HUE_PLUS_SPEED_NORMAL;
-//    modes.push_back(Fading);
+    mode Fading;
+    Fading.name       = "Fading";
+    Fading.value      = HUE_PLUS_MODE_FADING;
+    Fading.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Fading.speed_min  = HUE_PLUS_SPEED_SLOWEST;
+    Fading.speed_max  = HUE_PLUS_SPEED_FASTEST;
+    Fading.colors_min = 1;
+    Fading.colors_max = 8;
+    Fading.speed      = HUE_PLUS_SPEED_NORMAL;
+    Fading.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Fading.colors.resize(2);
+    modes.push_back(Fading);
 
     mode SpectrumCycle;
-    SpectrumCycle.name      = "Spectrum Cycle";
-    SpectrumCycle.value     = HUE_PLUS_MODE_SPECTRUM;
-    SpectrumCycle.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    SpectrumCycle.speed_min = HUE_PLUS_SPEED_SLOWEST;
-    SpectrumCycle.speed_max = HUE_PLUS_SPEED_FASTEST;
-    SpectrumCycle.speed     = HUE_PLUS_SPEED_NORMAL;
-    SpectrumCycle.direction = MODE_DIRECTION_RIGHT;
+    SpectrumCycle.name       = "Spectrum Cycle";
+    SpectrumCycle.value      = HUE_PLUS_MODE_SPECTRUM;
+    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    SpectrumCycle.speed_min  = HUE_PLUS_SPEED_SLOWEST;
+    SpectrumCycle.speed_max  = HUE_PLUS_SPEED_FASTEST;
+    SpectrumCycle.speed      = HUE_PLUS_SPEED_NORMAL;
+    SpectrumCycle.direction  = MODE_DIRECTION_RIGHT;
+    SpectrumCycle.color_mode = MODE_COLORS_NONE;
     modes.push_back(SpectrumCycle);
 
     mode Marquee;
-    Marquee.name      = "Marquee";
-    Marquee.value     = HUE_PLUS_MODE_MARQUEE;
-    Marquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Marquee.speed_min = HUE_PLUS_SPEED_SLOWEST;
-    Marquee.speed_max = HUE_PLUS_SPEED_FASTEST;
-    Marquee.speed     = HUE_PLUS_SPEED_NORMAL;
-    Marquee.direction = MODE_DIRECTION_RIGHT;
+    Marquee.name       = "Marquee";
+    Marquee.value      = HUE_PLUS_MODE_MARQUEE;
+    Marquee.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Marquee.speed_min  = HUE_PLUS_SPEED_SLOWEST;
+    Marquee.speed_max  = HUE_PLUS_SPEED_FASTEST;
+    Marquee.colors_min = 1;
+    Marquee.colors_max = 1;
+    Marquee.speed      = HUE_PLUS_SPEED_NORMAL;
+    Marquee.direction  = MODE_DIRECTION_RIGHT;
+    Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Marquee.colors.resize(1);
     modes.push_back(Marquee);
 
     mode CoverMarquee;
-    CoverMarquee.name      = "Cover Marquee";
-    CoverMarquee.value     = HUE_PLUS_MODE_COVER_MARQUEE;
-    CoverMarquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    CoverMarquee.speed_min = HUE_PLUS_SPEED_SLOWEST;
-    CoverMarquee.speed_max = HUE_PLUS_SPEED_FASTEST;
-    CoverMarquee.speed     = HUE_PLUS_SPEED_NORMAL;
-    CoverMarquee.direction = MODE_DIRECTION_RIGHT;
+    CoverMarquee.name       = "Cover Marquee";
+    CoverMarquee.value      = HUE_PLUS_MODE_COVER_MARQUEE;
+    CoverMarquee.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    CoverMarquee.speed_min  = HUE_PLUS_SPEED_SLOWEST;
+    CoverMarquee.speed_max  = HUE_PLUS_SPEED_FASTEST;
+    CoverMarquee.colors_min = 1;
+    CoverMarquee.colors_max = 8;
+    CoverMarquee.speed      = HUE_PLUS_SPEED_NORMAL;
+    CoverMarquee.direction  = MODE_DIRECTION_RIGHT;
+    CoverMarquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    CoverMarquee.colors.resize(2);
     modes.push_back(CoverMarquee);
 
     mode Alternating;
-    Alternating.name      = "Alternating";
-    Alternating.value     = HUE_PLUS_MODE_ALTERNATING;
-    Alternating.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Alternating.speed_min = HUE_PLUS_SPEED_SLOWEST;
-    Alternating.speed_max = HUE_PLUS_SPEED_FASTEST;
-    Alternating.speed     = HUE_PLUS_SPEED_NORMAL;
-    Alternating.direction = MODE_DIRECTION_RIGHT;
+    Alternating.name       = "Alternating";
+    Alternating.value      = HUE_PLUS_MODE_ALTERNATING;
+    Alternating.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Alternating.speed_min  = HUE_PLUS_SPEED_SLOWEST;
+    Alternating.speed_max  = HUE_PLUS_SPEED_FASTEST;
+    Alternating.colors_min = 1;
+    Alternating.colors_max = 2;
+    Alternating.speed      = HUE_PLUS_SPEED_NORMAL;
+    Alternating.direction  = MODE_DIRECTION_RIGHT;
+    Alternating.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Alternating.colors.resize(2);
     modes.push_back(Alternating);
 
     mode Pulsing;
-    Pulsing.name      = "Pulsing";
-    Pulsing.value     = HUE_PLUS_MODE_PULSING;
-    Pulsing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Pulsing.speed_min = HUE_PLUS_SPEED_SLOWEST;
-    Pulsing.speed_max = HUE_PLUS_SPEED_FASTEST;
-    Pulsing.speed     = HUE_PLUS_SPEED_NORMAL;
+    Pulsing.name       = "Pulsing";
+    Pulsing.value      = HUE_PLUS_MODE_PULSING;
+    Pulsing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Pulsing.speed_min  = HUE_PLUS_SPEED_SLOWEST;
+    Pulsing.speed_max  = HUE_PLUS_SPEED_FASTEST;
+    Pulsing.colors_min = 1;
+    Pulsing.colors_max = 8;
+    Pulsing.speed      = HUE_PLUS_SPEED_NORMAL;
+    Pulsing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Pulsing.colors.resize(2);
     modes.push_back(Pulsing);
 
     mode Breathing;
-    Breathing.name      = "Breathing";
-    Breathing.value     = HUE_PLUS_MODE_BREATHING;
-    Breathing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Breathing.speed_min = HUE_PLUS_SPEED_SLOWEST;
-    Breathing.speed_max = HUE_PLUS_SPEED_FASTEST;
-    Breathing.speed     = HUE_PLUS_SPEED_NORMAL;
+    Breathing.name       = "Breathing";
+    Breathing.value      = HUE_PLUS_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.speed_min  = HUE_PLUS_SPEED_SLOWEST;
+    Breathing.speed_max  = HUE_PLUS_SPEED_FASTEST;
+    Breathing.colors_min = 1;
+    Breathing.colors_max = 8;
+    Breathing.speed      = HUE_PLUS_SPEED_NORMAL;
+    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(2);
     modes.push_back(Breathing);
 
     mode Alert;
-    Alert.name  = "Alert";
-    Alert.value = HUE_PLUS_MODE_ALERT;
-    Alert.flags = 0;
+    Alert.name       = "Alert";
+    Alert.value      = HUE_PLUS_MODE_ALERT;
+    Alert.flags      = 0;
+    Alert.color_mode = MODE_COLORS_NONE;
     modes.push_back(Alert);
 
     mode Candlelight;
-    Candlelight.name  = "Candlelight";
-    Candlelight.value = HUE_PLUS_MODE_CANDLELIGHT;
-    Candlelight.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Candlelight.name       = "Candlelight";
+    Candlelight.value      = HUE_PLUS_MODE_CANDLELIGHT;
+    Candlelight.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Candlelight.colors_min = 1;
+    Candlelight.colors_max = 1;
+    Candlelight.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Candlelight.colors.resize(1);
     modes.push_back(Candlelight);
 
     mode Wings;
-    Wings.name      = "Wings";
-    Wings.value     = HUE_PLUS_MODE_WINGS;
-    Wings.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Wings.speed_min = HUE_PLUS_SPEED_SLOWEST;
-    Wings.speed_max = HUE_PLUS_SPEED_FASTEST;
-    Wings.speed     = HUE_PLUS_SPEED_NORMAL;
+    Wings.name       = "Wings";
+    Wings.value      = HUE_PLUS_MODE_WINGS;
+    Wings.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Wings.speed_min  = HUE_PLUS_SPEED_SLOWEST;
+    Wings.speed_max  = HUE_PLUS_SPEED_FASTEST;
+    Wings.colors_min = 1;
+    Wings.colors_max = 1;
+    Wings.speed      = HUE_PLUS_SPEED_NORMAL;
+    Wings.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Wings.colors.resize(1);
     modes.push_back(Wings);
 
-// Wave mode is currently disabled because it doesn't appear to work
-//    mode Wave;
-//    Wave.name      = "Wave";
-//    Wave.value     = HUE_PLUS_MODE_WAVE;
-//    Wave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-//    Wave.speed_min = HUE_PLUS_SPEED_SLOWEST;
-//    Wave.speed_max = HUE_PLUS_SPEED_FASTEST;
-//    Wave.speed     = HUE_PLUS_SPEED_NORMAL;
-//    modes.push_back(Wave);
+    mode Wave;
+    Wave.name       = "Wave";
+    Wave.value      = HUE_PLUS_MODE_WAVE;
+    Wave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Wave.speed_min  = HUE_PLUS_SPEED_SLOWEST;
+    Wave.speed_max  = HUE_PLUS_SPEED_FASTEST;
+    Wave.speed      = HUE_PLUS_SPEED_NORMAL;
+    Wave.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Wave);
 
     /*-------------------------------------------------*\
     | Set size of colors array                          |
@@ -272,7 +306,23 @@ void RGBController_HuePlus::UpdateMode()
             }
 
             hueplus->SetMode(modes[active_mode].value, modes[active_mode].speed, direction);
-            hueplus->SetChannelLEDs(channel, channel_colors);
+
+
+            if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
+            {
+                hueplus->SetChannelLEDs(channel, channel_colors);
+            }
+            else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+            {
+                hueplus->SetModeColors(channel, modes[active_mode].colors);
+            }
+            else if(modes[active_mode].color_mode == MODE_COLORS_NONE)
+            {
+                std::vector<RGBColor> temp_colors;
+                temp_colors.push_back(0x00000000);
+
+                hueplus->SetModeColors(channel, temp_colors);
+            }
         }
     }
-}
+}

RGBController/RGBController_HyperX.cpp

@@ -92,83 +92,105 @@ RGBController_HyperX::RGBController_HyperX(HyperXController* hyperx_ptr)
     type = DEVICE_TYPE_DRAM;
 
     mode Direct;
-    Direct.name  = "Direct";
-    Direct.value = HYPERX_MODE_DIRECT;
-    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Direct.name       = "Direct";
+    Direct.value      = HYPERX_MODE_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 = HYPERX_MODE_STATIC;
-    Static.flags = MODE_FLAG_HAS_COLOR;
+    Static.name       = "Static";
+    Static.value      = HYPERX_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min = 1;
+    Static.colors_max = 1;
+    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
     modes.push_back(Static);
 
     mode Rainbow;
-    Rainbow.name      = "Rainbow";
-    Rainbow.value     = HYPERX_MODE_RAINBOW;
-    Rainbow.flags     = MODE_FLAG_HAS_SPEED;
-    Rainbow.speed_min = HYPERX_SPEED_RAINBOW_SLOW;
-    Rainbow.speed_max = HYPERX_SPEED_RAINBOW_FAST;
-    Rainbow.speed     = HYPERX_SPEED_RAINBOW_NORMAL;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = HYPERX_MODE_RAINBOW;
+    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min  = HYPERX_SPEED_RAINBOW_SLOW;
+    Rainbow.speed_max  = HYPERX_SPEED_RAINBOW_FAST;
+    Rainbow.speed      = HYPERX_SPEED_RAINBOW_NORMAL;
+    Rainbow.color_mode = MODE_COLORS_NONE;
     modes.push_back(Rainbow);
 
     mode Comet;
-    Comet.name      = "Comet";
-    Comet.value     = HYPERX_MODE_COMET;
-    Comet.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Comet.speed_min = HYPERX_SPEED_COMET_SLOW;
-    Comet.speed_max = HYPERX_SPEED_COMET_FAST;
-    Comet.random    = false;
-    Comet.speed     = HYPERX_SPEED_COMET_NORMAL;
+    Comet.name       = "Comet";
+    Comet.value      = HYPERX_MODE_COMET;
+    Comet.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Comet.speed_min  = HYPERX_SPEED_COMET_SLOW;
+    Comet.speed_max  = HYPERX_SPEED_COMET_FAST;
+    Comet.colors_min = 1;
+    Comet.colors_max = 1;
+    Comet.speed      = HYPERX_SPEED_COMET_NORMAL;
+    Comet.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Comet.colors.resize(1);
     modes.push_back(Comet);
 
     mode Heartbeat;
-    Heartbeat.name      = "Heartbeat";
-    Heartbeat.value     = HYPERX_MODE_HEARTBEAT;
-    Heartbeat.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Heartbeat.speed_min = HYPERX_SPEED_COMET_SLOW;
-    Heartbeat.speed_max = HYPERX_SPEED_COMET_FAST;
-    Heartbeat.random    = false;
-    Heartbeat.speed     = HYPERX_SPEED_COMET_NORMAL;
+    Heartbeat.name       = "Heartbeat";
+    Heartbeat.value      = HYPERX_MODE_HEARTBEAT;
+    Heartbeat.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Heartbeat.speed_min  = HYPERX_SPEED_COMET_SLOW;
+    Heartbeat.speed_max  = HYPERX_SPEED_COMET_FAST;
+    Heartbeat.colors_min = 1;
+    Heartbeat.colors_max = 1;
+    Heartbeat.speed      = HYPERX_SPEED_COMET_NORMAL;
+    Heartbeat.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Heartbeat.colors.resize(1);
     modes.push_back(Heartbeat);
 
     mode SpectrumCycle;
-    SpectrumCycle.name      = "Spectrum Cycle";
-    SpectrumCycle.value     = HYPERX_MODE_CYCLE;
-    SpectrumCycle.flags     = MODE_FLAG_HAS_SPEED;
-    SpectrumCycle.speed_min = HYPERX_SPEED_CYCLE_SLOW;
-    SpectrumCycle.speed_max = HYPERX_SPEED_CYCLE_FAST;
-    SpectrumCycle.speed     = HYPERX_SPEED_CYCLE_NORMAL;
+    SpectrumCycle.name       = "Spectrum Cycle";
+    SpectrumCycle.value      = HYPERX_MODE_CYCLE;
+    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED;
+    SpectrumCycle.speed_min  = HYPERX_SPEED_CYCLE_SLOW;
+    SpectrumCycle.speed_max  = HYPERX_SPEED_CYCLE_FAST;
+    SpectrumCycle.speed      = HYPERX_SPEED_CYCLE_NORMAL;
+    SpectrumCycle.color_mode = MODE_COLORS_NONE;
     modes.push_back(SpectrumCycle);
     
     mode Breathing;
-    Breathing.name      = "Breathing";
-    Breathing.value     = HYPERX_MODE_BREATHING;
-    Breathing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Breathing.speed_min = HYPERX_SPEED_BREATHING_SLOW;
-    Breathing.speed_max = HYPERX_SPEED_BREATHING_FAST;
-    Breathing.random    = false;
-    Breathing.speed     = HYPERX_SPEED_BREATHING_NORMAL;
+    Breathing.name       = "Breathing";
+    Breathing.value      = HYPERX_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Breathing.speed_min  = HYPERX_SPEED_BREATHING_SLOW;
+    Breathing.speed_max  = HYPERX_SPEED_BREATHING_FAST;
+    Breathing.colors_min = 1;
+    Breathing.colors_max = 1;
+    Breathing.speed      = HYPERX_SPEED_BREATHING_NORMAL;
+    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(1);
     modes.push_back(Breathing);
 
     mode Bounce;
-    Bounce.name      = "Bounce";
-    Bounce.value     = HYPERX_MODE_BOUNCE;
-    Bounce.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Bounce.speed_min = HYPERX_SPEED_BOUNCE_SLOW;
-    Bounce.speed_max = HYPERX_SPEED_BOUNCE_FAST;
-    Bounce.random    = false;
-    Bounce.speed     = HYPERX_SPEED_BOUNCE_NORMAL;
+    Bounce.name       = "Bounce";
+    Bounce.value      = HYPERX_MODE_BOUNCE;
+    Bounce.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Bounce.speed_min  = HYPERX_SPEED_BOUNCE_SLOW;
+    Bounce.speed_max  = HYPERX_SPEED_BOUNCE_FAST;
+    Bounce.colors_min = 1;
+    Bounce.colors_max = 1;
+    Bounce.speed      = HYPERX_SPEED_BOUNCE_NORMAL;
+    Bounce.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Bounce.colors.resize(1);
     modes.push_back(Bounce);
 
     mode Blink;
-    Blink.name      = "Blink";
-    Blink.value     = HYPERX_MODE_BLINK;
-    Blink.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
-    Blink.speed_min = HYPERX_SPEED_BLINK_SLOW;
-    Blink.speed_max = HYPERX_SPEED_BLINK_FAST;
-    Blink.random    = false;
-    Blink.speed     = HYPERX_SPEED_BLINK_NORMAL;
+    Blink.name       = "Blink";
+    Blink.value      = HYPERX_MODE_BLINK;
+    Blink.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Blink.speed_min  = HYPERX_SPEED_BLINK_SLOW;
+    Blink.speed_max  = HYPERX_SPEED_BLINK_FAST;
+    Blink.colors_min = 1;
+    Blink.colors_max = 1;
+    Blink.speed      = HYPERX_SPEED_BLINK_NORMAL;
+    Blink.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Blink.colors.resize(1);
     modes.push_back(Blink);
 
     colors.resize(hyperx->GetLEDCount());
@@ -217,6 +239,17 @@ void RGBController_HyperX::SetCustomMode()
 
 void RGBController_HyperX::UpdateMode()
 {
-    hyperx->SetMode(modes[active_mode].value, modes[active_mode].random, modes[active_mode].speed);
+    bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+
+    hyperx->SetMode(modes[active_mode].value, random, modes[active_mode].speed);
+
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        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]);
+
+        hyperx->SetEffectColor(red, grn, blu);
+    }
 }
 

RGBController/RGBController_HyperXKeyboard.cpp

@@ -161,38 +161,41 @@ RGBController_HyperXKeyboard::RGBController_HyperXKeyboard(HyperXKeyboardControl
     type = DEVICE_TYPE_KEYBOARD;
 
     mode Direct;
-    Direct.name   = "Direct";
-    Direct.value  = HYPERX_MODE_STATIC;
-    Direct.flags  = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Direct.random = false;
+    Direct.name       = "Direct";
+    Direct.value      = HYPERX_MODE_STATIC;
+    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  = HYPERX_MODE_STATIC;
-    Static.flags  = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Static.random = false;
+    Static.name       = "Static";
+    Static.value      = HYPERX_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Wave;
-    Wave.name      = "Wave";
-    Wave.value     = HYPERX_MODE_WAVE;
-    Wave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Wave.speed_min = 0x00;
-    Wave.speed_max = 0x09;
-    Wave.random    = false;
-    Wave.speed     = 0x09;
-    Wave.direction = MODE_DIRECTION_LEFT;
+    Wave.name       = "Wave";
+    Wave.value      = HYPERX_MODE_WAVE;
+    Wave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Wave.speed_min  = 0x00;
+    Wave.speed_max  = 0x09;
+    Wave.color_mode = MODE_COLORS_NONE;
+    Wave.speed      = 0x09;
+    Wave.direction  = MODE_DIRECTION_LEFT;
     modes.push_back(Wave);
 
     mode Breathing;
-    Breathing.name = "Breathing";
-    Breathing.value = HYPERX_MODE_BREATHING;
-    Breathing.flags = MODE_FLAG_HAS_SPEED;
-    Breathing.speed_min = 0x00;
-    Breathing.speed_max = 0x09;
-    Breathing.random = false;
-    Breathing.speed = 0x09;
+    Breathing.name       = "Breathing";
+    Breathing.value      = HYPERX_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Breathing.speed_min  = 0x00;
+    Breathing.speed_max  = 0x09;
+    Breathing.colors_min = 1;
+    Breathing.colors_max = 2;
+    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed      = 0x09;
+    Breathing.colors.resize(2);
     modes.push_back(Breathing);
 
     colors.resize(126);
@@ -256,5 +259,13 @@ void RGBController_HyperXKeyboard::SetCustomMode()
 
 void RGBController_HyperXKeyboard::UpdateMode()
 {
-    hyperx->SetMode(modes[active_mode].value, modes[active_mode].direction, modes[active_mode].speed);
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        hyperx->SetMode(modes[active_mode].value, modes[active_mode].direction, modes[active_mode].speed, modes[active_mode].colors);
+    }
+    else
+    {
+        std::vector<RGBColor> temp_colors;
+        hyperx->SetMode(modes[active_mode].value, modes[active_mode].direction, modes[active_mode].speed, temp_colors);
+    }
 }

RGBController/RGBController_LEDStrip.cpp

@@ -18,9 +18,12 @@ RGBController_LEDStrip::RGBController_LEDStrip(LEDStripController* ledstrip_ptr)
 
     type = DEVICE_TYPE_LEDSTRIP;
 
-    mode led_mode;
-    led_mode.name = "Custom";
-    modes.push_back(led_mode);
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
 
     colors.resize(strip->num_leds);
     
@@ -70,4 +73,4 @@ void RGBController_LEDStrip::SetCustomMode()
 void RGBController_LEDStrip::UpdateMode()
 {
 
-}
+}

RGBController/RGBController_MSI3Zone.cpp

@@ -16,9 +16,12 @@ RGBController_MSI3Zone::RGBController_MSI3Zone(MSI3ZoneController* msi_ptr)
     name = "MSI 3-Zone Keyboard";
     type = DEVICE_TYPE_KEYBOARD;
 
-    mode led_mode;
-    led_mode.name = "Custom";
-    modes.push_back(led_mode);
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
 
     led left_led;
     left_led.name = "Keyboard Left";
@@ -87,4 +90,4 @@ void RGBController_MSI3Zone::SetCustomMode()
 void RGBController_MSI3Zone::UpdateMode()
 {
 
-}
+}

RGBController/RGBController_OpenRazer.cpp

@@ -12,7 +12,6 @@
 #include <fstream>
 #include <unistd.h>
 
-
 void RGBController_OpenRazer::UpdateLEDs()
 {
     switch(matrix_type)
@@ -81,7 +80,7 @@ void RGBController_OpenRazer::UpdateLEDs()
                 }
             }
             break;
-        
+#if 0
         case RAZER_TYPE_NOMATRIX:
             {
                 unsigned int output_array_size = 3;
@@ -107,6 +106,7 @@ void RGBController_OpenRazer::UpdateLEDs()
                 scroll_led_effect.flush();
             }
             break;
+#endif
     }
 }
 
@@ -120,59 +120,8 @@ void RGBController_OpenRazer::UpdateSingleLED(int led)
     UpdateLEDs();
 }
 
-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);
-}
-
-static std::string GetFirmwareVersionString(std::string dev_path)
-{
-    // Read firmware_version for firmware version string
-    std::string firm_ver_path = dev_path + "/firmware_version";
-    std::ifstream firm_ver_file;
-    std::string ret_str;
-
-    firm_ver_file.open(firm_ver_path);
-    std::getline(firm_ver_file, ret_str);
-    firm_ver_file.close();
-
-    return(ret_str);   
-}
-
-static std::string GetSerialNumberString(std::string dev_path)
-{
-    // Read device_serial for serial number string
-    std::string ser_num_path = dev_path + "/device_serial";
-    std::ifstream ser_num_file;
-    std::string ret_str;
-
-    ser_num_file.open(ser_num_path);
-    std::getline(ser_num_file, ret_str);
-    ser_num_file.close();
-
-    return(ret_str);    
-}
-
 void RGBController_OpenRazer::SetupMatrixDevice(std::string dev_path, unsigned int rows, unsigned int cols)
 {
-    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)
     {
         if(!matrix_effect_custom)
@@ -198,27 +147,60 @@ void RGBController_OpenRazer::SetupMatrixDevice(std::string dev_path, unsigned i
 
 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");
-
     matrix_type = RAZER_TYPE_NOMATRIX;
 }
 
+void RGBController_OpenRazer::OpenFunctions(std::string dev_path)
+{
+    device_type.open(                  dev_path + "/device_type");
+    device_serial.open(                dev_path + "/device_serial");
+    firmware_version.open(             dev_path + "/firmware_version");
+
+    matrix_custom_frame.open(          dev_path + "/matrix_custom_frame");
+    matrix_brightness.open(            dev_path + "/matrix_brightness");
+
+    matrix_effect_custom.open(         dev_path + "/matrix_effect_custom");
+    matrix_effect_none.open(           dev_path + "/matrix_effect_none");
+    matrix_effect_static.open(         dev_path + "/matrix_effect_static");
+    matrix_effect_breath.open(         dev_path + "/matrix_effect_breath");
+    matrix_effect_spectrum.open(       dev_path + "/matrix_effect_spectrum");
+    matrix_effect_reactive.open(       dev_path + "/matrix_effect_reactive");
+    matrix_effect_wave.open(           dev_path + "/matrix_effect_wave");
+
+    logo_led_brightness.open(          dev_path + "/logo_led_brightness");
+    logo_matrix_effect_none.open(      dev_path + "/logo_matrix_effect_none");
+    logo_matrix_effect_static.open(    dev_path + "/logo_matrix_effect_static");
+    logo_matrix_effect_spectrum.open(  dev_path + "/logo_matrix_effect_spectrum");
+    logo_matrix_effect_reactive.open(  dev_path + "/logo_matrix_effect_reactive");
+
+    scroll_led_brightness.open(        dev_path + "/scroll_led_brightness");
+    scroll_matrix_effect_none.open(    dev_path + "/scroll_matrix_effect_none");
+    scroll_matrix_effect_static.open(  dev_path + "/scroll_matrix_effect_static");
+    scroll_matrix_effect_spectrum.open(dev_path + "/scroll_matrix_effect_spectrum");
+    scroll_matrix_effect_reactive.open(dev_path + "/scroll_matrix_effect_reactive");
+
+    scroll_led_effect.open(            dev_path + "/scroll_led_effect");
+    scroll_led_rgb.open(               dev_path + "/scroll_led_rgb");
+}
+
 RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
 {
     unsigned int led_count = 0;
 
+    /*-----------------------------------------------------------------*\
+    | Open the OpenRazer device functions                               |
+    \*-----------------------------------------------------------------*/
+    OpenFunctions(dev_path);
+
     /*-----------------------------------------------------------------*\
     | Start device at -1.  This indicates the device was not detected   |
     \*-----------------------------------------------------------------*/
-    device = -1;
+    device_index = -1;
 
     /*-----------------------------------------------------------------*\
     | Get the device name from the OpenRazer driver                     |
     \*-----------------------------------------------------------------*/
-    name = GetDeviceTypeString(dev_path);
+    std::getline(device_type, name);
 
     /*-----------------------------------------------------------------*\
     | Set the description to indicate this is an OpenRazer device       |
@@ -233,12 +215,12 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
     /*-----------------------------------------------------------------*\
     | Get the serial number from the dev path                           |
     \*-----------------------------------------------------------------*/
-    serial = GetSerialNumberString(dev_path);
+    std::getline(device_serial, serial);
 
     /*-----------------------------------------------------------------*\
     | Get the firmware version from the dev path                        |
     \*-----------------------------------------------------------------*/
-    version = GetFirmwareVersionString(dev_path);
+    std::getline(firmware_version, version);
 
     /*-----------------------------------------------------------------*\
     | Loop through all known devices to look for a name match           |
@@ -250,7 +232,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
             /*---------------------------------------------------------*\
             | Set device ID                                             |
             \*---------------------------------------------------------*/
-            device = i;
+            device_index = i;
 
             /*---------------------------------------------------------*\
             | Set device type                                           |
@@ -260,19 +242,81 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
             /*---------------------------------------------------------*\
             | Initialize modes                                          |
             \*---------------------------------------------------------*/
-            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++)
+            if(matrix_effect_custom)
             {
-                modes.push_back(razer_modes[i]);
+                mode Custom;
+                Custom.name       = "Custom";
+                Custom.value      = RAZER_MODE_CUSTOM;
+                Custom.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+                Custom.color_mode = MODE_COLORS_PER_LED;
+                modes.push_back(Custom);
+            }
+
+            if(matrix_effect_none)
+            {
+                mode Off;
+                Off.name       = "Off";
+                Off.value      = RAZER_MODE_OFF;
+                Off.flags      = 0;
+                Off.color_mode = MODE_COLORS_NONE;
+                modes.push_back(Off);
+            }
+
+            if(matrix_effect_static)
+            {
+                mode Static;
+                Static.name       = "Static";
+                Static.value      = RAZER_MODE_STATIC;
+                Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+                Static.colors_min = 1;
+                Static.colors_max = 1;
+                Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+                Static.colors.resize(1);
+                modes.push_back(Static);
+            }
+
+            if(matrix_effect_breath)
+            {
+                mode Breathing;
+                Breathing.name       = "Breathing";
+                Breathing.value      = RAZER_MODE_BREATHING;
+                Breathing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+                Breathing.colors_min = 1;
+                Breathing.colors_max = 2;
+                Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+                Breathing.colors.resize(1);
+                modes.push_back(Breathing);
+            }
+
+            if(matrix_effect_spectrum)
+            {
+                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);
+            }
+
+            if(matrix_effect_wave)
+            {
+                mode Wave;
+                Wave.name       = "Wave";
+                Wave.value      = RAZER_MODE_WAVE;
+                Wave.flags      = MODE_FLAG_HAS_DIRECTION_LR;
+                Wave.direction  = MODE_DIRECTION_RIGHT;
+                Wave.color_mode = MODE_COLORS_NONE;
+                modes.push_back(Wave);
+            }
+
+            if(matrix_effect_reactive)
+            {
+                mode Reactive;
+                Reactive.name       = "Reactive";
+                Reactive.value      = RAZER_MODE_REACTIVE;
+                Reactive.flags      = 0;
+                Reactive.color_mode = MODE_COLORS_NONE;
+                modes.push_back(Reactive);
             }
             
             /*---------------------------------------------------------*\
@@ -332,49 +376,94 @@ void RGBController_OpenRazer::SetCustomMode()
 
 void RGBController_OpenRazer::UpdateMode()
 {
-    char update_value = 1;
+    char update_value[6];
+
+    update_value[0] = 1;
 
     switch(matrix_type)
     {
         case RAZER_TYPE_MATRIX_FRAME:
         case RAZER_TYPE_MATRIX_NOFRAME:
             {
-                switch(active_mode)
+                switch(modes[active_mode].value)
                 {
                     case RAZER_MODE_CUSTOM:
-                        matrix_effect_custom.write(&update_value, 1);
+                        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.write(update_value, 1);
                         matrix_effect_none.flush();
                         break;
 
                     case RAZER_MODE_STATIC:
+                        update_value[0] = RGBGetRValue(modes[RAZER_MODE_STATIC].colors[0]);
+                        update_value[1] = RGBGetGValue(modes[RAZER_MODE_STATIC].colors[0]);
+                        update_value[2] = RGBGetBValue(modes[RAZER_MODE_STATIC].colors[0]);
+                        matrix_effect_static.write(update_value, 3);
+                        matrix_effect_static.flush();
                         break;
 
                     case RAZER_MODE_BREATHING:
+                        switch(modes[RAZER_MODE_BREATHING].color_mode)
+                        {
+                            case MODE_COLORS_MODE_SPECIFIC:
+                                update_value[0] = RGBGetRValue(modes[RAZER_MODE_BREATHING].colors[0]);
+                                update_value[1] = RGBGetGValue(modes[RAZER_MODE_BREATHING].colors[0]);
+                                update_value[2] = RGBGetBValue(modes[RAZER_MODE_BREATHING].colors[0]);
+
+                                if(modes[RAZER_MODE_BREATHING].colors.size() == 2)
+                                {
+                                    update_value[3] = RGBGetRValue(modes[RAZER_MODE_BREATHING].colors[1]);
+                                    update_value[4] = RGBGetGValue(modes[RAZER_MODE_BREATHING].colors[1]);
+                                    update_value[5] = RGBGetBValue(modes[RAZER_MODE_BREATHING].colors[1]);
+
+                                    matrix_effect_breath.write(update_value, 6);
+                                    matrix_effect_breath.flush();
+                                }
+                                else
+                                {
+                                    matrix_effect_breath.write(update_value, 3);
+                                    matrix_effect_breath.flush();
+                                }
+                                break;
+
+                            case MODE_COLORS_RANDOM:
+                                matrix_effect_breath.write(update_value, 1);
+                                matrix_effect_breath.flush();
+                                break;
+                        }
                         break;
 
                     case RAZER_MODE_SPECTRUM_CYCLE:
-                        matrix_effect_spectrum.write(&update_value, 1);
+                        matrix_effect_spectrum.write(update_value, 1);
                         matrix_effect_spectrum.flush();
                         break;
-                    
+
                     case RAZER_MODE_WAVE:
-                        matrix_effect_wave.write(&update_value, 1);
+                        switch(modes[active_mode].direction)
+                        {
+                            case MODE_DIRECTION_LEFT:
+                                update_value[0] = '2';
+                                break;
+
+                            default:
+                                update_value[0] = '1';
+                                break;
+                        }
+                        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.write(update_value, 1);
                         matrix_effect_reactive.flush();
                         break;
                 }
             }
             break;
-
+#if 0
         case RAZER_TYPE_NOMATRIX:
             {
                 switch(active_mode)
@@ -396,5 +485,6 @@ void RGBController_OpenRazer::UpdateMode()
                         break;
                 }
             }
+#endif
     }
-}
+}

RGBController/RGBController_OpenRazer.h

@@ -10,890 +10,10 @@
 #pragma once
 
 #include "RGBController.h"
+#include "OpenRazerDevices.h"
+
 #include <fstream>
 
-#define RAZER_MAX_ZONES 6
-
-typedef struct
-{
-    std::string name;
-    unsigned int type;
-    unsigned int rows;
-    unsigned int cols;
-} razer_zone;
-
-typedef struct
-{
-    std::string name;
-    device_type type;
-    bool matrix_type;
-    unsigned int rows;
-    unsigned int cols;
-    const razer_zone* zones[RAZER_MAX_ZONES];
-} razer_device;
-
-/*-------------------------------------------------------------------------*\
-|  KEYBOARDS                                                                |
-\*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------*\
-|  Razer BlackWidow Chroma                                      |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       6 Rows, 22 Columns                                      |
-\*-------------------------------------------------------------*/
-static const razer_zone blackwidow_chroma_zone =
-{
-    "Keyboard",
-    ZONE_TYPE_MATRIX,
-    6,
-    22
-};
-
-static const razer_device blackwidow_chroma_device =
-{
-    "Razer BlackWidow Chroma",
-    DEVICE_TYPE_KEYBOARD,
-    true,
-    6,
-    22,
-    {
-        &blackwidow_chroma_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  Razer BlackWidow Chroma Tournament Edition                   |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       6 Rows, 22 Columns                                      |
-\*-------------------------------------------------------------*/
-static const razer_zone blackwidow_chroma_te_zone =
-{
-    "Keyboard",
-    ZONE_TYPE_MATRIX,
-    6,
-    22
-};
-
-static const razer_device blackwidow_chroma_te_device =
-{
-    "Razer BlackWidow Chroma Tournament Edition",
-    DEVICE_TYPE_KEYBOARD,
-    true,
-    6,
-    22,
-    {
-        &blackwidow_chroma_te_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Ornata Chroma                                          |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       6 Rows, 22 Columns                                      |
-\*-------------------------------------------------------------*/
-static const razer_zone ornata_chroma_zone =
-{
-    "Keyboard",
-    ZONE_TYPE_MATRIX,
-    6,
-    22
-};
-
-static const razer_device ornata_chroma_device =
-{
-    "Razer Ornata Chroma",
-    DEVICE_TYPE_KEYBOARD,
-    true,
-    6,
-    22,
-    {
-        &ornata_chroma_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  Razer DeathStalker Chroma                                    |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Linear                                                  |
-|       12 LEDs                                                 |
-\*-------------------------------------------------------------*/
-static const razer_zone deathstalker_chroma_zone =
-{
-    "Keyboard",
-    ZONE_TYPE_LINEAR,
-    1,
-    12
-};
-
-static const razer_device deathstalker_chroma_device =
-{
-    "Razer DeathStalker Chroma",
-    DEVICE_TYPE_KEYBOARD,
-    true,
-    1,
-    12,
-    {
-        &deathstalker_chroma_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------------------*\
-|  LAPTOPS                                                                  |
-\*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------*\
-|  Razer Blade Stealth                                          |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       6 Rows, 16 Columns                                      |
-\*-------------------------------------------------------------*/
-static const razer_zone blade_stealth_zone =
-{
-    "Keyboard",
-    ZONE_TYPE_MATRIX,
-    6,
-    16
-};
-
-static const razer_device blade_stealth_device =
-{
-    "Razer Blade Stealth",
-    DEVICE_TYPE_KEYBOARD,
-    true,
-    6,
-    16,
-    {
-        &blade_stealth_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Blade Pro (Late 2016)                                  |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       6 Rows, 25 Columns                                      |
-\*-------------------------------------------------------------*/
-static const razer_zone blade_pro_late_2016_zone =
-{
-    "Keyboard",
-    ZONE_TYPE_MATRIX,
-    6,
-    25
-};
-
-static const razer_device blade_pro_late_2016_device =
-{
-    "Razer Blade Pro (Late 2016)",
-    DEVICE_TYPE_KEYBOARD,
-    true,
-    6,
-    25,
-    {
-        &blade_pro_late_2016_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Blade Pro (2017)                                       |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       6 Rows, 25 Columns                                      |
-\*-------------------------------------------------------------*/
-static const razer_zone blade_pro_2017_zone =
-{
-    "Keyboard",
-    ZONE_TYPE_MATRIX,
-    6,
-    25
-};
-
-static const razer_device blade_pro_2017_device =
-{
-    "Razer Blade Pro (2017)",
-    DEVICE_TYPE_KEYBOARD,
-    true,
-    6,
-    25,
-    {
-        &blade_pro_2017_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------------------*\
-|  MICE                                                                     |
-\*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------*\
-|  Razer Mamba Tournament Edition                               |
-|                                                               |
-|  Zone "Left"                                                  |
-|       Linear                                                  |
-|       7 LEDs                                                  |
-|                                                               |
-|  Zone "Right"                                                 |
-|       Linear                                                  |
-|       7 LEDs                                                  |
-|                                                               |
-|  Zone "Logo"                                                  |
-|       Single                                                  |
-|       1 LED                                                   |
-|                                                               |
-|  Zone "Scroll Wheel"                                          |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone mamba_te_left_zone =
-{
-    "Left LED Strip",
-    ZONE_TYPE_LINEAR,
-    1,
-    7
-};
-
-static const razer_zone mamba_te_right_zone =
-{
-    "Right LED Strip",
-    ZONE_TYPE_LINEAR,
-    1,
-    7
-};
-
-static const razer_zone mamba_te_logo_zone =
-{
-    "Logo",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_zone mamba_te_scroll_wheel_zone =
-{
-    "Scroll Wheel",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device mamba_te_device =
-{
-    "Razer Mamba Tournament Edition",
-    DEVICE_TYPE_MOUSE,
-    true,
-    1,
-    16,
-    {
-        &mamba_te_left_zone,
-        &mamba_te_right_zone,
-        &mamba_te_logo_zone,
-        &mamba_te_scroll_wheel_zone,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Diamondback Chroma                                     |
-|                                                               |
-|  Zone "Right"                                                 |
-|       Linear                                                  |
-|       7 LEDs                                                  |
-|                                                               |
-|  Zone "Bottom"                                                |
-|       Linear                                                  |
-|       5 LEDs                                                  |
-|                                                               |
-|  Zone "Left"                                                  |
-|       Linear                                                  |
-|       7 LEDs                                                  |
-|                                                               |
-|  Zone "Logo"                                                  |
-|       Single                                                  |
-|       1 LED                                                   |
-|                                                               |
-|  Zone "Scroll Wheel"                                          |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone diamondback_chroma_right_zone =
-{
-    "Right LED Strip",
-    ZONE_TYPE_LINEAR,
-    1,
-    7
-};
-
-static const razer_zone diamondback_chroma_bottom_zone =
-{
-    "Bottom LED Strip",
-    ZONE_TYPE_LINEAR,
-    1,
-    5
-};
-
-static const razer_zone diamondback_chroma_left_zone =
-{
-    "Left LED Strip",
-    ZONE_TYPE_LINEAR,
-    1,
-    7
-};
-
-static const razer_zone diamondback_chroma_logo_zone =
-{
-    "Logo",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_zone diamondback_chroma_scroll_wheel_zone =
-{
-    "Scroll Wheel",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device diamondback_chroma_device =
-{
-    "Razer Diamondback Chroma",
-    DEVICE_TYPE_MOUSE,
-    true,
-    1,
-    21,
-    {
-        &diamondback_chroma_right_zone,
-        &diamondback_chroma_bottom_zone,
-        &diamondback_chroma_left_zone,
-        &diamondback_chroma_logo_zone,
-        &diamondback_chroma_scroll_wheel_zone,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  Razer DeathAdder Chroma                                      |
-|                                                               |
-|  Zone "Logo"                                                  |
-|       Single                                                  |
-|       1 LED                                                   |
-|                                                               |
-|  Zone "Scroll Wheel"                                          |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone deathadder_chroma_logo_zone =
-{
-    "Logo",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_zone deathadder_chroma_scroll_wheel_zone =
-{
-    "Scroll Wheel",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device deathadder_chroma_device =
-{
-    "Razer DeathAdder Chroma",
-    DEVICE_TYPE_MOUSE,
-    false,
-    1,
-    2,
-    {
-        &deathadder_chroma_logo_zone,
-        &deathadder_chroma_scroll_wheel_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Naga Chroma                                            |
-|                                                               |
-|  Zone "Logo"                                                  |
-|       Single                                                  |
-|       1 LED                                                   |
-|                                                               |
-|  Zone "Scroll Wheel"                                          |
-|       Single                                                  |
-|       1 LED                                                   |
-|                                                               |
-|  Zone "Numpad"                                                |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone naga_chroma_logo_zone =
-{
-    "Logo",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_zone naga_chroma_scroll_wheel_zone =
-{
-    "Scroll Wheel",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_zone naga_chroma_numpad_zone =
-{
-    "Numpad",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device naga_chroma_device =
-{
-    "Razer Naga Chroma",
-    DEVICE_TYPE_MOUSE,
-    false,
-    1,
-    3,
-    {
-        &naga_chroma_logo_zone,
-        &naga_chroma_scroll_wheel_zone,
-        &naga_chroma_numpad_zone,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------------------*\
-|  KEYPADS                                                                  |
-\*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------*\
-|  Razer Orbweaver Chroma                                       |
-|                                                               |
-|  Zone "Keypad"                                                |
-|       Matrix                                                  |
-|       4 Rows, 5 Columns                                       |
-\*-------------------------------------------------------------*/
-static const razer_zone orbweaver_chroma_zone =
-{
-    "Keypad",
-    ZONE_TYPE_MATRIX,
-    4,
-    5
-};
-
-static const razer_device orbweaver_chroma_device =
-{
-    "Razer Orbweaver Chroma",
-    DEVICE_TYPE_KEYBOARD,
-    true,
-    6,
-    25,
-    {
-        &orbweaver_chroma_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Tartarus Chroma                                        |
-|                                                               |
-|  Zone "Keypad"                                                |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone tartarus_chroma_zone =
-{
-    "Keypad",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device tartarus_chroma_device =
-{
-    "Razer Tartarus Chroma",
-    DEVICE_TYPE_KEYBOARD,
-    true,
-    1,
-    1,
-    {
-        &tartarus_chroma_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------------------*\
-|  MOUSEMATS                                                                |
-\*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------*\
-|  Razer Firefly                                                |
-|                                                               |
-|  Zone "LED Strip"                                             |
-|       Linear                                                  |
-|       15 LEDs                                                 |
-\*-------------------------------------------------------------*/
-static const razer_zone firefly_zone =
-{
-    "LED Strip",
-    ZONE_TYPE_LINEAR,
-    1,
-    15
-};
-
-static const razer_device firefly_device =
-{
-    "Razer Firefly",
-    DEVICE_TYPE_MOUSEMAT,
-    true,
-    1,
-    15,
-    {
-        &firefly_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Goliathus Extended                                     |
-|                                                               |
-|  Zone "LED Strip"                                             |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone goliathus_extended_zone =
-{
-    "LED Strip",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device goliathus_extended_device =
-{
-    "Razer Goliathus Extended",
-    DEVICE_TYPE_MOUSEMAT,
-    true,
-    1,
-    1,
-    {
-        &goliathus_extended_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------------------*\
-|  HEADSETS                                                                 |
-\*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------*\
-|  Razer Kraken 7.1 Chroma                                      |
-|                                                               |
-|  Zone "Headset"                                               |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone kraken_chroma_zone =
-{
-    "Headset",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device kraken_chroma_device =
-{
-    "Razer Kraken 7.1 Chroma",
-    DEVICE_TYPE_HEADSET,
-    true,
-    1,
-    1,
-    {
-        &kraken_chroma_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Kraken 7.1 V2                                          |
-|                                                               |
-|  Zone "Headset"                                               |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone kraken_v2_zone =
-{
-    "Headset",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device kraken_v2_device =
-{
-    "Razer Kraken 7.1 V2",
-    DEVICE_TYPE_HEADSET,
-    true,
-    1,
-    1,
-    {
-        &kraken_v2_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------------------*\
-|  OTHER                                                                    |
-\*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------*\
-|  Razer Core                                                   |
-|                                                               |
-|  Zone "Side Window Lights"                                    |
-|       Single                                                  |
-|       1 LED                                                   |
-|                                                               |
-|  Zone "LED Strip"                                             |
-|       Linear                                                  |
-|       8 LEDs                                                  |
-\*-------------------------------------------------------------*/
-static const razer_zone core_side_zone =
-{
-    "Side Window Lights",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_zone core_led_strip_zone =
-{
-    "LED Strip",
-    ZONE_TYPE_LINEAR,
-    1,
-    8
-};
-
-static const razer_device core_device =
-{
-    "Razer Core",
-    DEVICE_TYPE_UNKNOWN,
-    true,
-    1,
-    9,
-    {
-        &core_side_zone,
-        &core_led_strip_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Chroma Mug Holder                                      |
-|                                                               |
-|  Zone "LED Strip"                                             |
-|       Linear                                                  |
-|       15 LEDs                                                 |
-\*-------------------------------------------------------------*/
-static const razer_zone mug_holder_zone =
-{
-    "LED Strip",
-    ZONE_TYPE_LINEAR,
-    1,
-    15
-};
-
-static const razer_device mug_holder_device =
-{
-    "Razer Chroma Mug Holder",
-    DEVICE_TYPE_UNKNOWN,
-    true,
-    1,
-    15,
-    {
-        &mug_holder_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Chroma HDK                                             |
-|                                                               |
-|  Zone "LED Strip"                                             |
-|       Linear                                                  |
-|       16 LEDs                                                 |
-|                                                               |
-|  Zone "LED Strip"                                             |
-|       Linear                                                  |
-|       16 LEDs                                                 |
-|                                                               |
-|  Zone "LED Strip"                                             |
-|       Linear                                                  |
-|       16 LEDs                                                 |
-|                                                               |
-|  Zone "LED Strip"                                             |
-|       Linear                                                  |
-|       16 LEDs                                                 |
-\*-------------------------------------------------------------*/
-static const razer_zone chromahdk_zone =
-{
-    "LED Strip",
-    ZONE_TYPE_LINEAR,
-    1,
-    16
-};
-
-static const razer_device chromahdk_device =
-{
-    "Razer Chroma HDK",
-    DEVICE_TYPE_LEDSTRIP,
-    true,
-    4,
-    16,
-    {
-        &chromahdk_zone,
-        &chromahdk_zone,
-        &chromahdk_zone,
-        &chromahdk_zone,
-        NULL,
-        NULL
-    }
-};
-
-/*-------------------------------------------------------------------------*\
-|  DEVICE MASTER LIST                                                       |
-\*-------------------------------------------------------------------------*/
-#define RAZER_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const razer_device* device_list[] =
-{
-/*-----------------------------------------------------------------*\
-|  KEYBOARDS                                                        |
-\*-----------------------------------------------------------------*/
-    &blackwidow_chroma_device,
-    &blackwidow_chroma_te_device,
-    &ornata_chroma_device,
-    &deathstalker_chroma_device,
-/*-----------------------------------------------------------------*\
-|  LAPTOPS                                                          |
-\*-----------------------------------------------------------------*/
-    &blade_stealth_device,
-    &blade_pro_late_2016_device,
-    &blade_pro_2017_device,
-/*-----------------------------------------------------------------*\
-|  MICE                                                             |
-\*-----------------------------------------------------------------*/
-    &mamba_te_device,
-    &diamondback_chroma_device,
-    &deathadder_chroma_device,
-/*-----------------------------------------------------------------*\
-|  KEYPADS                                                          |
-\*-----------------------------------------------------------------*/
-    &orbweaver_chroma_device,
-    &tartarus_chroma_device,
-/*-----------------------------------------------------------------*\
-|  MOUSEMATS                                                        |
-\*-----------------------------------------------------------------*/
-    &firefly_device,
-    &goliathus_extended_device,
-/*-----------------------------------------------------------------*\
-|  HEADSETS                                                         |
-\*-----------------------------------------------------------------*/
-    &kraken_chroma_device,
-    &kraken_v2_device,
-/*-----------------------------------------------------------------*\
-|  OTHER                                                            |
-\*-----------------------------------------------------------------*/
-    &core_device,
-    &mug_holder_device,
-    &chromahdk_device
-};
-
-
 class RGBController_OpenRazer : public RGBController
 {
 public:
@@ -927,7 +47,7 @@ public:
     void        SetCustomMode();
     void        UpdateMode();
 
-    int device;
+    int device_index;
 
 private:
     void SetupMatrixDevice(std::string dev_path, unsigned int rows, unsigned int cols);
@@ -937,19 +57,35 @@ private:
     unsigned int matrix_rows;
     unsigned int matrix_cols;
 
-    //OpenRazer Sysfs Entries for Matrix Devices
+    void OpenFunctions(std::string dev_path);
+
+    std::ifstream device_type;
+    std::ifstream device_serial;
+    std::ifstream firmware_version;
+
     std::ofstream matrix_custom_frame;
+    std::ofstream matrix_brightness;
+
     std::ofstream matrix_effect_custom;
-    std::ofstream matrix_effect_breath;
     std::ofstream matrix_effect_none;
-    std::ofstream matrix_effect_reactive;
-    std::ofstream matrix_effect_spectrum;
     std::ofstream matrix_effect_static;
+    std::ofstream matrix_effect_breath;
+    std::ofstream matrix_effect_spectrum;
+    std::ofstream matrix_effect_reactive;
     std::ofstream matrix_effect_wave;
 
-    //OpenRazer Sysfs Entries for Non-Matrix Devices
-    std::ofstream logo_led_effect;
-    std::ofstream logo_led_rgb;
+    std::ofstream logo_led_brightness;
+    std::ofstream logo_matrix_effect_none;
+    std::ofstream logo_matrix_effect_static;
+    std::ofstream logo_matrix_effect_spectrum;
+    std::ofstream logo_matrix_effect_reactive;
+
+    std::ofstream scroll_led_brightness;
+    std::ofstream scroll_matrix_effect_none;
+    std::ofstream scroll_matrix_effect_static;
+    std::ofstream scroll_matrix_effect_spectrum;
+    std::ofstream scroll_matrix_effect_reactive;
+
     std::ofstream scroll_led_effect;
     std::ofstream scroll_led_rgb;
 };

RGBController/RGBController_OpenRazerWindows.cpp

@@ -0,0 +1,476 @@
+/*-----------------------------------------*\
+|  RGBController_OpenRazer.cpp              |
+|                                           |
+|  Generic RGB Interface for OpenRazer      |
+|  kernel drivers for Chroma peripherals    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/15/2019   |
+\*-----------------------------------------*/
+
+#include "RGBController_OpenRazerWindows.h"
+
+#include <algorithm>
+#include <fstream>
+#include <string.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/hid.h>
+
+void RGBController_OpenRazer::UpdateLEDs()
+{
+    switch(matrix_type)
+    {
+        case RAZER_TYPE_MATRIX_FRAME:
+        case RAZER_TYPE_MATRIX_NOFRAME:
+        case RAZER_TYPE_MATRIX_STATIC:
+            {
+                char update_value = 1;
+                
+                for (unsigned int row = 0; row < matrix_rows; row++)
+                {
+                    unsigned int output_array_size;
+                    unsigned int output_offset;
+                    unsigned int row_offset = (row * matrix_cols);
+
+                    if(matrix_type == RAZER_TYPE_MATRIX_FRAME)
+                    {
+                        output_array_size = 3 + (matrix_cols* 3);
+                        output_offset = 3;
+                    }
+                    else
+                    {
+                        output_array_size = 3;
+                        output_offset = 0;
+                    }
+                    
+                    char* output_array = new char[output_array_size];
+
+                    if(matrix_type == RAZER_TYPE_MATRIX_FRAME)
+                    {
+                        output_array[0] = row;
+                        output_array[1] = 0;
+                        output_array[2] = matrix_cols - 1;
+                    }
+
+                    for(unsigned int col = 0; col < matrix_cols; col++)
+                    {
+                        unsigned int color_idx = col + row_offset;
+                        output_array[(col * 3) + 0 + output_offset] = (char)RGBGetRValue(colors[color_idx]);
+                        output_array[(col * 3) + 1 + output_offset] = (char)RGBGetGValue(colors[color_idx]);
+                        output_array[(col * 3) + 2 + output_offset] = (char)RGBGetBValue(colors[color_idx]);
+                    }
+                    
+                    if(matrix_type == RAZER_TYPE_MATRIX_FRAME)
+                    {
+                        razer_functions->matrix_custom_frame->store(razer_device, NULL, output_array, output_array_size);
+                    }
+                    else if(matrix_type == RAZER_TYPE_MATRIX_NOFRAME)
+                    {
+                        razer_functions->matrix_effect_custom->store(razer_device, NULL, output_array, output_array_size);
+                    }
+                    else
+                    {
+                        razer_functions->matrix_effect_static->store(razer_device, NULL, output_array, output_array_size);
+                    }
+                }
+                
+                if(matrix_type == RAZER_TYPE_MATRIX_FRAME)
+                {
+                    razer_functions->matrix_effect_custom->store(razer_device, NULL, &update_value, 1);
+                }
+            }
+            break;
+        #if 0
+        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(colors[0]);
+                output_array[1] = (char)RGBGetGValue(colors[0]);
+                output_array[2] = (char)RGBGetBValue(colors[0]);
+                logo_led_rgb.write(output_array, output_array_size);
+
+                output_array[0] = (char)RGBGetRValue(colors[1]);
+                output_array[1] = (char)RGBGetGValue(colors[1]);
+                output_array[2] = (char)RGBGetBValue(colors[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;
+            #endif
+    }
+}
+
+void RGBController_OpenRazer::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_OpenRazer::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
+}
+
+void RGBController_OpenRazer::SetupMatrixDevice(device * razer_device, device_fn_type* razer_functions, unsigned int rows, unsigned int cols)
+{
+    if(!razer_functions->matrix_custom_frame)
+    {
+        if(!razer_functions->matrix_effect_custom)
+        {
+            matrix_type = RAZER_TYPE_MATRIX_STATIC;
+        }
+        else
+        {
+            matrix_type = RAZER_TYPE_MATRIX_NOFRAME;
+        }
+
+        matrix_rows = 1;
+        matrix_cols = 1;
+    }
+    else
+    {
+        matrix_type = RAZER_TYPE_MATRIX_FRAME;
+
+        matrix_rows = rows;
+        matrix_cols = cols;
+    }
+}
+
+void RGBController_OpenRazer::SetupNonMatrixDevice(device * razer_device, device_fn_type* razer_functions)
+{
+    matrix_type = RAZER_TYPE_NOMATRIX;
+}
+
+RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_fn_type* razer_functions)
+{
+    char string_buf[1024];
+    
+    this->razer_device = razer_device;
+    this->razer_functions = razer_functions;
+
+    unsigned int led_count = 0;
+
+    /*-----------------------------------------------------------------*\
+    | Initialize buffer                                                 |
+    \*-----------------------------------------------------------------*/
+    memset(string_buf, 0xFF, sizeof(string_buf));
+    string_buf[1023] = '\0';
+
+    /*-----------------------------------------------------------------*\
+    | Start device at -1.  This indicates the device was not detected   |
+    \*-----------------------------------------------------------------*/
+    device_index = -1;
+
+    /*-----------------------------------------------------------------*\
+    | Get the device name from the OpenRazer driver                     |
+    \*-----------------------------------------------------------------*/
+    razer_functions->device_type->show(razer_device, NULL, string_buf);
+    name = string_buf;
+    name.erase(std::remove(name.begin(), name.end(), '\n'), name.end());
+    name.erase(std::remove(name.begin(), name.end(), '\r'), name.end());
+    
+    /*-----------------------------------------------------------------*\
+    | Set the description to indicate this is an OpenRazer device       |
+    \*-----------------------------------------------------------------*/
+    description = "OpenRazer Device";
+
+    /*-----------------------------------------------------------------*\
+    | Set the device path as the location                               |
+    \*-----------------------------------------------------------------*/
+    location = "";
+
+    /*-----------------------------------------------------------------*\
+    | Initialize buffer                                                 |
+    \*-----------------------------------------------------------------*/
+    //memset(string_buf, 0xFF, sizeof(string_buf));
+    //string_buf[1023] = '\0';
+
+    /*-----------------------------------------------------------------*\
+    | Get the serial number from the dev path                           |
+    \*-----------------------------------------------------------------*/
+    //razer_functions->device_serial->show(razer_device, NULL, string_buf);
+    //serial = string_buf;
+
+    /*-----------------------------------------------------------------*\
+    | Initialize buffer                                                 |
+    \*-----------------------------------------------------------------*/
+    //memset(string_buf, 0xFF, sizeof(string_buf));
+    //string_buf[1023] = '\0';
+
+    /*-----------------------------------------------------------------*\
+    | Get the firmware version from the dev path                        |
+    \*-----------------------------------------------------------------*/
+    //razer_functions->firmware_version->show(razer_device, NULL, string_buf);
+    //version = string_buf;
+
+    /*-----------------------------------------------------------------*\
+    | Loop through all known devices to look for a name match           |
+    \*-----------------------------------------------------------------*/
+    for (unsigned int i = 0; i < RAZER_NUM_DEVICES; i++)
+    {
+        if (device_list[i]->name == name)
+        {
+            /*---------------------------------------------------------*\
+            | Set device ID                                             |
+            \*---------------------------------------------------------*/
+            device_index = i;
+
+            /*---------------------------------------------------------*\
+            | Set device type                                           |
+            \*---------------------------------------------------------*/
+            type = device_list[i]->type;
+
+            /*---------------------------------------------------------*\
+            | Initialize modes                                          |
+            \*---------------------------------------------------------*/
+            if(razer_functions->matrix_effect_custom)
+            {
+                mode Custom;
+                Custom.name       = "Custom";
+                Custom.value      = RAZER_MODE_CUSTOM;
+                Custom.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+                Custom.color_mode = MODE_COLORS_PER_LED;
+                modes.push_back(Custom);
+            }
+
+            if(razer_functions->matrix_effect_none)
+            {
+                mode Off;
+                Off.name       = "Off";
+                Off.value      = RAZER_MODE_OFF;
+                Off.flags      = 0;
+                Off.color_mode = MODE_COLORS_NONE;
+                modes.push_back(Off);
+            }
+
+            if(razer_functions->matrix_effect_static)
+            {
+                mode Static;
+                Static.name       = "Static";
+                Static.value      = RAZER_MODE_STATIC;
+                Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+                Static.colors_min = 1;
+                Static.colors_max = 1;
+                Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+                Static.colors.resize(1);
+                modes.push_back(Static);
+            }
+
+            if(razer_functions->matrix_effect_breath)
+            {
+                mode Breathing;
+                Breathing.name       = "Breathing";
+                Breathing.value      = RAZER_MODE_BREATHING;
+                Breathing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+                Breathing.colors_min = 1;
+                Breathing.colors_max = 2;
+                Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+                Breathing.colors.resize(2);
+                modes.push_back(Breathing);
+            }
+
+            if(razer_functions->matrix_effect_spectrum)
+            {
+                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);
+            }
+
+            if(razer_functions->matrix_effect_wave)
+            {
+                mode Wave;
+                Wave.name       = "Wave";
+                Wave.value      = RAZER_MODE_WAVE;
+                Wave.flags      = MODE_FLAG_HAS_DIRECTION_LR;
+                Wave.direction  = MODE_DIRECTION_RIGHT;
+                Wave.color_mode = MODE_COLORS_NONE;
+                modes.push_back(Wave);
+            }
+
+            if(razer_functions->matrix_effect_reactive)
+            {
+                mode Reactive;
+                Reactive.name       = "Reactive";
+                Reactive.value      = RAZER_MODE_REACTIVE;
+                Reactive.flags      = 0;
+                Reactive.color_mode = MODE_COLORS_NONE;
+                modes.push_back(Reactive);
+            }
+
+            /*---------------------------------------------------------*\
+            | Initialize file descriptors                               |
+            \*---------------------------------------------------------*/
+            if(device_list[i]->matrix_type == true)
+            {
+                SetupMatrixDevice(razer_device, razer_functions, device_list[i]->rows, device_list[i]->cols);    
+            }
+            else
+            {
+                SetupNonMatrixDevice(razer_device, razer_functions);
+            }
+            
+            /*---------------------------------------------------------*\
+            | Fill in zone information based on device table            |
+            \*---------------------------------------------------------*/
+            for (int zone_id = 0; zone_id < RAZER_MAX_ZONES; zone_id++)
+            {
+                if (device_list[i]->zones[zone_id] != NULL)
+                {
+                    zone new_zone;
+                    new_zone.name = device_list[i]->zones[zone_id]->name;
+                    new_zone.type = device_list[i]->zones[zone_id]->type;
+
+                    for (unsigned int row_id = 0; row_id < device_list[i]->zones[zone_id]->rows; row_id++)
+                    {
+                        std::vector<int> new_zone_map;
+
+                        for (unsigned int col_id = 0; col_id < device_list[i]->zones[zone_id]->cols; col_id++)
+                        {
+                            char id_buf[8];
+                            snprintf(id_buf, 8, "%d", col_id + 1);
+
+                            RGBColor new_color = 0x00000000;
+                            colors.push_back(new_color);
+
+                            led* new_led = new led();
+                            new_led->name = device_list[i]->zones[zone_id]->name + " LED ";
+                            new_led->name.append(id_buf);
+                            leds.push_back(*new_led);
+
+                            new_zone_map.push_back(led_count);
+
+                            led_count++;
+                        }
+
+                        new_zone.map.push_back(new_zone_map);
+                    }
+                    zones.push_back(new_zone);
+                }
+            }
+        }
+    }
+
+}
+
+void RGBController_OpenRazer::SetCustomMode()
+{
+    SetMode(RAZER_MODE_CUSTOM);
+}
+
+void RGBController_OpenRazer::UpdateMode()
+{
+    char update_value[6];
+
+    update_value[0] = 1;
+
+    switch(matrix_type)
+    {
+        case RAZER_TYPE_MATRIX_FRAME:
+        case RAZER_TYPE_MATRIX_NOFRAME:
+            {
+                switch(modes[active_mode].value)
+                {
+                    case RAZER_MODE_CUSTOM:
+                        razer_functions->matrix_effect_custom->store(razer_device, NULL, update_value, 1);
+                        break;
+
+                    case RAZER_MODE_OFF:
+                        razer_functions->matrix_effect_none->store(razer_device, NULL, update_value, 1);
+                        break;
+
+                    case RAZER_MODE_STATIC:
+                        update_value[0] = RGBGetRValue(modes[RAZER_MODE_STATIC].colors[0]);
+                        update_value[1] = RGBGetGValue(modes[RAZER_MODE_STATIC].colors[0]);
+                        update_value[2] = RGBGetBValue(modes[RAZER_MODE_STATIC].colors[0]);
+                        razer_functions->matrix_effect_static->store(razer_device, NULL, update_value, 3);
+                        break;
+
+                    case RAZER_MODE_BREATHING:
+                        switch(modes[RAZER_MODE_BREATHING].color_mode)
+                        {
+                            case MODE_COLORS_MODE_SPECIFIC:
+                                update_value[0] = RGBGetRValue(modes[RAZER_MODE_BREATHING].colors[0]);
+                                update_value[1] = RGBGetGValue(modes[RAZER_MODE_BREATHING].colors[0]);
+                                update_value[2] = RGBGetBValue(modes[RAZER_MODE_BREATHING].colors[0]);
+
+                                if(modes[RAZER_MODE_BREATHING].colors.size() == 2)
+                                {
+                                    update_value[3] = RGBGetRValue(modes[RAZER_MODE_BREATHING].colors[1]);
+                                    update_value[4] = RGBGetGValue(modes[RAZER_MODE_BREATHING].colors[1]);
+                                    update_value[5] = RGBGetBValue(modes[RAZER_MODE_BREATHING].colors[1]);
+
+                                    razer_functions->matrix_effect_breath->store(razer_device, NULL, update_value, 6);
+                                }
+                                else
+                                {
+                                    razer_functions->matrix_effect_breath->store(razer_device, NULL, update_value, 3);
+                                }
+                                break;
+
+                            case MODE_COLORS_RANDOM:
+                                razer_functions->matrix_effect_breath->store(razer_device, NULL, update_value, 1);
+                                break;
+                        }
+                        break;
+
+                    case RAZER_MODE_SPECTRUM_CYCLE:
+                        razer_functions->matrix_effect_spectrum->store(razer_device, NULL, update_value, 1);
+                        break;
+
+                    case RAZER_MODE_WAVE:
+                        switch(modes[active_mode].direction)
+                        {
+                            case MODE_DIRECTION_LEFT:
+                                update_value[0] = '2';
+                                break;
+                            
+                            default:
+                                update_value[0] = '1';
+                                break;
+                        }
+                        razer_functions->matrix_effect_wave->store(razer_device, NULL, update_value, 1);
+                        break;
+
+                    case RAZER_MODE_REACTIVE:
+                        razer_functions->matrix_effect_reactive->store(razer_device, NULL, update_value, 1);
+                        break;
+                }
+            }
+            break;
+#if 0
+        case RAZER_TYPE_NOMATRIX:
+            {
+                switch(modes[active_mode].value)
+                {
+                    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;
+                }
+            }
+#endif
+    }
+}

RGBController/RGBController_OpenRazerWindows.h

@@ -0,0 +1,112 @@
+/*-----------------------------------------*\
+|  RGBController_OpenRazerWindows.h         |
+|                                           |
+|  Generic RGB Interface for OpenRazer      |
+|  kernel drivers for Chroma peripherals    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/15/2019   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include "OpenRazerDevices.h"
+
+#include <fstream>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/hid.h>
+
+typedef struct
+{
+    struct device_attribute *   device_type;
+    struct device_attribute *   device_serial;
+    struct device_attribute *   firmware_version;
+
+    struct device_attribute *   matrix_custom_frame;
+    struct device_attribute *   matrix_brightness;
+
+    struct device_attribute *   matrix_effect_custom;
+    struct device_attribute *   matrix_effect_none;
+    struct device_attribute *   matrix_effect_static;
+    struct device_attribute *   matrix_effect_breath;
+    struct device_attribute *   matrix_effect_spectrum;
+    struct device_attribute *   matrix_effect_reactive;
+    struct device_attribute *   matrix_effect_wave;
+
+    struct device_attribute *   logo_led_brightness;
+    struct device_attribute *   logo_matrix_effect_none;
+    struct device_attribute *   logo_matrix_effect_static;
+    struct device_attribute *   logo_matrix_effect_spectrum;
+    struct device_attribute *   logo_matrix_effect_reactive;
+
+    struct device_attribute *   scroll_led_brightness;
+    struct device_attribute *   scroll_matrix_effect_none;
+    struct device_attribute *   scroll_matrix_effect_static;
+    struct device_attribute *   scroll_matrix_effect_spectrum;
+    struct device_attribute *   scroll_matrix_effect_reactive;
+
+    struct device_attribute *   scroll_led_effect;
+    struct device_attribute *   scroll_led_rgb;
+} device_fn_type;
+
+class RGBController_OpenRazer : public RGBController
+{
+public:
+    enum
+    {
+        RAZER_MODE_CUSTOM,
+        RAZER_MODE_OFF,
+        RAZER_MODE_STATIC,
+        RAZER_MODE_BREATHING,
+        RAZER_MODE_SPECTRUM_CYCLE,
+        RAZER_MODE_WAVE,
+        RAZER_MODE_REACTIVE,
+        RAZER_NUM_MODES
+    };
+
+    enum
+    {
+        RAZER_TYPE_MATRIX_FRAME,
+        RAZER_TYPE_MATRIX_NOFRAME,
+        RAZER_TYPE_MATRIX_STATIC,
+        RAZER_TYPE_NOMATRIX,
+        RAZER_NUM_TYPES
+    };
+
+public:
+    RGBController_OpenRazer(device * razer_device, device_fn_type* razer_functions);
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+    int device_index;
+
+private:
+    void SetupMatrixDevice(device * razer_device, device_fn_type* razer_functions, unsigned int rows, unsigned int cols);
+    void SetupNonMatrixDevice(device * razer_device, device_fn_type* razer_functions);
+
+    unsigned int matrix_type;
+    unsigned int matrix_rows;
+    unsigned int matrix_cols;
+
+    device* razer_device;
+    device_fn_type* razer_functions;
+
+    //OpenRazer Sysfs Entries for Matrix Devices
+    std::ofstream matrix_custom_frame;
+    std::ofstream matrix_effect_custom;
+    std::ofstream matrix_effect_breath;
+    std::ofstream matrix_effect_none;
+    std::ofstream matrix_effect_reactive;
+    std::ofstream matrix_effect_spectrum;
+    std::ofstream matrix_effect_static;
+    std::ofstream matrix_effect_wave;
+
+    //OpenRazer Sysfs Entries for Non-Matrix Devices
+    std::ofstream logo_led_effect;
+    std::ofstream logo_led_rgb;
+    std::ofstream scroll_led_effect;
+    std::ofstream scroll_led_rgb;
+};

RGBController/RGBController_PatriotViper.cpp

@@ -67,83 +67,83 @@ RGBController_PatriotViper::RGBController_PatriotViper(PatriotViperController* v
     type = DEVICE_TYPE_DRAM;
 
     mode Direct;
-    Direct.name      = "Direct";
-    Direct.value     = 0xFFFF;
-    Direct.flags     = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Direct.speed_min = 0;
-    Direct.speed_max = 0;
-    Direct.random    = false;
-    Direct.speed     = 0;
+    Direct.name       = "Direct";
+    Direct.value      = 0xFFFF;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.speed_min  = 0;
+    Direct.speed_max  = 0;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.speed      = 0;
     modes.push_back(Direct);
 
     mode Dark;
-    Dark.name      = "Dark";
-    Dark.value     = VIPER_MODE_DARK;
-    Dark.flags     = 0;
-    Dark.speed_min = 0;
-    Dark.speed_max = 0;
-    Dark.random    = false;
-    Dark.speed     = 0;
+    Dark.name       = "Dark";
+    Dark.value      = VIPER_MODE_DARK;
+    Dark.flags      = 0;
+    Dark.speed_min  = 0;
+    Dark.speed_max  = 0;
+    Dark.color_mode = MODE_COLORS_NONE;
+    Dark.speed      = 0;
     modes.push_back(Dark);
 
     mode Breathing;
-    Breathing.name      = "Breathing";
-    Breathing.value     = VIPER_MODE_BREATHING;
-    Breathing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Breathing.speed_min = VIPER_SPEED_BREATHING_MIN;
-    Breathing.speed_max = VIPER_SPEED_BREATHING_MAX;
-    Breathing.random    = false;
-    Breathing.speed     = VIPER_SPEED_BREATHING_DEFAULT;
+    Breathing.name       = "Breathing";
+    Breathing.value      = VIPER_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.speed_min  = VIPER_SPEED_BREATHING_MIN;
+    Breathing.speed_max  = VIPER_SPEED_BREATHING_MAX;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
+    Breathing.speed      = VIPER_SPEED_BREATHING_DEFAULT;
     modes.push_back(Breathing);
 
     mode Viper;
-    Viper.name      = "Viper";
-    Viper.value     = VIPER_MODE_VIPER;
-    Viper.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Viper.speed_min = VIPER_SPEED_MIN;
-    Viper.speed_max = VIPER_SPEED_MAX;
-    Viper.random    = false;
-    Viper.speed     = VIPER_SPEED_DEFAULT;
+    Viper.name       = "Viper";
+    Viper.value      = VIPER_MODE_VIPER;
+    Viper.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Viper.speed_min  = VIPER_SPEED_MIN;
+    Viper.speed_max  = VIPER_SPEED_MAX;
+    Viper.color_mode = MODE_COLORS_PER_LED;
+    Viper.speed      = VIPER_SPEED_DEFAULT;
     modes.push_back(Viper);
 
     mode Heartbeat;
-    Heartbeat.name      = "Heartbeat";
-    Heartbeat.value     = VIPER_MODE_HEARTBEAT;
-    Heartbeat.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Heartbeat.speed_min = VIPER_SPEED_MIN;
-    Heartbeat.speed_max = VIPER_SPEED_MAX;
-    Heartbeat.random    = false;
-    Heartbeat.speed     = VIPER_SPEED_DEFAULT;
+    Heartbeat.name       = "Heartbeat";
+    Heartbeat.value      = VIPER_MODE_HEARTBEAT;
+    Heartbeat.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Heartbeat.speed_min  = VIPER_SPEED_MIN;
+    Heartbeat.speed_max  = VIPER_SPEED_MAX;
+    Heartbeat.color_mode = MODE_COLORS_PER_LED;
+    Heartbeat.speed      = VIPER_SPEED_DEFAULT;
     modes.push_back(Heartbeat);
 
     mode Marquee;
-    Marquee.name      = "Marquee";
-    Marquee.value     = VIPER_MODE_MARQUEE;
-    Marquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Marquee.speed_min = VIPER_SPEED_MIN;
-    Marquee.speed_max = VIPER_SPEED_MAX;
-    Marquee.random    = false;
-    Marquee.speed     = VIPER_SPEED_DEFAULT;
+    Marquee.name       = "Marquee";
+    Marquee.value      = VIPER_MODE_MARQUEE;
+    Marquee.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Marquee.speed_min  = VIPER_SPEED_MIN;
+    Marquee.speed_max  = VIPER_SPEED_MAX;
+    Marquee.color_mode = MODE_COLORS_PER_LED;
+    Marquee.speed      = VIPER_SPEED_DEFAULT;
     modes.push_back(Marquee);
 
     mode Raindrop;
-    Raindrop.name      = "Raindrop";
-    Raindrop.value     = VIPER_MODE_RAINDROP;
-    Raindrop.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Raindrop.speed_min = VIPER_SPEED_MIN;
-    Raindrop.speed_max = VIPER_SPEED_MAX;
-    Raindrop.random    = false;
-    Raindrop.speed     = VIPER_SPEED_DEFAULT;
+    Raindrop.name       = "Raindrop";
+    Raindrop.value      = VIPER_MODE_RAINDROP;
+    Raindrop.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Raindrop.speed_min  = VIPER_SPEED_MIN;
+    Raindrop.speed_max  = VIPER_SPEED_MAX;
+    Raindrop.color_mode = MODE_COLORS_PER_LED;
+    Raindrop.speed      = VIPER_SPEED_DEFAULT;
     modes.push_back(Raindrop);
 
     mode Aurora;
-    Aurora.name      = "Aurora";
-    Aurora.value     = VIPER_MODE_AURORA;
-    Aurora.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Aurora.speed_min = VIPER_SPEED_MIN;
-    Aurora.speed_max = VIPER_SPEED_MAX;
-    Aurora.random    = false;
-    Aurora.speed     = VIPER_SPEED_DEFAULT;
+    Aurora.name       = "Aurora";
+    Aurora.value      = VIPER_MODE_AURORA;
+    Aurora.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Aurora.speed_min  = VIPER_SPEED_MIN;
+    Aurora.speed_max  = VIPER_SPEED_MAX;
+    Aurora.color_mode = MODE_COLORS_PER_LED;
+    Aurora.speed      = VIPER_SPEED_DEFAULT;
     modes.push_back(Aurora);
 
     colors.resize(viper->GetLEDCount());
@@ -199,4 +199,4 @@ void RGBController_PatriotViper::UpdateMode()
     {
         viper->SetMode(modes[active_mode].value, modes[active_mode].speed);
     }
-}
+}

RGBController/RGBController_Polychrome.cpp

@@ -46,137 +46,159 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
     if(polychrome->IsAsrLed())
     {
         mode Off;
-        Off.name = "Off";
-        Off.value = ASRLED_MODE_OFF;
-        Off.flags = 0;
+        Off.name       = "Off";
+        Off.value      = ASRLED_MODE_OFF;
+        Off.flags      = 0;
+        Off.color_mode = MODE_COLORS_NONE;
         modes.push_back(Off);
 
         mode Static;
-        Static.name = "Static";
-        Static.value = ASRLED_MODE_STATIC;
-        Static.flags = MODE_FLAG_HAS_COLOR;
+        Static.name       = "Static";
+        Static.value      = ASRLED_MODE_STATIC;
+        Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+        Static.color_mode = MODE_COLORS_PER_LED;
         modes.push_back(Static);
 
         mode Breathing;
-        Breathing.name = "Breathing";
-        Breathing.value = ASRLED_MODE_BREATHING;
-        Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR;
+        Breathing.name       = "Breathing";
+        Breathing.value      = ASRLED_MODE_BREATHING;
+        Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+        Breathing.color_mode = MODE_COLORS_PER_LED;
         modes.push_back(Breathing);
 
         mode Strobe;
-        Strobe.name = "Strobe";
-        Strobe.value = ASRLED_MODE_FLASHING;
-        Strobe.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR;
+        Strobe.name       = "Strobe";
+        Strobe.value      = ASRLED_MODE_FLASHING;
+        Strobe.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+        Strobe.color_mode = MODE_COLORS_PER_LED;
         modes.push_back(Strobe);
 
         mode SpectrumCycle;
-        SpectrumCycle.name = "Spectrum Cycle";
-        SpectrumCycle.value = ASRLED_MODE_SPECTRUM_CYCLE;
-        SpectrumCycle.flags = MODE_FLAG_HAS_SPEED;
+        SpectrumCycle.name       = "Spectrum Cycle";
+        SpectrumCycle.value      = ASRLED_MODE_SPECTRUM_CYCLE;
+        SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED;
+        SpectrumCycle.color_mode = MODE_COLORS_NONE;
         modes.push_back(SpectrumCycle);
 
         mode Random;
-        Random.name = "Random";
-        Random.value = ASRLED_MODE_RANDOM;
-        Random.flags = MODE_FLAG_HAS_SPEED;
+        Random.name       = "Random";
+        Random.value      = ASRLED_MODE_RANDOM;
+        Random.flags      = MODE_FLAG_HAS_SPEED;
+        Random.color_mode = MODE_COLORS_NONE;
         modes.push_back(Random);
         
         mode Music;
-        Music.name = "Music";
-        Music.value = ASRLED_MODE_MUSIC;
-        Music.flags = MODE_FLAG_HAS_COLOR;
+        Music.name       = "Music";
+        Music.value      = ASRLED_MODE_MUSIC;
+        Music.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+        Music.color_mode = MODE_COLORS_PER_LED;
         modes.push_back(Music);
 
         mode Wave;
-        Wave.name = "Wave";
-        Wave.value = ASRLED_MODE_WAVE;
-        Wave.flags = MODE_FLAG_HAS_SPEED;
+        Wave.name       = "Wave";
+        Wave.value      = ASRLED_MODE_WAVE;
+        Wave.flags      = MODE_FLAG_HAS_SPEED;
+        Wave.color_mode = MODE_COLORS_NONE;
         modes.push_back(Wave);
     }
     else
     {
         mode Off;
-        Off.name = "Off";
-        Off.value = POLYCHROME_MODE_OFF;
-        Off.flags = 0;
+        Off.name       = "Off";
+        Off.value      = POLYCHROME_MODE_OFF;
+        Off.flags      = 0;
+        Off.color_mode = MODE_COLORS_NONE;
         modes.push_back(Off);
 
         mode Static;
-        Static.name = "Static";
-        Static.value = POLYCHROME_MODE_STATIC;
-        Static.flags = MODE_FLAG_HAS_COLOR;
+        Static.name       = "Static";
+        Static.value      = POLYCHROME_MODE_STATIC;
+        Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+        Static.color_mode = MODE_COLORS_PER_LED;
         modes.push_back(Static);
 
         mode Breathing;
-        Breathing.name = "Breathing";
-        Breathing.value = POLYCHROME_MODE_BREATHING;
-        Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR;
+        Breathing.name       = "Breathing";
+        Breathing.value      = POLYCHROME_MODE_BREATHING;
+        Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+        Breathing.color_mode = MODE_COLORS_PER_LED;
         modes.push_back(Breathing);
 
         mode Strobe;
-        Strobe.name = "Strobe";
-        Strobe.value = POLYCHROME_MODE_FLASHING;
-        Strobe.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR;
+        Strobe.name       = "Strobe";
+        Strobe.value      = POLYCHROME_MODE_FLASHING;
+        Strobe.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+        Strobe.color_mode = MODE_COLORS_PER_LED;
         modes.push_back(Strobe);
 
         mode SpectrumCycle;
-        SpectrumCycle.name = "Spectrum Cycle";
-        SpectrumCycle.value = POLYCHROME_MODE_SPECTRUM_CYCLE;
-        SpectrumCycle.flags = MODE_FLAG_HAS_SPEED;
+        SpectrumCycle.name       = "Spectrum Cycle";
+        SpectrumCycle.value      = POLYCHROME_MODE_SPECTRUM_CYCLE;
+        SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED;
+        SpectrumCycle.color_mode = MODE_COLORS_NONE;
         modes.push_back(SpectrumCycle);
 
         mode Random;
-        Random.name = "Random";
-        Random.value = POLYCHROME_MODE_RANDOM;
-        Random.flags = MODE_FLAG_HAS_SPEED;
+        Random.name       = "Random";
+        Random.value      = POLYCHROME_MODE_RANDOM;
+        Random.flags      = MODE_FLAG_HAS_SPEED;
+        Random.color_mode = MODE_COLORS_NONE;
         modes.push_back(Random);
 
         mode Wave;
-        Wave.name = "Wave";
-        Wave.value = POLYCHROME_MODE_WAVE;
-        Wave.flags = MODE_FLAG_HAS_SPEED;
+        Wave.name       = "Wave";
+        Wave.value      = POLYCHROME_MODE_WAVE;
+        Wave.flags      = MODE_FLAG_HAS_SPEED;
+        Wave.color_mode = MODE_COLORS_NONE;
         modes.push_back(Wave);
 
         mode Spring;
-        Spring.name = "Spring";
-        Spring.value = POLYCHROME_MODE_SPRING;
-        Spring.flags = MODE_FLAG_HAS_SPEED;
+        Spring.name       = "Spring";
+        Spring.value      = POLYCHROME_MODE_SPRING;
+        Spring.flags      = MODE_FLAG_HAS_SPEED;
+        Spring.color_mode = MODE_COLORS_NONE;
         modes.push_back(Spring);
 
         mode Stack;
-        Stack.name = "Stack";
-        Stack.value = POLYCHROME_MODE_STACK;
-        Stack.flags = MODE_FLAG_HAS_SPEED;
+        Stack.name       = "Stack";
+        Stack.value      = POLYCHROME_MODE_STACK;
+        Stack.flags      = MODE_FLAG_HAS_SPEED;
+        Stack.color_mode = MODE_COLORS_NONE;
         modes.push_back(Stack);
 
         mode Cram;
-        Cram.name = "Cram";
-        Cram.value = POLYCHROME_MODE_CRAM;
-        Cram.flags = MODE_FLAG_HAS_SPEED;
+        Cram.name       = "Cram";
+        Cram.value      = POLYCHROME_MODE_CRAM;
+        Cram.flags      = MODE_FLAG_HAS_SPEED;
+        Cram.color_mode = MODE_COLORS_NONE;
         modes.push_back(Cram);
 
         mode Scan;
-        Scan.name = "Scan";
-        Scan.value = POLYCHROME_MODE_SCAN;
-        Scan.flags = MODE_FLAG_HAS_SPEED;
+        Scan.name       = "Scan";
+        Scan.value      = POLYCHROME_MODE_SCAN;
+        Scan.flags      = MODE_FLAG_HAS_SPEED;
+        Scan.color_mode = MODE_COLORS_NONE;
         modes.push_back(Scan);
 
         mode Neon;
-        Neon.name = "Neon";
-        Neon.value = POLYCHROME_MODE_NEON;
-        Neon.flags = 0;
+        Neon.name       = "Neon";
+        Neon.value      = POLYCHROME_MODE_NEON;
+        Neon.flags      = 0;
+        Neon.color_mode = MODE_COLORS_NONE;
         modes.push_back(Neon);
 
         mode Water;
-        Water.name = "Water";
-        Water.value = POLYCHROME_MODE_WATER;
-        Water.flags = MODE_FLAG_HAS_SPEED;
+        Water.name       = "Water";
+        Water.value      = POLYCHROME_MODE_WATER;
+        Water.flags      = MODE_FLAG_HAS_SPEED;
+        Water.color_mode = MODE_COLORS_NONE;
         modes.push_back(Water);
 
         mode Rainbow;
-        Rainbow.name = "Rainbow";
-        Rainbow.value = POLYCHROME_MODE_RAINBOW;
-        Rainbow.flags = MODE_FLAG_HAS_SPEED;
+        Rainbow.name       = "Rainbow";
+        Rainbow.value      = POLYCHROME_MODE_RAINBOW;
+        Rainbow.flags      = MODE_FLAG_HAS_SPEED;
+        Rainbow.color_mode = MODE_COLORS_NONE;
         modes.push_back(Rainbow);
     }
 

RGBController/RGBController_PoseidonZRGB.cpp

@@ -135,42 +135,42 @@ RGBController_PoseidonZRGB::RGBController_PoseidonZRGB(PoseidonZRGBController* p
     type = DEVICE_TYPE_KEYBOARD;
 
     mode Direct;
-    Direct.name   = "Direct";
-    Direct.value  = POSEIDONZ_MODE_STATIC;
-    Direct.flags  = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Direct.random = false;
+    Direct.name       = "Direct";
+    Direct.value      = POSEIDONZ_MODE_STATIC;
+    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  = POSEIDONZ_MODE_STATIC;
-    Static.flags  = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Static.random = false;
+    Static.name       = "Static";
+    Static.value      = POSEIDONZ_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Wave;
-    Wave.name      = "Wave";
-    Wave.value     = POSEIDONZ_MODE_WAVE;
-    Wave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Wave.speed_min = POSEIDONZ_SPEED_SLOW;
-    Wave.speed_max = POSEIDONZ_SPEED_FAST;
-    Wave.random    = false;
-    Wave.speed     = POSEIDONZ_SPEED_FAST;
-    Wave.direction = MODE_DIRECTION_LEFT;
+    Wave.name       = "Wave";
+    Wave.value      = POSEIDONZ_MODE_WAVE;
+    Wave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Wave.speed_min  = POSEIDONZ_SPEED_SLOW;
+    Wave.speed_max  = POSEIDONZ_SPEED_FAST;
+    Wave.color_mode = MODE_COLORS_NONE;
+    Wave.speed      = POSEIDONZ_SPEED_FAST;
+    Wave.direction  = MODE_DIRECTION_LEFT;
     modes.push_back(Wave);
 
     mode Ripple;
-    Ripple.name   = "Ripple";
-    Ripple.value  = POSEIDONZ_MODE_RIPPLE;
-    Ripple.flags  = 0;
-    Ripple.random = false;
+    Ripple.name       = "Ripple";
+    Ripple.value      = POSEIDONZ_MODE_RIPPLE;
+    Ripple.flags      = 0;
+    Ripple.color_mode = MODE_COLORS_NONE;
     modes.push_back(Ripple);
 
     mode Reactive;
-    Reactive.name   = "Reactive";
-    Reactive.value  = POSEIDONZ_MODE_REACTIVE;
-    Reactive.flags  = 0;
-    Reactive.random = false;
+    Reactive.name       = "Reactive";
+    Reactive.value      = POSEIDONZ_MODE_REACTIVE;
+    Reactive.flags      = 0;
+    Reactive.color_mode = MODE_COLORS_NONE;
     modes.push_back(Reactive);
 
     colors.resize(104);

RGBController/RGBController_RGBFusion.cpp

@@ -55,27 +55,30 @@ RGBController_RGBFusion::RGBController_RGBFusion(RGBFusionController* rgb_fusion
     type = DEVICE_TYPE_MOTHERBOARD;
 
     mode Static;
-    Static.name  = "Static";
-    Static.value = RGB_FUSION_MODE_STATIC;
-    Static.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Static.name       = "Static";
+    Static.value      = RGB_FUSION_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Breathing;
-    Breathing.name      = "Breathing";
-    Breathing.value     = RGB_FUSION_MODE_BREATHING;
-    Breathing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Breathing.speed_min = RGB_FUSION_SPEED_SLOW;
-    Breathing.speed_max = RGB_FUSION_SPEED_FAST;
-    Breathing.speed     = RGB_FUSION_SPEED_NORMAL;
+    Breathing.name       = "Breathing";
+    Breathing.value      = RGB_FUSION_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.speed_min  = RGB_FUSION_SPEED_SLOW;
+    Breathing.speed_max  = RGB_FUSION_SPEED_FAST;
+    Breathing.speed      = RGB_FUSION_SPEED_NORMAL;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Breathing);
 
     mode Flashing;
-    Flashing.name      = "Flashing";
-    Flashing.value     = RGB_FUSION_MODE_FLASHING;
-    Flashing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Flashing.speed_min = RGB_FUSION_SPEED_SLOW;
-    Flashing.speed_max = RGB_FUSION_SPEED_FAST;
-    Flashing.speed     = RGB_FUSION_SPEED_NORMAL;
+    Flashing.name       = "Flashing";
+    Flashing.value      = RGB_FUSION_MODE_FLASHING;
+    Flashing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Flashing.speed_min  = RGB_FUSION_SPEED_SLOW;
+    Flashing.speed_max  = RGB_FUSION_SPEED_FAST;
+    Flashing.speed      = RGB_FUSION_SPEED_NORMAL;
+    Flashing.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Flashing);
 
     colors.resize(rgb_fusion->GetLEDCount());

RGBController/RGBController_RGBFusion2.cpp

@@ -47,14 +47,12 @@ RGBController_RGBFusion2::RGBController_RGBFusion2(RGBFusion2Controller* rgb_fus
 
     type = DEVICE_TYPE_MOTHERBOARD;
 
-    mode rgb_fusion_modes[1];
-
-    rgb_fusion_modes[0].name = "Static";
-
-    for (int i = 0; i < 1; i++)
-    {
-        modes.push_back(rgb_fusion_modes[i]);
-    }
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
 
     colors.resize(rgb_fusion->GetLEDCount());
 
@@ -92,4 +90,4 @@ void RGBController_RGBFusion2::SetCustomMode()
 void RGBController_RGBFusion2::UpdateMode()
 {
     rgb_fusion->SetMode(modes[active_mode].value);
-}
+}

RGBController/RGBController_RazerChromaSDK.cpp

@@ -1,166 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_RazerChromaSDK.h           |
-|                                           |
-|  Generic RGB Interface for official Razer |
-|  Chroma SDK                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 9/2/2019    |
-\*-----------------------------------------*/
-
-#include "RGBController_RazerChromaSDK.h"
-
-CREATEEFFECT           RGBController_RazerChromaSDK::CreateEffect           = NULL;
-CREATEKEYBOARDEFFECT   RGBController_RazerChromaSDK::CreateKeyboardEffect   = NULL;
-CREATEMOUSEEFFECT      RGBController_RazerChromaSDK::CreateMouseEffect      = NULL;
-CREATEMOUSEPADEFFECT   RGBController_RazerChromaSDK::CreateMousepadEffect   = NULL;
-CREATEHEADSETEFFECT    RGBController_RazerChromaSDK::CreateHeadsetEffect    = NULL;
-CREATECHROMALINKEFFECT RGBController_RazerChromaSDK::CreateChromaLinkEffect = NULL;
-
-RGBController_RazerChromaSDK::RGBController_RazerChromaSDK(unsigned int device_type, HMODULE* hModule)
-{
-    unsigned int led_count = 0;
-
-    for (int i = 0; i < RAZER_NUM_DEVICES; i++)
-    {
-        if (device_list[i]->razer_type == device_type)
-        {
-            name = device_list[i]->name;
-            type = device_list[i]->type;
-            location = "Razer Chroma SDK";
-
-            for (int zone_id = 0; zone_id < RAZER_MAX_ZONES; zone_id++)
-            {
-                if (device_list[i]->zones[zone_id] != NULL)
-                {
-                    device = device_list[i];
-
-                    zone* new_zone = new zone();
-                    new_zone->name = device_list[i]->zones[zone_id]->name;
-                    new_zone->type = device_list[i]->zones[zone_id]->type;
-
-                    std::vector<int> new_zone_map;
-
-                    for (int led_id = 0; led_id < device_list[i]->zones[zone_id]->leds; led_id++)
-                    {
-                        RGBColor new_color = 0x00000000;
-                        colors.push_back(new_color);
-
-                        led* new_led = new led();
-                        new_led->name = device_list[i]->zones[zone_id]->name;
-                        leds.push_back(*new_led);
-
-                        new_zone_map.push_back(led_count);
-
-                        led_count++;
-                    }
-
-                    new_zone->map.push_back(new_zone_map);
-
-                    zones.push_back(*new_zone);
-                }
-            }
-        }
-    }
-
-    if(CreateEffect           == NULL) CreateEffect           = (CREATEEFFECT)GetProcAddress(*hModule, "CreateEffect");
-    if(CreateKeyboardEffect   == NULL) CreateKeyboardEffect   = (CREATEKEYBOARDEFFECT)GetProcAddress(*hModule, "CreateKeyboardEffect");
-    if(CreateMouseEffect      == NULL) CreateMouseEffect      = (CREATEMOUSEEFFECT)GetProcAddress(*hModule, "CreateMouseEffect");
-    if(CreateMousepadEffect   == NULL) CreateMousepadEffect   = (CREATEMOUSEPADEFFECT)GetProcAddress(*hModule, "CreateMousepadEffect");
-    if(CreateHeadsetEffect    == NULL) CreateHeadsetEffect    = (CREATEHEADSETEFFECT)GetProcAddress(*hModule, "CreateHeadsetEffect");
-    if(CreateChromaLinkEffect == NULL) CreateChromaLinkEffect = (CREATECHROMALINKEFFECT)GetProcAddress(*hModule, "CreateChromaLinkEffect");
-}
-
-void RGBController_RazerChromaSDK::UpdateLEDs()
-{
-    switch (device->razer_type)
-    {
-    case RAZER_GENERIC_MOUSE:
-        {
-            ChromaSDK::Mouse::CUSTOM_EFFECT_TYPE2 MouseEffect = {};
-
-            std::vector<int> left_zone_map = zones[0].map[0];
-
-            for (int left = 1; left < 8; left++)
-            {
-                MouseEffect.Color[left][0] = colors[left_zone_map[left - 1]];
-            }
-
-            std::vector<int> right_zone_map = zones[1].map[0];
-
-            for (int right = 1; right < 8; right++)
-            {
-                MouseEffect.Color[right][6] = colors[right_zone_map[right - 1]];
-            }
-
-            std::vector<int> bottom_zone_map = zones[2].map[0];
-
-            for (int bottom = 1; bottom < 6; bottom++)
-            {
-                MouseEffect.Color[8][bottom] = colors[bottom_zone_map[bottom - 1]];
-            }
-
-            std::vector<int> scroll_wheel_zone_map = zones[3].map[0];
-
-            MouseEffect.Color[2][3] = colors[scroll_wheel_zone_map[0]];
-
-            std::vector<int> logo_zone_map = zones[4].map[0];
-
-            MouseEffect.Color[7][3] = colors[logo_zone_map[0]];
-
-            std::vector<int> numpad_backlight_zone_map = zones[5].map[0];
-
-            MouseEffect.Color[4][3] = colors[numpad_backlight_zone_map[0]];
-
-            CreateMouseEffect(ChromaSDK::Mouse::CHROMA_CUSTOM2, &MouseEffect, NULL);
-        }
-        break;
-
-    case RAZER_GENERIC_MOUSEPAD:
-        {
-            ChromaSDK::Mousepad::CUSTOM_EFFECT_TYPE MousepadEffect = {};
-
-            for (int x = 0; x < 15; x++)
-            {
-                MousepadEffect.Color[x] = colors[x];
-            }
-
-            CreateMousepadEffect(ChromaSDK::Mousepad::CHROMA_CUSTOM, &MousepadEffect, NULL);
-        }
-        break;
-
-    case RAZER_CHROMA_HDK:
-        {
-            ChromaSDK::CUSTOM_EFFECT_TYPE ChromaBoxEffect = {};
-
-            for (int x = 0; x < 16; x++)
-            {
-                for (int y = 0; y < 4; y++)
-                {
-                    ChromaBoxEffect.Color[y][x] = colors[(y*16) + x];
-                }
-            }
-            CreateEffect(ChromaSDK::CHROMABOX, ChromaSDK::CHROMA_CUSTOM, &ChromaBoxEffect, NULL);
-        }
-        break;
-    }
-}
-
-void RGBController_RazerChromaSDK::UpdateZoneLEDs(int zone)
-{
-    UpdateLEDs();
-}
-
-void RGBController_RazerChromaSDK::UpdateSingleLED(int led)
-{
-    UpdateLEDs();
-}
-
-void RGBController_RazerChromaSDK::SetCustomMode()
-{
-
-}
-
-void RGBController_RazerChromaSDK::UpdateMode()
-{
-
-}

RGBController/RGBController_RazerChromaSDK.h

@@ -1,248 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_RazerChromaSDK.h           |
-|                                           |
-|  Generic RGB Interface for official Razer |
-|  Chroma SDK                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 9/2/2019    |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include <Windows.h>
-
-#include "RzChromaSDKDefines.h"
-#include "RzChromaSDKTypes.h"
-#include "RzErrors.h"
-
-using namespace ChromaSDK::Keyboard;
-
-typedef RZRESULT(*INIT)(void);
-typedef RZRESULT(*UNINIT)(void);
-typedef RZRESULT(*CREATEEFFECT)(RZDEVICEID DeviceId, ChromaSDK::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);
-typedef RZRESULT(*CREATEKEYBOARDEFFECT)(ChromaSDK::Keyboard::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);
-typedef RZRESULT(*CREATEMOUSEEFFECT)(ChromaSDK::Mouse::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);
-typedef RZRESULT(*CREATEMOUSEPADEFFECT)(ChromaSDK::Mousepad::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);
-typedef RZRESULT(*CREATEHEADSETEFFECT)(ChromaSDK::Headset::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);
-typedef RZRESULT(*CREATECHROMALINKEFFECT)(ChromaSDK::ChromaLink::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);
-
-#define RAZER_MAX_ZONES 6
-#define RAZER_NUM_DEVICES 3
-
-enum
-{
-    RAZER_GENERIC_KEYBOARD,
-    RAZER_GENERIC_MOUSE,
-    RAZER_GENERIC_MOUSEPAD,
-    RAZER_CHROMA_HDK
-};
-
-enum
-{
-    RAZER_MODE_CUSTOM,
-    RAZER_MODE_OFF,
-    RAZER_MODE_STATIC,
-    RAZER_MODE_BREATHING,
-    RAZER_MODE_SPECTRUM_CYCLE,
-    RAZER_MODE_WAVE,
-    RAZER_MODE_REACTIVE,
-    RAZER_NUM_MODES
-};
-
-typedef struct
-{
-    std::string name;
-    unsigned int type;
-    unsigned int leds;
-} razer_zone;
-
-typedef struct
-{
-    std::string name;
-    unsigned int razer_type;
-    unsigned int type;
-    const razer_zone* zones[RAZER_MAX_ZONES];
-} razer_device;
-
-/*------------------------------------------------------------ *\
-|  Razer Generic Mouse                                          |
-|                                                               |
-|  Zone "Left"                                                  |
-|       Linear                                                  |
-|       7 LEDs                                                  |
-|                                                               |
-|  Zone "Right"                                                 |
-|       Linear                                                  |
-|       7 LEDs                                                  |
-|                                                               |
-|  Zone "Bottom"                                                |
-|       Linear                                                  |
-|       5 LEDs                                                  |
-|                                                               |
-|  Zone "Scroll Wheel"                                          |
-|       Single                                                  |
-|       1 LED                                                   |
-|                                                               |
-|  Zone "Logo"                                                  |
-|       Single                                                  |
-|       1 LED                                                   |
-|                                                               |
-|  Zone "Numpad/Backlight"                                      |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone mouse_left_zone =
-{
-    "Left LED Strip",
-    ZONE_TYPE_LINEAR,
-    7
-};
-
-static const razer_zone mouse_right_zone =
-{
-    "Right LED Strip",
-    ZONE_TYPE_LINEAR,
-    7
-};
-
-static const razer_zone mouse_bottom_zone =
-{
-    "Bottom LED Strip",
-    ZONE_TYPE_LINEAR,
-    5
-};
-
-static const razer_zone mouse_scroll_wheel_zone =
-{
-    "Scroll Wheel",
-    ZONE_TYPE_SINGLE,
-    1
-};
-
-static const razer_zone mouse_logo_zone =
-{
-    "Logo",
-    ZONE_TYPE_SINGLE,
-    1
-};
-
-static const razer_zone mouse_numpad_backlight_zone =
-{
-    "Numpad/Backlight",
-    ZONE_TYPE_SINGLE,
-    1
-};
-
-static const razer_device mouse_device =
-{
-    "Razer Generic Mouse",
-    RAZER_GENERIC_MOUSE,
-    DEVICE_TYPE_MOUSE,
-    {
-        &mouse_left_zone,
-        &mouse_right_zone,
-        &mouse_bottom_zone,
-        &mouse_scroll_wheel_zone,
-        &mouse_logo_zone,
-        &mouse_numpad_backlight_zone
-    }
-};
-
-/*------------------------------------------------------------ *\
-|  Razer Generic Mousepad (Firefly, Mug Holder)                 |
-|                                                               |
-|  Zone "LED Strip"                                             |
-|       Linear                                                  |
-|       15 LEDs                                                 |
-\*-------------------------------------------------------------*/
-static const razer_zone mousepad_zone =
-{
-    "LED Strip",
-    ZONE_TYPE_LINEAR,
-    15
-};
-
-static const razer_device mousepad_device =
-{
-    "Razer Generic Mousepad",
-    RAZER_GENERIC_MOUSEPAD,
-    DEVICE_TYPE_MOUSE,
-    {
-        &mousepad_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    }
-};
-
-/*------------------------------------------------------------ *\
-|  Razer Chroma HDK                                             |
-|                                                               |
-|  Zone "LED Strip"                                             |
-|       Linear                                                  |
-|       16 LEDs                                                 |
-|                                                               |
-|  Zone "LED Strip"                                             |
-|       Linear                                                  |
-|       16 LEDs                                                 |
-|                                                               |
-|  Zone "LED Strip"                                             |
-|       Linear                                                  |
-|       16 LEDs                                                 |
-|                                                               |
-|  Zone "LED Strip"                                             |
-|       Linear                                                  |
-|       16 LEDs                                                 |
-\*-------------------------------------------------------------*/
-static const razer_zone chromahdk_zone =
-{
-    "LED Strip",
-    ZONE_TYPE_LINEAR,
-    16
-};
-
-static const razer_device chromahdk_device =
-{
-    "Razer Chroma HDK",
-    RAZER_CHROMA_HDK,
-    DEVICE_TYPE_LEDSTRIP,
-    {
-        &chromahdk_zone,
-        &chromahdk_zone,
-        &chromahdk_zone,
-        &chromahdk_zone,
-        NULL,
-        NULL
-    }
-};
-
-static const razer_device* device_list[RAZER_NUM_DEVICES] =
-{
-    &mouse_device,
-    &mousepad_device,
-    &chromahdk_device
-};
-
-class RGBController_RazerChromaSDK : public RGBController
-{
-public:
-    RGBController_RazerChromaSDK(unsigned int device_type, HMODULE* hModule);
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        UpdateMode();
-
-private:
-    const razer_device* device;
-
-    static CREATEEFFECT CreateEffect;
-    static CREATEKEYBOARDEFFECT CreateKeyboardEffect;
-    static CREATEMOUSEEFFECT CreateMouseEffect;
-    static CREATEMOUSEPADEFFECT CreateMousepadEffect;
-    static CREATEHEADSETEFFECT CreateHeadsetEffect;
-    static CREATECHROMALINKEFFECT CreateChromaLinkEffect;
-};

RGBController/RGBController_ThermaltakeRiing.cpp

@@ -19,75 +19,86 @@ RGBController_ThermaltakeRiing::RGBController_ThermaltakeRiing(ThermaltakeRiingC
     type = DEVICE_TYPE_COOLER;
 
     mode Flow;
-    Flow.name      = "Flow";
-    Flow.value     = THERMALTAKE_MODE_FLOW;
-    Flow.flags     = MODE_FLAG_HAS_SPEED;
-    Flow.speed_min = THERMALTAKE_SPEED_SLOW;
-    Flow.speed_max = THERMALTAKE_SPEED_EXTREME;
-    Flow.speed     = THERMALTAKE_SPEED_NORMAL;
+    Flow.name       = "Flow";
+    Flow.value      = THERMALTAKE_MODE_FLOW;
+    Flow.flags      = MODE_FLAG_HAS_SPEED;
+    Flow.speed_min  = THERMALTAKE_SPEED_SLOW;
+    Flow.speed_max  = THERMALTAKE_SPEED_EXTREME;
+    Flow.speed      = THERMALTAKE_SPEED_NORMAL;
+    Flow.color_mode = MODE_COLORS_NONE;
     modes.push_back(Flow);
 
     mode Spectrum;
-    Spectrum.name      = "Spectrum";
-    Spectrum.value     = THERMALTAKE_MODE_SPECTRUM;
-    Spectrum.flags     = MODE_FLAG_HAS_SPEED;
-    Spectrum.speed_min = THERMALTAKE_SPEED_SLOW;
-    Spectrum.speed_max = THERMALTAKE_SPEED_EXTREME;
-    Spectrum.speed     = THERMALTAKE_SPEED_NORMAL;
+    Spectrum.name       = "Spectrum";
+    Spectrum.value      = THERMALTAKE_MODE_SPECTRUM;
+    Spectrum.flags      = MODE_FLAG_HAS_SPEED;
+    Spectrum.speed_min  = THERMALTAKE_SPEED_SLOW;
+    Spectrum.speed_max  = THERMALTAKE_SPEED_EXTREME;
+    Spectrum.speed      = THERMALTAKE_SPEED_NORMAL;
+    Spectrum.color_mode = MODE_COLORS_NONE;
     modes.push_back(Spectrum);
 
     mode Ripple;
-    Ripple.name      = "Ripple";
-    Ripple.value     = THERMALTAKE_MODE_RIPPLE;
-    Ripple.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR;
-    Ripple.speed_min = THERMALTAKE_SPEED_SLOW;
-    Ripple.speed_max = THERMALTAKE_SPEED_EXTREME;
-    Ripple.speed     = THERMALTAKE_SPEED_NORMAL;
+    Ripple.name       = "Ripple";
+    Ripple.value      = THERMALTAKE_MODE_RIPPLE;
+    Ripple.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Ripple.speed_min  = THERMALTAKE_SPEED_SLOW;
+    Ripple.speed_max  = THERMALTAKE_SPEED_EXTREME;
+    Ripple.speed      = THERMALTAKE_SPEED_NORMAL;
+    Ripple.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Ripple);
 
     mode Blink;
-    Blink.name      = "Blink";
-    Blink.value     = THERMALTAKE_MODE_BLINK;
-    Blink.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Blink.speed_min = THERMALTAKE_SPEED_SLOW;
-    Blink.speed_max = THERMALTAKE_SPEED_EXTREME;
-    Blink.speed     = THERMALTAKE_SPEED_NORMAL;
+    Blink.name       = "Blink";
+    Blink.value      = THERMALTAKE_MODE_BLINK;
+    Blink.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Blink.speed_min  = THERMALTAKE_SPEED_SLOW;
+    Blink.speed_max  = THERMALTAKE_SPEED_EXTREME;
+    Blink.speed      = THERMALTAKE_SPEED_NORMAL;
+    Blink.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Blink);
 
     mode Pulse;
-    Pulse.name      = "Pulse";
-    Pulse.value     = THERMALTAKE_MODE_PULSE;
-    Pulse.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Pulse.speed_min = THERMALTAKE_SPEED_SLOW;
-    Pulse.speed_max = THERMALTAKE_SPEED_EXTREME;
-    Pulse.speed     = THERMALTAKE_SPEED_NORMAL;
+    Pulse.name       = "Pulse";
+    Pulse.value      = THERMALTAKE_MODE_PULSE;
+    Pulse.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Pulse.speed_min  = THERMALTAKE_SPEED_SLOW;
+    Pulse.speed_max  = THERMALTAKE_SPEED_EXTREME;
+    Pulse.speed      = THERMALTAKE_SPEED_NORMAL;
+    Pulse.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Pulse);
 
     mode Wave;
-    Wave.name      = "Wave";
-    Wave.value     = THERMALTAKE_MODE_WAVE;
-    Wave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Wave.speed_min = THERMALTAKE_SPEED_SLOW;
-    Wave.speed_max = THERMALTAKE_SPEED_EXTREME;
-    Wave.speed     = THERMALTAKE_SPEED_NORMAL;
+    Wave.name       = "Wave";
+    Wave.value      = THERMALTAKE_MODE_WAVE;
+    Wave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Wave.speed_min  = THERMALTAKE_SPEED_SLOW;
+    Wave.speed_max  = THERMALTAKE_SPEED_EXTREME;
+    Wave.speed      = THERMALTAKE_SPEED_NORMAL;
+    Wave.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Wave);
 
     mode Direct;
-    Direct.name      = "Direct";
-    Direct.value     = THERMALTAKE_MODE_PER_LED;
-    Direct.flags     = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
-    Direct.speed_min = 0;
-    Direct.speed_max = 0;
-    Direct.speed     = 0;
+    Direct.name       = "Direct";
+    Direct.value      = THERMALTAKE_MODE_PER_LED;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.speed_min  = 0;
+    Direct.speed_max  = 0;
+    Direct.speed      = 0;
+    Direct.color_mode = MODE_FLAG_HAS_PER_LED_COLOR;
     modes.push_back(Direct);
 
     mode Static;
-    Static.name      = "Static";
-    Static.value     = THERMALTAKE_MODE_FULL;
-    Static.flags     = MODE_FLAG_HAS_COLOR;
-    Static.speed_min = 0;
-    Static.speed_max = 0;
-    Static.speed     = 0;
+    Static.name       = "Static";
+    Static.value      = THERMALTAKE_MODE_FULL;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min = 1;
+    Static.colors_max = 1;
+    Static.speed_min  = 0;
+    Static.speed_max  = 0;
+    Static.speed      = 0;
+    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
     modes.push_back(Static);
 
     /*-------------------------------------------------*\

RGBController/RazerChromaSDKDetect.cpp

@@ -1,70 +0,0 @@
-#include "RGBController.h"
-#include "RGBController_RazerChromaSDK.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <fcntl.h>
-#include <string.h>
-
-static HMODULE hModule;
-
-#include "RzChromaSDKDefines.h"
-#include "RzChromaSDKTypes.h"
-#include "RzErrors.h"
-
-using namespace ChromaSDK::Keyboard;
-
-typedef RZRESULT(*INIT)(void);
-typedef RZRESULT(*UNINIT)(void);
-typedef RZRESULT(*CREATEEFFECT)(RZDEVICEID DeviceId, ChromaSDK::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);
-typedef RZRESULT(*CREATEKEYBOARDEFFECT)(ChromaSDK::Keyboard::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);
-typedef RZRESULT(*CREATEMOUSEEFFECT)(ChromaSDK::Mouse::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);
-typedef RZRESULT(*CREATEMOUSEPADEFFECT)(ChromaSDK::Mousepad::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);
-typedef RZRESULT(*CREATEHEADSETEFFECT)(ChromaSDK::Headset::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);
-typedef RZRESULT(*CREATECHROMALINKEFFECT)(ChromaSDK::ChromaLink::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID* pEffectId);
-
-#ifdef _WIN64
-#define CHROMASDKDLL        ("RzChromaSDK64.dll")
-#else
-#define CHROMASDKDLL        ("RzChromaSDK.dll")
-#endif
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectRazerChromaSDKControllers                                                        *
-*                                                                                          *
-*       Detect devices supported by the Razer Chroma SDK                                   *
-*                                                                                          *                                                                                          *
-\******************************************************************************************/
-
-void DetectRazerChromaSDKControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    RGBController_RazerChromaSDK* razer_rgb;
-
-    // Dynamically loads the Chroma SDK library.
-    hModule = LoadLibrary(CHROMASDKDLL);
-    if (hModule)
-    {
-        INIT Init = (INIT)GetProcAddress(hModule, "Init");
-        if (Init)
-        {
-            //Initialize the SDK
-            Init();
-        }
-    }
-
-
-    razer_rgb = new RGBController_RazerChromaSDK(RAZER_GENERIC_MOUSE, &hModule);
-
-    rgb_controllers.push_back(razer_rgb);
-
-    razer_rgb = new RGBController_RazerChromaSDK(RAZER_GENERIC_MOUSEPAD, &hModule);
-
-    rgb_controllers.push_back(razer_rgb);
-
-    razer_rgb = new RGBController_RazerChromaSDK(RAZER_CHROMA_HDK, &hModule);
-
-    rgb_controllers.push_back(razer_rgb);
-
-}   /* DetectRazerChromaSDKControllers() */

dependencies/openrazer-win32/linux/dmi.h

@@ -0,0 +1,31 @@
+#ifndef DMI_H_
+#define DMI_H_
+
+enum dmi_field {
+	DMI_NONE,
+	DMI_BIOS_VENDOR,
+	DMI_BIOS_VERSION,
+	DMI_BIOS_DATE,
+	DMI_SYS_VENDOR,
+	DMI_PRODUCT_NAME,
+	DMI_PRODUCT_VERSION,
+	DMI_PRODUCT_SERIAL,
+	DMI_PRODUCT_UUID,
+	DMI_BOARD_VENDOR,
+	DMI_BOARD_NAME,
+	DMI_BOARD_VERSION,
+	DMI_BOARD_SERIAL,
+	DMI_BOARD_ASSET_TAG,
+	DMI_CHASSIS_VENDOR,
+	DMI_CHASSIS_TYPE,
+	DMI_CHASSIS_VERSION,
+	DMI_CHASSIS_SERIAL,
+	DMI_CHASSIS_ASSET_TAG,
+	DMI_STRING_MAX,
+};
+
+static inline char* dmi_get_system_info(int x) {
+	return "BLADESERIAL";
+}
+
+#endif /* DMI_H_ */

dependencies/openrazer-win32/linux/hid.h

@@ -0,0 +1,300 @@
+#ifndef HID_H_
+#define HID_H_
+
+#include <SetupAPI.h>
+#include <cfgmgr32.h>
+#include <Winusb.h>
+
+#pragma comment(lib, "setupapi.lib")
+#pragma comment(lib, "Winusb.lib")
+
+#define HID_STAT_ADDED					1
+#define HID_STAT_PARSED					2
+
+#define HID_CONNECT_HIDINPUT            0x01
+#define HID_CONNECT_HIDRAW              0x04
+#define HID_CONNECT_HIDDEV              0x08
+#define HID_CONNECT_FF                  0x20
+#define HID_CONNECT_DEFAULT     (HID_CONNECT_HIDINPUT|HID_CONNECT_HIDRAW| HID_CONNECT_HIDDEV|HID_CONNECT_FF)
+
+#define HID_GD_WHEEL					0x00010038
+
+#define HID_REQ_GET_REPORT              0x01
+#define HID_REQ_SET_REPORT				0x09
+
+#define USB_INTERFACE_PROTOCOL_KEYBOARD 1
+#define USB_INTERFACE_PROTOCOL_MOUSE    2
+
+static const GUID GUID_DEVINTERFACE = { 0xDEE824EF, 0x729B, 0x4A0E, 0x9C, 0x14, 0xB7, 0x11, 0x7D, 0x33, 0xA8, 0x17 };
+
+typedef enum
+{
+HID_TYPE_OTHER,
+HID_TYPE_USBMOUSE,
+HID_TYPE_USBNONE
+} hid_type;
+
+struct hid_input {
+	struct input_dev *input;
+};
+
+struct hid_field {
+	struct hid_input *hidinput;     /* associated input structure */
+};
+
+struct hid_usage {
+	unsigned  hid;
+	__u16     code;                 /* input driver code */
+	__u8      type;                 /* input driver type */
+};
+
+struct hid_driver {
+	char *name;
+	const struct hid_device_id *id_table;
+	int (*probe)(struct hid_device *dev, const struct hid_device_id *id);
+	void (*remove)(struct hid_device *dev);
+	int (*raw_event)(struct hid_device *hdev, struct hid_report *report, u8 *data, int size);
+	int (*event)(struct hid_device *hdev, struct hid_field *field, struct hid_usage *usage, __s32 value);
+	int (*input_configured)(struct hid_device *hdev,
+					struct hid_input *hidinput);
+	int (*input_mapping)(struct hid_device *hdev,
+					struct hid_input *hidinput, struct hid_field *field,
+					struct hid_usage *usage, unsigned long **bit, int *max);
+};
+
+struct hid_device_id {
+	__u16 bus;
+	__u32 vendor;
+	__u32 product;
+};
+
+struct hid_device {
+	__u16 product;
+	enum hid_type type;
+	struct device dev;
+	struct hid_ll_driver *ll_driver;
+	unsigned int status;
+	struct hid_driver *driver;
+};
+
+struct hid_ll_driver {
+	int (*start)(struct hid_device *hdev);
+	void (*stop)(struct hid_device *hdev);
+	int (*parse)(struct hid_device *hdev);
+};
+
+inline int ll_start(struct hid_device *hdev) {
+	printf("ll_start\n");
+	return 0;
+}
+
+inline void ll_stop(struct hid_device *hdev) {
+	printf("ll_stop\n");
+}
+
+inline int ll_parse(struct hid_device *hdev) {
+	printf("ll_parse\n");
+	return 0;
+}
+
+inline void dev_err(struct device** dev, const char* msg) {
+	printf("dev_err device=%s msg=%s", (*dev)->init_name, msg);
+}
+
+inline void dev_info(struct device** dev, const char* msg) {
+	printf("dev_err device=%s msg=%s", (*dev)->init_name, msg);
+}
+
+inline void *dev_get_drvdata(const struct device *dev) {
+	return dev->driver_data;
+}
+
+inline void dev_set_drvdata(struct device *dev, void *data) {
+	dev->driver_data = data;
+}
+
+inline int hid_connect(struct hid_device *hdev, unsigned int connect_mask) {
+	printf("hid_connect\n");
+	return 0;
+}
+
+inline int hid_parse(struct hid_device *hdev) {
+	int ret;
+
+	if (hdev->status & HID_STAT_PARSED)
+		return 0;
+
+	ret = hdev->ll_driver->parse(hdev);
+	if (!ret)
+		hdev->status |= HID_STAT_PARSED;
+
+	return ret;
+}
+
+inline void *hid_get_drvdata(struct hid_device *hdev) {
+	return dev_get_drvdata(&hdev->dev);
+}
+
+inline void hid_set_drvdata(struct hid_device *hdev, void *data) {
+	dev_set_drvdata(&hdev->dev, data);
+}
+
+inline int hid_hw_start(struct hid_device *hdev, unsigned int connect_mask) {
+	int ret = hdev->ll_driver->start(hdev);
+	if (ret || !connect_mask)
+		return ret;
+	ret = hid_connect(hdev, connect_mask);
+	if (ret)
+		hdev->ll_driver->stop(hdev);
+	return ret;
+}
+
+inline void hid_hw_stop(struct hid_device *hdev) {
+	hdev->ll_driver->stop(hdev);
+}
+
+inline void hid_err(struct hid_device *hdev, const char* msg, ...) {
+	va_list args;
+	va_start(args, msg);
+	printf("hid_err device=%s", hdev->dev.init_name);
+	printf(msg, args);
+	va_end(args);
+}
+
+inline void hid_map_usage(struct hid_input* hidinput,
+	struct hid_usage* usage, unsigned long** bit, int* max,
+	__u8 type, __u16 c)
+{
+
+};
+
+#define container_of(ptr, type, member) (type*)((char*)(ptr)-(char*)&((type *)0)->member)
+
+inline void close(struct device* dev) {
+	printf("close %04X\n", (to_usb_device(dev))->descriptor.idProduct);
+	struct usb_interface *intf = to_usb_interface(dev->parent);
+	struct usb_device *usb_dev = interface_to_usbdev(intf);
+	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+	free(hdev->ll_driver);
+	free(usb_dev);
+	free(intf->cur_altsetting);
+	free(intf);
+	free(hdev);
+	//TODO:cleanup malloc memory, move this function into DLL
+}
+
+inline void openChromaDevice(struct hid_device** hdev, unsigned int* numHdev, struct hid_driver hdr) {
+
+	for (unsigned int  i = 0; hdr.id_table[i].vendor != 0; i++) {
+		HDEVINFO hDevInfo = SetupDiGetClassDevs(&GUID_DEVINTERFACE, 0, 0, DIGCF_DEVICEINTERFACE);
+		if (hDevInfo == INVALID_HANDLE_VALUE) {
+			printf("SetupDiGetClassDevs failed\n");
+			return;
+		}
+
+		SP_DEVINFO_DATA deviceData = { 0 };
+		deviceData.cbSize = sizeof(SP_DEVINFO_DATA);
+
+		for (unsigned int j = 0; SetupDiEnumDeviceInfo(hDevInfo, j, &deviceData); ++j) {
+			char deviceID[MAX_DEVICE_ID_LEN];
+			if (CM_Get_Device_ID(deviceData.DevInst, deviceID, MAX_DEVICE_ID_LEN, 0))
+				continue;
+
+			char* vid = strstr(deviceID, "VID_");
+			if (!vid || hdr.id_table[i].vendor != strtoul(vid+4, NULL, 16))
+				continue;
+
+			char* pid = strstr(deviceID, "PID_");
+			if (!pid || hdr.id_table[i].product != strtoul(pid+4, NULL, 16))
+				continue;
+
+			SP_INTERFACE_DEVICE_DATA interfaceData = { 0 };
+			interfaceData.cbSize = sizeof(SP_INTERFACE_DEVICE_DATA);
+			if (!SetupDiEnumDeviceInterfaces(hDevInfo, &deviceData, &GUID_DEVINTERFACE, 0, &interfaceData))
+				continue;
+
+			DWORD dwRequiredSize = 0;
+			SetupDiGetDeviceInterfaceDetail(hDevInfo, &interfaceData, 0, 0, &dwRequiredSize, 0);
+			SP_INTERFACE_DEVICE_DETAIL_DATA* pData = (SP_INTERFACE_DEVICE_DETAIL_DATA*)malloc(dwRequiredSize);
+			pData->cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
+			if (!SetupDiGetDeviceInterfaceDetail(hDevInfo, &interfaceData, pData, dwRequiredSize, 0, 0)) {
+				free(pData);
+				continue;
+			}
+
+			HANDLE hDevice = CreateFile(pData->DevicePath
+				, GENERIC_READ | GENERIC_WRITE
+				, FILE_SHARE_READ | FILE_SHARE_WRITE
+				, 0
+				, OPEN_EXISTING
+				, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED
+				, 0);
+			if (hDevice == INVALID_HANDLE_VALUE) {
+				free(pData);
+				continue;
+			}
+
+			WINUSB_INTERFACE_HANDLE hWinUSBHandle;
+			if (!WinUsb_Initialize(hDevice, &hWinUSBHandle))
+				continue;
+
+			SetupDiDestroyDeviceInfoList(hDevInfo);
+
+			printf("CM_Get_Device_ID (%s)\n", deviceID);
+			printf("device %04X:%04X opened!\n", hdr.id_table[i].vendor, hdr.id_table[i].product);
+
+			*hdev = (struct hid_device*)realloc(*hdev, (*numHdev+1) * sizeof(struct hid_device));
+			if (!*hdev) {
+				printf("out of memory\n");
+				continue;
+			}
+
+			if (*numHdev > 0)
+			{
+				//Correct all previous pointers to their new locations
+				for (int old_dev = 0; old_dev < *numHdev; old_dev++)
+				{
+					(*hdev)[old_dev].dev.parent = &((*hdev)[old_dev].dev);
+					(*hdev)[old_dev].dev.parent_usb_interface->dev = &((*hdev)[old_dev].dev);
+					(*hdev)[old_dev].dev.parent_usb_interface->parent_usb_device->dev = &((*hdev)[old_dev].dev);
+				}
+			}
+
+			struct usb_interface* intf = (struct usb_interface*)malloc(sizeof(struct usb_interface));
+			intf->cur_altsetting = (struct usb_host_interface*)malloc(sizeof(struct usb_host_interface));
+			intf->cur_altsetting->desc.bInterfaceProtocol = 0;
+
+			struct usb_device *usbdevice = (struct usb_device*)malloc(sizeof(struct usb_device));
+			usbdevice->descriptor.idVendor = hdr.id_table[i].vendor;
+			usbdevice->descriptor.idProduct = hdr.id_table[i].product;
+
+			intf->parent_usb_device = usbdevice;
+
+			(*hdev)[*numHdev].product = hdr.id_table[i].product;
+			(*hdev)[*numHdev].dev.parent = &((*hdev)[*numHdev].dev);
+			(*hdev)[*numHdev].dev.driver_data;
+			(*hdev)[*numHdev].dev.p = hWinUSBHandle;
+			(*hdev)[*numHdev].dev.parent_usb_interface = intf;
+			(*hdev)[*numHdev].dev.init_name = hdr.name;
+
+			usbdevice->dev = &((*hdev)[*numHdev].dev);
+			intf->dev = &((*hdev)[*numHdev].dev);
+
+
+			(*hdev)[*numHdev].status = 2;
+			(*hdev)[*numHdev].driver = &hdr;
+			(*hdev)[*numHdev].ll_driver = (struct hid_ll_driver*)malloc(sizeof(struct hid_ll_driver));
+			(*hdev)[*numHdev].ll_driver->parse = ll_parse;
+			(*hdev)[*numHdev].ll_driver->start = ll_start;
+			(*hdev)[*numHdev].ll_driver->stop = ll_stop;
+
+			(*hdev)[*numHdev].driver->probe(&((*hdev)[*numHdev]), &(hdr.id_table[i]));
+
+			(*numHdev)++;
+		}
+		if (!numHdev)
+			printf("device %04X:%04X NOT opened!\n", hdr.id_table[i].vendor, hdr.id_table[i].product);
+	}
+}
+
+#endif /* HID_H_ */

dependencies/openrazer-win32/linux/init.h

@@ -0,0 +1,60 @@
+#ifndef INIT_H_
+#define INIT_H_
+
+static inline int sprint_f(char* buf, const char* fmt, ...) {
+	va_list args;
+	int i;
+	va_start(args, fmt);
+	i = sprintf_s(buf, strlen(buf) - 1, fmt, args);
+	va_end(args);
+	return i;
+}
+#define sprintf sprint_f
+
+static inline int strncpy_f(char* dest, const char* source, const size_t sourceLen) {
+	return strncpy_s(dest, strlen(dest) - 1, source, sourceLen);
+}
+#define strncpy strncpy_f
+
+static inline int strcpy_f(char* dest, const char* source) {
+	return strcpy_s(dest, strlen(dest) - 1, source);
+}
+#define strcpy strcpy_f
+
+#define strdup _strdup
+
+#define KERN_WARNING
+#define KERN_ALERT
+#define KERN_CRIT
+
+#define printk printf
+
+inline unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base) {
+	return strtoul(cp, endp, base);
+}
+
+inline void usleep(__int64 usec) {
+	HANDLE timer;
+	LARGE_INTEGER ft;
+
+	ft.QuadPart = -(10 * usec); // Convert to 100 nanosecond interval, negative value indicates relative time
+
+	timer = CreateWaitableTimer(NULL, TRUE, NULL);
+	SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0);
+	WaitForSingleObject(timer, INFINITE);
+	CloseHandle(timer);
+}
+
+inline void msleep(__int64 msec) {
+	usleep(1000 * msec);
+}
+
+inline void usleep_range(__int64 usec1, __int64 usec2) {
+	usleep((usec1 + usec2) / 2);
+}
+
+inline unsigned short eflip(unsigned short val) {
+	return (val & 0xff) * 0xFF + (val >> 8);
+}
+
+#endif /* INIT_H_ */

dependencies/openrazer-win32/linux/kernel.h

@@ -0,0 +1,98 @@
+#ifndef KERNEL_H_
+#define KERNEL_H_
+
+#include <windows.h>
+
+#define DLL_INTERNAL __declspec( dllexport )
+
+#define u8 unsigned char
+#define u16 unsigned short
+#define u32 unsigned int
+#define u64 unsigned long
+
+#define __u8 unsigned char
+#define __u16 unsigned short
+#define __u32 unsigned int
+#define __u64 unsigned long
+#define uint8_t unsigned char
+#define uint16_t unsigned short
+#define uint32_t unsigned int
+#define uint64_t unsigned long
+#define __le8 unsigned char
+#define __le16 unsigned short
+#define __le32 unsigned int
+#define __le64 unsigned long
+#define __s8 signed char
+#define __s16 signed short
+#define __s32 signed int
+#define __s64 signed long
+#define uint unsigned int
+#define ulong unsigned long
+
+#define socklen_t int
+
+#define bool int
+#define true 1
+#define false 0
+
+#define size_t SIZE_T
+#define ssize_t SSIZE_T
+
+struct mutex {
+	CRITICAL_SECTION lock;
+};
+
+inline void mutex_init(struct mutex* mutex) {
+	InitializeCriticalSection(&mutex->lock);
+}
+
+inline void mutex_lock(struct mutex* mutex) {
+	EnterCriticalSection(&mutex->lock);
+}
+
+inline void mutex_unlock(struct mutex* mutex) {
+	LeaveCriticalSection(&mutex->lock);
+}
+
+inline int mutex_trylock(struct mutex* mutex) {
+	return TryEnterCriticalSection(&mutex->lock);
+}
+
+inline int mutex_is_locked(struct mutex* mutex) {
+	if (mutex_trylock(mutex)) {
+		mutex_unlock(mutex);
+		return 0;
+	}
+	else
+		return 1;
+}
+
+inline void set_bit(int nr, volatile unsigned long *addr) {
+        int *a = (int *)addr;
+        int mask;
+
+        a += nr >> 5;
+        mask = 1 << (nr & 0x1f);
+        *a |= mask;
+}
+#define __set_bit set_bit
+
+inline void clear_bit(int nr, volatile unsigned long *addr) {
+        int *a = (int *)addr;
+        int mask;
+
+        a += nr >> 5;
+        mask = 1 << (nr & 0x1f);
+        *a &= ~mask;
+}
+
+inline int test_bit(int nr, const void *addr) {
+        int *a = (int *)addr;
+        int mask;
+
+		a += nr >> 5;
+        mask = 1 << (nr & 0x1f);
+        return ((mask & *a) != 0);
+}
+
+#endif /* KERNEL_H_ */

dependencies/openrazer-win32/linux/module.h

@@ -0,0 +1,146 @@
+#ifndef MODULE_H_
+#define MODULE_H_
+
+#include <stdio.h>
+#include <Winusb.h>
+
+#define MODULE_AUTHOR( __Declaration__ )
+#define MODULE_DESCRIPTION( __Declaration__ )
+#define MODULE_VERSION( __Declaration__ )
+#define MODULE_LICENSE( __Declaration__ )
+
+#define USB_CTRL_SET_TIMEOUT    5000
+
+#define USB_DIR_OUT                     0
+#define USB_DIR_IN                      0x80
+
+#define USB_TYPE_CLASS			(0x01 << 5)
+#define USB_RECIP_INTERFACE	0x01
+
+#define usb_sndctrlpipe(u,d) 0
+#define usb_rcvctrlpipe(u,d) 0
+
+#define PATH_MAX 512
+
+struct usb_interface_descriptor {
+    unsigned char  bInterfaceProtocol;
+};
+
+struct usb_host_interface {
+	struct usb_interface_descriptor desc;
+};
+
+struct device {
+	struct device					*parent;
+	void							*p;
+	const char						*init_name;
+	void							*driver_data;
+struct usb_interface *parent_usb_interface;
+};
+
+struct usb_interface {
+	struct device* dev;
+    int num_altsetting;
+	struct usb_host_interface *cur_altsetting;
+struct usb_device *parent_usb_device;
+};
+
+struct usb_device_descriptor {
+    unsigned short idVendor;
+    unsigned short idProduct;
+};
+
+struct usb_device {
+	struct device* dev;
+    struct usb_device_descriptor descriptor;
+};
+
+inline int usb_control_msg(
+	struct usb_device *usb_dev
+	, int usb_pipe
+	, unsigned int request
+	, unsigned int request_type
+	, unsigned int value
+	, unsigned int report_index
+	, unsigned char* buf, unsigned int size
+	, unsigned int timeout)
+{
+	WINUSB_SETUP_PACKET packet;
+	packet.RequestType = request_type;
+	packet.Request = request;
+	packet.Value = value;
+	packet.Index = report_index; 
+	packet.Length = size;
+	ULONG cbSent = 0;
+	if (!WinUsb_ControlTransfer(usb_dev->dev->p, packet, buf, size, &cbSent, 0))
+		printf("WinUsb_ControlTransfer failed\n");
+
+	return cbSent;
+}
+
+
+
+inline struct usb_interface *to_usb_interface(struct device *dev) {
+	return dev->parent_usb_interface;
+}
+
+inline struct usb_device *to_usb_device(struct device *dev) {
+	return dev->parent_usb_interface->parent_usb_device;
+}
+
+inline struct usb_device *interface_to_usbdev(struct usb_interface *intf) {
+	return to_usb_device(intf->dev->parent);
+}
+
+inline void usb_disable_autosuspend(struct usb_device *usb_dev) {
+	printf("usb_disable_autosuspend\n");
+}
+
+struct device_attribute {
+	const char* name;
+	ssize_t(*show)(struct device *dev, struct device_attribute *attr, char *buf);
+	ssize_t(*store)(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
+};
+
+inline int device_create_file(struct device *device, struct device_attribute *entry) {
+	printf("device_create_file %s\n", entry->name);
+	return 0;
+}
+
+inline void device_remove_file(struct device *device, struct device_attribute *entry) {
+	printf("device_remove_file %s\n", entry->name);
+}
+
+#define HID_USB_DEVICE(ven, prod) \
+	  .vendor = (ven) \
+	, .product = (prod)
+
+
+#define __stringify(x)       #x
+
+// Hack to turn Linux device macros into API calls
+#define DEVICE_ATTR1(_device,_name, _mode, _show, _store)	\
+	struct device_attribute dev_attr_##_name; \
+	DLL_INTERNAL struct device_attribute dev##_device##_attr_##_name = {	\
+          .name = __stringify(_name)				\
+        , .show   = _show							\
+        , .store  = _store							\
+	};
+
+#define MODULE_DEVICE_TABLE(type, name)
+
+/*typedef struct hid_device_array_tag {
+	unsigned int count;
+	struct hid_device* hdev[];
+} hid_device_array;*/
+
+#define module_hid_driver(hdr) \
+DLL_INTERNAL unsigned int init_##hdr## (struct hid_device** hdevo) {	\
+	unsigned int numHdevs = 0; \
+	struct hid_device* hdev = NULL; \
+	openChromaDevice(&hdev, &numHdevs, hdr); \
+	*hdevo = hdev; \
+	return numHdevs; \
+}
+
+#endif /* MODULE_H_ */

dependencies/openrazer-win32/linux/random.h

@@ -0,0 +1,16 @@
+#ifndef RANDOM_H_
+#define RANDOM_H_
+
+static inline void get_random_bytes(void* rand_ptr, unsigned int rand_size) {
+	char failed = 0;
+	static HCRYPTPROV prov = 0;
+	if (prov == 0) {
+		if (!CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, 0))
+			failed = 1;
+	}
+	if (!failed && !CryptGenRandom(prov, rand_size, (unsigned char*)rand_ptr))
+		printf("get_random_bytes failed\n");
+}
+
+
+#endif /* RANDOM_H_ */

dependencies/openrazer-win32/linux/slab.h

@@ -0,0 +1,31 @@
+#ifndef SLAB_H_
+#define SLAB_H_
+
+typedef enum {
+	GFP_KERNEL,
+	GFP_ATOMIC,
+	__GFP_HIGHMEM,
+	__GFP_HIGH
+} gfp_t;
+
+static inline void *kzalloc(size_t s, gfp_t gfp) {
+	void *p = malloc(s);
+
+	memset(p, 0, s);
+	return p;
+}
+
+inline void *kmemdup(const void *src, size_t len, gfp_t gfp) {
+	void *p;
+	p = malloc(len);
+	if (p)
+		memcpy(p, src, len);
+	return p;
+}
+
+static inline void kfree(const void* p) {
+	free((void*)p);
+}
+
+
+#endif /* SLAB_H_ */

dependencies/openrazer-win32/linux/usb/input.h

@@ -0,0 +1,539 @@
+#ifndef INPUT_H_
+#define INPUT_H_
+
+#include <stdio.h>
+#include <windows.h>
+
+#define uint unsigned int
+#define ulong unsigned long
+#define u8 unsigned char
+#define u16 unsigned short
+#define u32 unsigned int
+#define u64 unsigned long
+
+#define ABS_VOLUME              0x20
+
+//input-event-codes.h
+#define KEY_RESERVED            0
+#define KEY_ESC                 1
+#define KEY_1                   2
+#define KEY_2                   3
+#define KEY_3                   4
+#define KEY_4                   5
+#define KEY_5                   6
+#define KEY_6                   7
+#define KEY_7                   8
+#define KEY_8                   9
+#define KEY_9                   10
+#define KEY_0                   11
+#define KEY_MINUS               12
+#define KEY_EQUAL               13
+#define KEY_BACKSPACE           14
+#define KEY_TAB                 15
+#define KEY_Q                   16
+#define KEY_W                   17
+#define KEY_E                   18
+#define KEY_R                   19
+#define KEY_T                   20
+#define KEY_Y                   21
+#define KEY_U                   22
+#define KEY_I                   23
+#define KEY_O                   24
+#define KEY_P                   25
+#define KEY_LEFTBRACE           26
+#define KEY_RIGHTBRACE          27
+#define KEY_ENTER               28
+#define KEY_LEFTCTRL            29
+#define KEY_A                   30
+#define KEY_S                   31
+#define KEY_D                   32
+#define KEY_F                   33
+#define KEY_G                   34
+#define KEY_H                   35
+#define KEY_J                   36
+#define KEY_K                   37
+#define KEY_L                   38
+#define KEY_SEMICOLON           39
+#define KEY_APOSTROPHE          40
+#define KEY_GRAVE               41
+#define KEY_LEFTSHIFT           42
+#define KEY_BACKSLASH           43
+#define KEY_Z                   44
+#define KEY_X                   45
+#define KEY_C                   46
+#define KEY_V                   47
+#define KEY_B                   48
+#define KEY_N                   49
+#define KEY_M                   50
+#define KEY_COMMA               51
+#define KEY_DOT                 52
+#define KEY_SLASH               53
+#define KEY_RIGHTSHIFT          54
+#define KEY_KPASTERISK          55
+#define KEY_LEFTALT             56
+#define KEY_SPACE               57
+#define KEY_CAPSLOCK            58
+#define KEY_F1                  59
+#define KEY_F2                  60
+#define KEY_F3                  61
+#define KEY_F4                  62
+#define KEY_F5                  63
+#define KEY_F6                  64
+#define KEY_F7                  65
+#define KEY_F8                  66
+#define KEY_F9                  67
+#define KEY_F10                 68
+#define KEY_NUMLOCK             69
+#define KEY_SCROLLLOCK          70
+#define KEY_KP7                 71
+#define KEY_KP8                 72
+#define KEY_KP9                 73
+#define KEY_KPMINUS             74
+#define KEY_KP4                 75
+#define KEY_KP5                 76
+#define KEY_KP6                 77
+#define KEY_KPPLUS              78
+#define KEY_KP1                 79
+#define KEY_KP2                 80
+#define KEY_KP3                 81
+#define KEY_KP0                 82
+#define KEY_KPDOT               83
+
+#define KEY_ZENKAKUHANKAKU      85
+#define KEY_102ND               86
+#define KEY_F11                 87
+#define KEY_F12                 88
+#define KEY_RO                  89
+#define KEY_KATAKANA            90
+#define KEY_HIRAGANA            91
+#define KEY_HENKAN              92
+#define KEY_KATAKANAHIRAGANA    93
+#define KEY_MUHENKAN            94
+#define KEY_KPJPCOMMA           95
+#define KEY_KPENTER             96
+#define KEY_RIGHTCTRL           97
+#define KEY_KPSLASH             98
+#define KEY_SYSRQ               99
+#define KEY_RIGHTALT            100
+#define KEY_LINEFEED            101
+#define KEY_HOME                102
+#define KEY_UP                  103
+#define KEY_PAGEUP              104
+#define KEY_LEFT                105
+#define KEY_RIGHT               106
+#define KEY_END                 107
+#define KEY_DOWN                108
+#define KEY_PAGEDOWN            109
+#define KEY_INSERT              110
+#define KEY_DELETE              111
+#define KEY_MACRO               112
+#define KEY_MUTE                113
+#define KEY_VOLUMEDOWN          114
+#define KEY_VOLUMEUP            115
+#define KEY_POWER               116     /* SC System Power Down */
+#define KEY_KPEQUAL             117
+#define KEY_KPPLUSMINUS         118
+#define KEY_PAUSE               119
+#define KEY_SCALE               120     /* AL Compiz Scale (Expose) */
+
+#define KEY_KPCOMMA             121
+#define KEY_HANGEUL             122
+#define KEY_HANGUEL             KEY_HANGEUL
+#define KEY_HANJA               123
+#define KEY_YEN                 124
+#define KEY_LEFTMETA            125
+#define KEY_RIGHTMETA           126
+#define KEY_COMPOSE             127
+
+#define KEY_STOP                128     /* AC Stop */
+#define KEY_AGAIN               129
+#define KEY_PROPS               130     /* AC Properties */
+#define KEY_UNDO                131     /* AC Undo */
+#define KEY_FRONT               132
+#define KEY_COPY                133     /* AC Copy */
+#define KEY_OPEN                134     /* AC Open */
+#define KEY_PASTE               135     /* AC Paste */
+#define KEY_FIND                136     /* AC Search */
+#define KEY_CUT                 137     /* AC Cut */
+#define KEY_HELP                138     /* AL Integrated Help Center */
+#define KEY_MENU                139     /* Menu (show menu) */
+#define KEY_CALC                140     /* AL Calculator */
+#define KEY_SETUP               141
+#define KEY_SLEEP               142     /* SC System Sleep */
+#define KEY_WAKEUP              143     /* System Wake Up */
+#define KEY_FILE                144     /* AL Local Machine Browser */
+#define KEY_SENDFILE            145
+#define KEY_DELETEFILE          146
+#define KEY_XFER                147
+#define KEY_PROG1               148
+#define KEY_PROG2               149
+#define KEY_WWW                 150     /* AL Internet Browser */
+#define KEY_MSDOS               151
+#define KEY_COFFEE              152     /* AL Terminal Lock/Screensaver */
+#define KEY_SCREENLOCK          KEY_COFFEE
+#define KEY_DIRECTION           153
+#define KEY_CYCLEWINDOWS        154
+#define KEY_MAIL                155
+#define KEY_BOOKMARKS           156     /* AC Bookmarks */
+#define KEY_COMPUTER            157
+#define KEY_BACK                158     /* AC Back */
+#define KEY_FORWARD             159     /* AC Forward */
+#define KEY_CLOSECD             160
+#define KEY_EJECTCD             161
+#define KEY_EJECTCLOSECD        162
+#define KEY_NEXTSONG            163
+#define KEY_PLAYPAUSE           164
+#define KEY_PREVIOUSSONG        165
+#define KEY_STOPCD              166
+#define KEY_RECORD              167
+#define KEY_REWIND              168
+#define KEY_PHONE               169     /* Media Select Telephone */
+#define KEY_ISO                 170
+#define KEY_CONFIG              171     /* AL Consumer Control Configuration */
+#define KEY_HOMEPAGE            172     /* AC Home */
+#define KEY_REFRESH             173     /* AC Refresh */
+#define KEY_EXIT                174     /* AC Exit */
+#define KEY_MOVE                175
+#define KEY_EDIT                176
+#define KEY_SCROLLUP            177
+#define KEY_SCROLLDOWN          178
+#define KEY_KPLEFTPAREN         179
+#define KEY_KPRIGHTPAREN        180
+#define KEY_NEW                 181     /* AC New */
+#define KEY_REDO                182     /* AC Redo/Repeat */
+
+#define KEY_F13                 183
+#define KEY_F14                 184
+#define KEY_F15                 185
+#define KEY_F16                 186
+#define KEY_F17                 187
+#define KEY_F18                 188
+#define KEY_F19                 189
+#define KEY_F20                 190
+#define KEY_F21                 191
+#define KEY_F22                 192
+#define KEY_F23                 193
+#define KEY_F24                 194
+
+#define KEY_PLAYCD              200
+#define KEY_PAUSECD             201
+#define KEY_PROG3               202
+#define KEY_PROG4               203
+#define KEY_DASHBOARD           204     /* AL Dashboard */
+#define KEY_SUSPEND             205
+#define KEY_CLOSE               206     /* AC Close */
+#define KEY_PLAY                207
+#define KEY_FASTFORWARD         208
+#define KEY_BASSBOOST           209
+#define KEY_PRINT               210     /* AC Print */
+#define KEY_HP                  211
+#define KEY_CAMERA              212
+#define KEY_SOUND               213
+#define KEY_QUESTION            214
+#define KEY_EMAIL               215
+#define KEY_CHAT                216
+#define KEY_SEARCH              217
+#define KEY_CONNECT             218
+#define KEY_FINANCE             219     /* AL Checkbook/Finance */
+#define KEY_SPORT               220
+#define KEY_SHOP                221
+#define KEY_ALTERASE            222
+#define KEY_CANCEL              223     /* AC Cancel */
+#define KEY_BRIGHTNESSDOWN      224
+#define KEY_BRIGHTNESSUP        225
+#define KEY_MEDIA               226
+
+#define KEY_SWITCHVIDEOMODE     227     /* Cycle between available video
+                                           outputs (Monitor/LCD/TV-out/etc) */
+#define KEY_KBDILLUMTOGGLE      228
+#define KEY_KBDILLUMDOWN        229
+#define KEY_KBDILLUMUP          230
+
+#define KEY_SEND                231     /* AC Send */
+#define KEY_REPLY               232     /* AC Reply */
+#define KEY_FORWARDMAIL         233     /* AC Forward Msg */
+#define KEY_SAVE                234     /* AC Save */
+#define KEY_DOCUMENTS           235
+
+#define KEY_BATTERY             236
+
+#define KEY_BLUETOOTH           237
+#define KEY_WLAN                238
+#define KEY_UWB                 239
+
+#define KEY_UNKNOWN             240
+
+#define KEY_VIDEO_NEXT          241     /* drive next video source */
+#define KEY_VIDEO_PREV          242     /* drive previous video source */
+#define KEY_BRIGHTNESS_CYCLE    243     /* brightness up, after max is min */
+#define KEY_BRIGHTNESS_ZERO     244     /* brightness off, use ambient */
+#define KEY_DISPLAY_OFF         245     /* display device to off state */
+
+#define KEY_WIMAX               246
+
+/* Range 248 - 255 is reserved for special needs of AT keyboard driver */
+
+#define BTN_MISC                0x100
+#define BTN_0                   0x100
+#define BTN_1                   0x101
+#define BTN_2                   0x102
+#define BTN_3                   0x103
+#define BTN_4                   0x104
+#define BTN_5                   0x105
+#define BTN_6                   0x106
+#define BTN_7                   0x107
+#define BTN_8                   0x108
+#define BTN_9                   0x109
+
+#define BTN_MOUSE               0x110
+#define BTN_LEFT                0x110
+#define BTN_RIGHT               0x111
+#define BTN_MIDDLE              0x112
+#define BTN_SIDE                0x113
+#define BTN_EXTRA               0x114
+#define BTN_FORWARD             0x115
+#define BTN_BACK                0x116
+#define BTN_TASK                0x117
+
+#define BTN_JOYSTICK            0x120
+#define BTN_TRIGGER             0x120
+#define BTN_THUMB               0x121
+#define BTN_THUMB2              0x122
+#define BTN_TOP                 0x123
+#define BTN_TOP2                0x124
+#define BTN_PINKIE              0x125
+#define BTN_BASE                0x126
+#define BTN_BASE2               0x127
+#define BTN_BASE3               0x128
+#define BTN_BASE4               0x129
+#define BTN_BASE5               0x12a
+#define BTN_BASE6               0x12b
+#define BTN_DEAD                0x12f
+
+#define BTN_GAMEPAD             0x130
+#define BTN_A                   0x130
+#define BTN_B                   0x131
+#define BTN_C                   0x132
+#define BTN_X                   0x133
+#define BTN_Y                   0x134
+#define BTN_Z                   0x135
+#define BTN_TL                  0x136
+#define BTN_TR                  0x137
+#define BTN_TL2                 0x138
+#define BTN_TR2                 0x139
+#define BTN_SELECT              0x13a
+#define BTN_START               0x13b
+#define BTN_MODE                0x13c
+#define BTN_THUMBL              0x13d
+#define BTN_THUMBR              0x13e
+
+#define BTN_DIGI                0x140
+#define BTN_TOOL_PEN            0x140
+#define BTN_TOOL_RUBBER         0x141
+#define BTN_TOOL_BRUSH          0x142
+#define BTN_TOOL_PENCIL         0x143
+#define BTN_TOOL_AIRBRUSH       0x144
+#define BTN_TOOL_FINGER         0x145
+#define BTN_TOOL_MOUSE          0x146
+#define BTN_TOOL_LENS           0x147
+#define BTN_TOUCH               0x14a
+#define BTN_STYLUS              0x14b
+#define BTN_STYLUS2             0x14c
+#define BTN_TOOL_DOUBLETAP      0x14d
+#define BTN_TOOL_TRIPLETAP      0x14e
+#define BTN_TOOL_QUADTAP        0x14f   /* Four fingers on trackpad */
+
+#define BTN_WHEEL               0x150
+#define BTN_GEAR_DOWN           0x150
+#define BTN_GEAR_UP             0x151
+
+#define KEY_OK                  0x160
+#define KEY_SELECT              0x161
+#define KEY_GOTO                0x162
+#define KEY_CLEAR               0x163
+#define KEY_POWER2              0x164
+#define KEY_OPTION              0x165
+#define KEY_INFO                0x166   /* AL OEM Features/Tips/Tutorial */
+#define KEY_TIME                0x167
+#define KEY_VENDOR              0x168
+#define KEY_ARCHIVE             0x169
+#define KEY_PROGRAM             0x16a   /* Media Select Program Guide */
+#define KEY_CHANNEL             0x16b
+#define KEY_FAVORITES           0x16c
+#define KEY_EPG                 0x16d
+#define KEY_PVR                 0x16e   /* Media Select Home */
+#define KEY_MHP                 0x16f
+#define KEY_LANGUAGE            0x170
+#define KEY_TITLE               0x171
+#define KEY_SUBTITLE            0x172
+#define KEY_ANGLE               0x173
+#define KEY_ZOOM                0x174
+#define KEY_MODE                0x175
+#define KEY_KEYBOARD            0x176
+#define KEY_SCREEN              0x177
+#define KEY_PC                  0x178   /* Media Select Computer */
+#define KEY_TV                  0x179   /* Media Select TV */
+#define KEY_TV2                 0x17a   /* Media Select Cable */
+#define KEY_VCR                 0x17b   /* Media Select VCR */
+#define KEY_VCR2                0x17c   /* VCR Plus */
+#define KEY_SAT                 0x17d   /* Media Select Satellite */
+#define KEY_SAT2                0x17e
+#define KEY_CD                  0x17f   /* Media Select CD */
+#define KEY_TAPE                0x180   /* Media Select Tape */
+#define KEY_RADIO               0x181
+#define KEY_TUNER               0x182   /* Media Select Tuner */
+#define KEY_PLAYER              0x183
+#define KEY_TEXT                0x184
+#define KEY_DVD                 0x185   /* Media Select DVD */
+#define KEY_AUX                 0x186
+#define KEY_MP3                 0x187
+#define KEY_AUDIO               0x188
+#define KEY_VIDEO               0x189
+#define KEY_DIRECTORY           0x18a
+#define KEY_LIST                0x18b
+#define KEY_MEMO                0x18c   /* Media Select Messages */
+#define KEY_CALENDAR            0x18d
+#define KEY_RED                 0x18e
+#define KEY_GREEN               0x18f
+#define KEY_YELLOW              0x190
+#define KEY_BLUE                0x191
+#define KEY_CHANNELUP           0x192   /* Channel Increment */
+#define KEY_CHANNELDOWN         0x193   /* Channel Decrement */
+#define KEY_FIRST               0x194
+#define KEY_LAST                0x195   /* Recall Last */
+#define KEY_AB                  0x196
+#define KEY_NEXT                0x197
+#define KEY_RESTART             0x198
+#define KEY_SLOW                0x199
+#define KEY_SHUFFLE             0x19a
+#define KEY_BREAK               0x19b
+#define KEY_PREVIOUS            0x19c
+#define KEY_DIGITS              0x19d
+#define KEY_TEEN                0x19e
+#define KEY_TWEN                0x19f
+#define KEY_VIDEOPHONE          0x1a0   /* Media Select Video Phone */
+#define KEY_GAMES               0x1a1   /* Media Select Games */
+#define KEY_ZOOMIN              0x1a2   /* AC Zoom In */
+#define KEY_ZOOMOUT             0x1a3   /* AC Zoom Out */
+#define KEY_ZOOMRESET           0x1a4   /* AC Zoom */
+#define KEY_WORDPROCESSOR       0x1a5   /* AL Word Processor */
+#define KEY_EDITOR              0x1a6   /* AL Text Editor */
+#define KEY_SPREADSHEET         0x1a7   /* AL Spreadsheet */
+#define KEY_GRAPHICSEDITOR      0x1a8   /* AL Graphics Editor */
+#define KEY_PRESENTATION        0x1a9   /* AL Presentation App */
+#define KEY_DATABASE            0x1aa   /* AL Database App */
+#define KEY_NEWS                0x1ab   /* AL Newsreader */
+#define KEY_VOICEMAIL           0x1ac   /* AL Voicemail */
+#define KEY_ADDRESSBOOK         0x1ad   /* AL Contacts/Address Book */
+#define KEY_MESSENGER           0x1ae   /* AL Instant Messaging */
+#define KEY_DISPLAYTOGGLE       0x1af   /* Turn display (LCD) on and off */
+#define KEY_SPELLCHECK          0x1b0   /* AL Spell Check */
+#define KEY_LOGOFF              0x1b1   /* AL Logoff */
+
+#define KEY_DOLLAR              0x1b2
+#define KEY_EURO                0x1b3
+
+#define KEY_FRAMEBACK           0x1b4   /* Consumer - transport controls */
+#define KEY_FRAMEFORWARD        0x1b5
+#define KEY_CONTEXT_MENU        0x1b6   /* GenDesc - system context menu */
+#define KEY_MEDIA_REPEAT        0x1b7   /* Consumer - transport control */
+
+#define KEY_DEL_EOL             0x1c0
+#define KEY_DEL_EOS             0x1c1
+#define KEY_INS_LINE            0x1c2
+#define KEY_DEL_LINE            0x1c3
+
+#define KEY_FN                  0x1d0
+#define KEY_FN_ESC              0x1d1
+#define KEY_FN_F1               0x1d2
+#define KEY_FN_F2               0x1d3
+#define KEY_FN_F3               0x1d4
+#define KEY_FN_F4               0x1d5
+#define KEY_FN_F5               0x1d6
+#define KEY_FN_F6               0x1d7
+#define KEY_FN_F7               0x1d8
+#define KEY_FN_F8               0x1d9
+#define KEY_FN_F9               0x1da
+#define KEY_FN_F10              0x1db
+#define KEY_FN_F11              0x1dc
+#define KEY_FN_F12              0x1dd
+#define KEY_FN_1                0x1de
+#define KEY_FN_2                0x1df
+#define KEY_FN_D                0x1e0
+#define KEY_FN_E                0x1e1
+#define KEY_FN_F                0x1e2
+#define KEY_FN_S                0x1e3
+#define KEY_FN_B                0x1e4
+
+#define KEY_BRL_DOT1            0x1f1
+#define KEY_BRL_DOT2            0x1f2
+#define KEY_BRL_DOT3            0x1f3
+#define KEY_BRL_DOT4            0x1f4
+#define KEY_BRL_DOT5            0x1f5
+#define KEY_BRL_DOT6            0x1f6
+#define KEY_BRL_DOT7            0x1f7
+#define KEY_BRL_DOT8            0x1f8
+#define KEY_BRL_DOT9            0x1f9
+#define KEY_BRL_DOT10           0x1fa
+
+#define KEY_NUMERIC_0           0x200   /* used by phones, remote controls, */
+#define KEY_NUMERIC_1           0x201   /* and other keypads */
+#define KEY_NUMERIC_2           0x202
+#define KEY_NUMERIC_3           0x203
+#define KEY_NUMERIC_4           0x204
+#define KEY_NUMERIC_5           0x205
+#define KEY_NUMERIC_6           0x206
+#define KEY_NUMERIC_7           0x207
+#define KEY_NUMERIC_8           0x208
+#define KEY_NUMERIC_9           0x209
+#define KEY_NUMERIC_STAR        0x20a
+#define KEY_NUMERIC_POUND       0x20b
+
+/* We avoid low common keys in module aliases so they don't get huge. */
+#define KEY_MIN_INTERESTING     KEY_MUTE
+#define KEY_MAX                 0x2ff
+#define KEY_CNT                 (KEY_MAX+1)
+
+#define EV_SYN                  0x00
+#define EV_KEY                  0x01
+#define EV_REL                  0x02
+#define EV_ABS                  0x03
+#define EV_MSC                  0x04
+#define EV_SW                   0x05
+#define EV_LED                  0x11
+#define EV_SND                  0x12
+#define EV_REP                  0x14
+#define EV_FF                   0x15
+#define EV_PWR                  0x16
+#define EV_FF_STATUS            0x17
+#define EV_MAX                  0x1f
+#define EV_CNT                  (EV_MAX+1)
+
+#define SYN_REPORT              0
+
+#define BITS_PER_BYTE           8
+#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
+#define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
+#define DECLARE_BITMAP(name,bits) unsigned long name[BITS_TO_LONGS(bits)]
+
+struct input_dev {
+        const char *name;
+        const char *phys;
+		unsigned long evbit[BITS_TO_LONGS(EV_CNT)];
+        unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];
+};
+
+static inline void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) {
+	printf("input_event\n");
+}
+
+static inline void input_report_key(struct input_dev *dev, unsigned int code, int value) {
+	input_event(dev, EV_KEY, code, value);
+}
+
+static inline void input_sync(struct input_dev *dev) {
+	input_event(dev, EV_SYN, SYN_REPORT, 0);
+}
+
+
+#endif /* INPUT_H_ */

dependencies/razer-chroma-2.9.0/inc/RzChromaLinkAPI.h

@@ -1,62 +0,0 @@
-//! \file RzChromaLinkAPI.h
-//! \brief Exported APIs.
-
-#ifndef _RZCHROMALINKAPI_H_
-#define _RZCHROMALINKAPI_H_
-
-#pragma once
-
-#include "RzErrors.h"
-#include "RzChromaSDKTypes.h"
-
-using namespace ChromaSDK;
-
-// Callback funtion
-typedef LONG(*LPCHROMALINKPROC)(ChromaLink::EFFECT_TYPE Effect, PRZPARAM pData);
-
-// Exported functions
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-    /*!
-    * Initialize Chroma Link API.
-    * @return <b>RZRESULT_ALREADY_INITIALIZED</b>: Chroma Link API has already been initialized.
-    * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-    */
-    RZRESULT Init(ChromaSDK::APPINFOTYPE AppInfo);
-
-    /*!
-    * UnInitialize Chroma API.
-    * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-    */
-    RZRESULT UnInit(void);
-
-    /*!
-    * Register for Chroma Link effect events.
-    * @param[in] lpFunc Callback function.
-    * @return <b>ERROR_INVALID_PARAMETER</b>: lpFunc is invalid.
-    * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-    * @remark 
-    * - <b>CHROMA_NONE</b> : This event will be sent when there are no more Chroma Link events. 
-    *                        Clients can resume their own lighting effects.
-    * - <b>CHROMA_CUSTOM</b> : This event will be sent when there is a ChromaSDK::ChromaLink::CHROMA_CUSTOM effect event.
-    *                          pData is casted to ChromaSDK::ChromaLink::CUSTOM_EFFECT_TYPE.
-    *                          The colors of each (5) LEDs can be accessed from the array.
-    * - <b>CHROMA_STATIC</b> : This event will be sent when there is a ChromaSDK::ChromaLink::CHROMA_STATIC effect event.
-    *                          pData is casted to ChromaSDK::ChromaLink::STATIC_EFFECT_TYPE.
-    *                          The color can be accessed from the structure.
-    */
-    RZRESULT RegisterEventNotification(LPCHROMALINKPROC lpFunc);
-
-    /*!
-    * Register for Chroma Link effect events.
-    * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-    */
-    RZRESULT UnregisterEventNotification(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // _RZCHROMALINKAPI_H_

dependencies/razer-chroma-2.9.0/inc/RzChromaSDK.h

@@ -1,189 +0,0 @@
-
-//! \file RzChromaSDK.h
-//! \brief Exported APIs.
-
-#ifndef _RZCHROMASDK_H_
-#define _RZCHROMASDK_H_
-
-#pragma once
-
-#include "RzErrors.h"
-#include "RzChromaSDKDefines.h"
-#include "RzChromaSDKTypes.h"
-
-using namespace ChromaSDK;
-using namespace ChromaSDK::Keyboard;
-using namespace ChromaSDK::Mouse;
-using namespace ChromaSDK::Headset;
-using namespace ChromaSDK::Mousepad;
-using namespace ChromaSDK::Keypad;
-using namespace ChromaSDK::ChromaLink;
-
-// Exported functions
-#ifdef __cplusplus
-extern "C" 
-{
-#endif
-
-    /*!
-     * Initialize Chroma SDK.
-     * @return <b>RZRESULT_SERVICE_NOT_ACTIVE</b>: Chroma SDK Service not running.
-     * @return <b>RZRESULT_ALREADY_INITIALIZED</b>: Chroma SDK has already been initialized.
-     * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-     */
-    RZRESULT Init(void);
-
-    /*!
-     * UnInitialize Chroma SDK.
-     * @return <b>RZRESULT_NOT_VALID_STATE</b>: Chroma SDK not in a valid state. For every Init() call there should be a corresponding UnInit().
-     * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-     */
-    RZRESULT UnInit(void);
-
-    /*! 
-     * Create generic effect for specific or all devices.
-     * @param[in] DeviceId Device Id defined in RzChromaSDKDefines.h
-     * @param[in] Effect Standard effect type.
-     * @param[in] pParam Pointer to a parameter type specified by Effect.
-     * @param[in,out] pEffectId Valid effect Id if successful. Set it to NULL if not required.
-     * @return <b>RZRESULT_NOT_VALID_STATE</b>: Chroma SDK not in a valid state. Did you forgot to call Init()?
-     * @return <b>RZRESULT_INVALID_PARAMETER</b>: Invalid parameter.
-     * @return <b>RZRESULT_DEVICE_NOT_AVAILABLE</b>: Device not supported.
-     * @return <b>RZRESULT_NOT_SUPPORTED</b>: Effect not supported for this device.
-     * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-     */
-    RZRESULT CreateEffect(RZDEVICEID DeviceId, ChromaSDK::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID *pEffectId);
-
-    /*! 
-     * Create keyboard effect.
-     * @param[in] Effect Keyboard effect type.
-     * @param[in] pParam Pointer to a parameter type specified by Effect.
-     * @param[in,out] pEffectId Valid effect Id if successful. Set it to NULL if not required.
-     * @return <b>RZRESULT_NOT_VALID_STATE</b>: Chroma SDK not in a valid state. Did you forgot to call Init()?
-     * @return <b>RZRESULT_INVALID_PARAMETER</b>: Invalid parameter.
-     * @return <b>RZRESULT_NOT_SUPPORTED</b>: Effect not supported for this device.
-     * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-     */
-    RZRESULT CreateKeyboardEffect(ChromaSDK::Keyboard::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID *pEffectId);
-
-    /*! 
-     * Create mouse effect.
-     * @param[in] Effect Mouse effect type.
-     * @param[in] pParam Pointer to a parameter type specified by Effect.
-     * @param[in,out] pEffectId Valid effect Id if successful. Set it to NULL if not required.
-     * @return <b>RZRESULT_NOT_VALID_STATE</b>: Chroma SDK not in a valid state. Did you forgot to call Init()?
-     * @return <b>RZRESULT_INVALID_PARAMETER</b>: Invalid parameter.
-     * @return <b>RZRESULT_NOT_SUPPORTED</b>: Effect not supported for this device.
-     * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-     */
-    RZRESULT CreateMouseEffect(ChromaSDK::Mouse::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID *pEffectId);
-
-    /*! 
-     * Create headset effect.
-     * @param[in] Effect Headset effect type.
-     * @param[in] pParam Pointer to a parameter type specified by Effect defined in RzChromaSDKTypes.h
-     * @param[in,out] pEffectId Valid effect Id if successful. Set it to NULL if not required.
-     * @return <b>RZRESULT_NOT_VALID_STATE</b>: Chroma SDK not in a valid state. Did you forgot to call Init()?
-     * @return <b>RZRESULT_INVALID_PARAMETER</b>: Invalid parameter.
-     * @return <b>RZRESULT_NOT_SUPPORTED</b>: Effect not supported for this device.
-     * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-     */
-    RZRESULT CreateHeadsetEffect(ChromaSDK::Headset::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID *pEffectId);
-
-    /*! 
-     * Create mousepad effect.
-     * @param[in] Effect Mousemat effect type.
-     * @param[in] pParam Pointer to a parameter type specified by Effect defined in RzChromaSDKTypes.h
-     * @param[in,out] pEffectId Valid effect Id if successful. Set it to NULL if not required.
-     * @return <b>RZRESULT_NOT_VALID_STATE</b>: Chroma SDK not in a valid state. Did you forgot to call Init()?
-     * @return <b>RZRESULT_INVALID_PARAMETER</b>: Invalid parameter.
-     * @return <b>RZRESULT_NOT_SUPPORTED</b>: Effect not supported for this device.
-     * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-     */
-    RZRESULT CreateMousepadEffect(ChromaSDK::Mousepad::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID *pEffectId);
-
-    /*! 
-     * Create keypad effect.
-     * @param[in] Effect Keypad effect type.
-     * @param[in] pParam Pointer to a parameter type specified by Effect defined in RzChromaSDKTypes.h
-     * @param[in,out] pEffectId Valid effect Id if successful. Set it to NULL if not required.
-     * @return <b>RZRESULT_NOT_VALID_STATE</b>: Chroma SDK not in a valid state. Did you forgot to call Init()?
-     * @return <b>RZRESULT_INVALID_PARAMETER</b>: Invalid parameter.
-     * @return <b>RZRESULT_NOT_SUPPORTED</b>: Effect not supported for this device.
-     * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-     */
-    RZRESULT CreateKeypadEffect(ChromaSDK::Keypad::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID *pEffectId);
-
-    /*!
-    * Create effects on Chroma Linked devices.
-    * @param[in] Effect Chroma Link effect type.
-    * @param[in] pParam Pointer to a parameter type specified by Effect defined in RzChromaSDKTypes.h
-    * @param[in,out] pEffectId Valid effect Id if successful. Set it to NULL if not required.
-    * @return <b>RZRESULT_NOT_VALID_STATE</b>: Chroma SDK not in a valid state. Did you forgot to call Init()?
-    * @return <b>RZRESULT_INVALID_PARAMETER</b>: Invalid parameter.
-    * @return <b>RZRESULT_NOT_SUPPORTED</b>: Effect not supported for this device.
-    * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-    */
-    RZRESULT CreateChromaLinkEffect(ChromaSDK::ChromaLink::EFFECT_TYPE Effect, PRZPARAM pParam, RZEFFECTID *pEffectId);
-
-    /*! 
-     * Delete effect
-     * @param[in] EffectId Id of the effect that needs to be deleted.
-     * @return <b>RZRESULT_NOT_VALID_STATE</b>: Chroma SDK not in a valid state. Did you forgot to call Init()?
-     * @return <b>RZRESULT_NOT_FOUND</b>: Effect Id not found.
-     * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-     */
-    RZRESULT DeleteEffect(RZEFFECTID EffectId);
-
-    /*! 
-     * Set effect.
-     * @param[in] EffectId Id of the effect that needs to be set.
-     * @return <b>RZRESULT_NOT_VALID_STATE</b>: Chroma SDK not in a valid state. Did you forgot to call Init()?
-     * @return <b>RZRESULT_ACCESS_DENIED</b>: No permision to access device.
-     * @return <b>RZRESULT_NOT_FOUND</b>: Effect Id not found.
-     * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-     */
-    RZRESULT SetEffect(RZEFFECTID EffectId);
-
-    /*! 
-     * Register for event notification.
-     * @param[in] hWnd Application window handle.
-     * @return <b>RZRESULT_NOT_VALID_STATE</b>: Chroma SDK not in a valid state. Did you forgot to call Init()?
-     * @return <b>RZRESULT_ALREADY_INITIALIZED</b>: Invalid Windows handle.
-     * @return <b>RZRESULT_INVALID_PARAMETER</b>: Invalid parameter.
-     * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-     * @remark <b>WM_CHROMA_EVENT</b> will be sent if there is an event.
-     * @remark 
-     * - \c <b>wParam</b> = 1 : Chroma SDK support. 
-     *  - \c <b>lParam</b> = 1 : Enabled.
-     *  - \c <b>lParam</b> = 0 : Disabled. 
-     * - \c <b>wParam</b> = 2 : Access to device.
-     *  - \c <b>lParam</b> = 1 : Granted accessible.
-     *  - \c <b>lParam</b> = 0 = Access revoked.
-     * - \c <b>wParam</b> = 3 : Application state. 
-     *  - \c <b>lParam</b> = 1 : Enabled.
-     *  - \c <b>lParam</b> = 0 = Disabled.
-     */
-    RZRESULT RegisterEventNotification(HWND hWnd);
-
-    /*!
-     * Un-register for event notification.
-     * @return <b>RZRESULT_NOT_VALID_STATE</b>: Internal state is not valid. There was no event registered.
-     * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-     */
-    RZRESULT UnregisterEventNotification();
-
-    /*!
-     * Query for device information.
-     * @param[in] DeviceId Device id found in RzChromaSDKDefines.h
-     * @param[out] DeviceInfo Contains device information specified by DeviceId.
-     * @return <b>RZRESULT_DEVICE_NOT_AVAILABLE</b>: Device not supported.
-     * @return For other error codes, please refer to [Windows System Error Codes](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx) from Windows SDK (WinError.h).
-     */
-    RZRESULT QueryDevice(RZDEVICEID DeviceId, DEVICE_INFO_TYPE &DeviceInfo);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

dependencies/razer-chroma-2.9.0/inc/RzChromaSDKDefines.h

@@ -1,182 +0,0 @@
-//! \file RzChromaSDKDefines.h
-//! \brief Definitions of global and static variables.
-
-#ifndef _RZSCHROMADKDEFINES_H_
-#define _RZSCHROMADKDEFINES_H_
-
-#pragma once
-
-#ifndef GUID_DEFINED
-#include <Guiddef.h>
-#endif
-
-namespace ChromaSDK
-{
-    // Keyboards
-    //! Razer Blackwidow Chroma device.
-    // {2EA1BB63-CA28-428D-9F06-196B88330BBB}
-    static const GUID BLACKWIDOW_CHROMA = 
-    { 0x2ea1bb63, 0xca28, 0x428d, { 0x9f, 0x06, 0x19, 0x6b, 0x88, 0x33, 0x0b, 0xbb } }; 
-
-    //! Razer Blackwidow Chroma Tournament Edition device.
-    // {ED1C1B82-BFBE-418F-B49D-D03F05B149DF}
-    static const GUID BLACKWIDOW_CHROMA_TE = 
-    { 0xed1c1b82, 0xbfbe, 0x418f, { 0xb4, 0x9d, 0xd0, 0x3f, 0x5, 0xb1, 0x49, 0xdf } };
-
-    //! Razer Deathstalker device.
-    // {18C5AD9B-4326-4828-92C4-2669A66D2283}
-    static const GUID DEATHSTALKER_CHROMA = 
-    { 0x18c5ad9b, 0x4326, 0x4828, { 0x92, 0xc4, 0x26, 0x69, 0xa6, 0x6d, 0x22, 0x83 } };
-
-    //! Overwatch Keyboard.
-    // {872AB2A9-7959-4478-9FED-15F6186E72E4}
-    static const GUID OVERWATCH_KEYBOARD = 
-    { 0x872ab2a9, 0x7959, 0x4478, { 0x9f, 0xed, 0x15, 0xf6, 0x18, 0x6e, 0x72, 0xe4 } };
-
-    //! Razer Blackwidow X Chroma device.
-    // {5AF60076-ADE9-43D4-B574-52599293B554}
-    static const GUID BLACKWIDOW_X_CHROMA = 
-    { 0x5af60076, 0xade9, 0x43d4, { 0xb5, 0x74, 0x52, 0x59, 0x92, 0x93, 0xb5, 0x54 } };
-
-    //! Razer Blackwidow X TE Chroma device.
-    // {2D84DD51-3290-4AAC-9A89-D8AFDE38B57C}
-    static const GUID BLACKWIDOW_X_TE_CHROMA = 
-    { 0x2d84dd51, 0x3290, 0x4aac, { 0x9a, 0x89, 0xd8, 0xaf, 0xde, 0x38, 0xb5, 0x7c } };
-
-    //! Razer Ornata Chroma
-    // {803378C1-CC48-4970-8539-D828CC1D420A}
-    static const GUID ORNATA_CHROMA =
-    { 0x803378c1, 0xcc48, 0x4970,{ 0x85, 0x39, 0xd8, 0x28, 0xcc, 0x1d, 0x42, 0xa } };
-
-    //! Razer Blade Stealth.
-    // {C83BDFE8-E7FC-40E0-99DB-872E23F19891}
-    static const GUID BLADE_STEALTH = 
-    { 0xc83bdfe8, 0xe7fc, 0x40e0, { 0x99, 0xdb, 0x87, 0x2e, 0x23, 0xf1, 0x98, 0x91 } };
-
-    //! Razer Blade
-    // {F2BEDFAF-A0FE-4651-9D41-B6CE603A3DDD}
-    static const GUID BLADE = 
-    { 0xf2bedfaf, 0xa0fe, 0x4651, { 0x9d, 0x41, 0xb6, 0xce, 0x60, 0x3a, 0x3d, 0xdd } };
-
-    //! Razer Blade Pro
-    // {A73AC338-F0E5-4BF7-91AE-DD1F7E1737A5}
-    static const GUID BLADE_PRO =
-    { 0xa73ac338, 0xf0e5, 0x4bf7,{ 0x91, 0xae, 0xdd, 0x1f, 0x7e, 0x17, 0x37, 0xa5 } };
-
-
-    // Mice
-    //! Razer Deathadder Chroma device.
-    // {AEC50D91-B1F1-452F-8E16-7B73F376FDF3}
-    static const GUID DEATHADDER_CHROMA = 
-    { 0xaec50d91, 0xb1f1, 0x452f, { 0x8e, 0x16, 0x7b, 0x73, 0xf3, 0x76, 0xfd, 0xf3 } };
-
-    //! Razer Mamba Chroma Tournament Edition device.
-    // {7EC00450-E0EE-4289-89D5-0D879C19061A}
-    static const GUID MAMBA_CHROMA_TE = 
-    { 0x7ec00450, 0xe0ee, 0x4289, { 0x89, 0xd5, 0xd, 0x87, 0x9c, 0x19, 0x6, 0x1a } };
-
-    //! Razer Diamondback device.
-    // {FF8A5929-4512-4257-8D59-C647BF9935D0}
-    static const GUID DIAMONDBACK_CHROMA = 
-    { 0xff8a5929, 0x4512, 0x4257, { 0x8d, 0x59, 0xc6, 0x47, 0xbf, 0x99, 0x35, 0xd0 } };
-
-    //! Razer Mamba device.
-    // {D527CBDC-EB0A-483A-9E89-66D50463EC6C}
-    static const GUID MAMBA_CHROMA = 
-    { 0xd527cbdc, 0xeb0a, 0x483a, { 0x9e, 0x89, 0x66, 0xd5, 0x4, 0x63, 0xec, 0x6c } };
-
-    //! Razer Naga Epic device.
-    // {D714C50B-7158-4368-B99C-601ACB985E98}
-    static const GUID NAGA_EPIC_CHROMA = 
-    { 0xd714c50b, 0x7158, 0x4368, { 0xb9, 0x9c, 0x60, 0x1a, 0xcb, 0x98, 0x5e, 0x98 } };
-
-    //! Razer Naga device.
-    // {F1876328-6CA4-46AE-BE04-BE812B414433}
-    static const GUID NAGA_CHROMA = 
-    { 0xf1876328, 0x6ca4, 0x46ae, { 0xbe, 0x4, 0xbe, 0x81, 0x2b, 0x41, 0x44, 0x33 } };
-
-    //! Razer Orochi Chroma device.
-    // {52C15681-4ECE-4DD9-8A52-A1418459EB34}
-    static const GUID OROCHI_CHROMA = 
-    { 0x52c15681, 0x4ece, 0x4dd9, { 0x8a, 0x52, 0xa1, 0x41, 0x84, 0x59, 0xeb, 0x34 } };
-
-    //! Razer Naga Hex Chroma device.
-    // {195D70F5-F285-4CFF-99F2-B8C0E9658DB4}
-    static const GUID NAGA_HEX_CHROMA = 
-    { 0x195d70f5, 0xf285, 0x4cff, { 0x99, 0xf2, 0xb8, 0xc0, 0xe9, 0x65, 0x8d, 0xb4 } };
-
-    //! Razer DeathAdder Elite Chroma device.
-    // {77834867-3237-4A9F-AD77-4A46C4183003}
-    static const GUID DEATHADDER_ELITE_CHROMA =
-    { 0x77834867, 0x3237, 0x4a9f,{ 0xad, 0x77, 0x4a, 0x46, 0xc4, 0x18, 0x30, 0x3 } };
-
-
-    // Headsets
-    //! Razer Kraken 7.1 Chroma device.
-    // {CD1E09A5-D5E6-4A6C-A93B-E6D9BF1D2092}
-    static const GUID KRAKEN71_CHROMA = 
-    { 0xcd1e09a5, 0xd5e6, 0x4a6c, { 0xa9, 0x3b, 0xe6, 0xd9, 0xbf, 0x1d, 0x20, 0x92 } };
-
-    //! Razer ManO'War device.
-    // {DF3164D7-5408-4A0E-8A7F-A7412F26BEBF}
-    static const GUID MANOWAR_CHROMA = 
-    { 0xdf3164d7, 0x5408, 0x4a0e, { 0x8a, 0x7f, 0xa7, 0x41, 0x2f, 0x26, 0xbe, 0xbf } };
-
-    //! Razer Kraken 7.1 Chroma Refresh headset.
-    // {7FB8A36E-9E74-4BB3-8C86-CAC7F7891EBD}
-    static const GUID KRAKEN71_REFRESH_CHROMA =
-    { 0x7fb8a36e, 0x9e74, 0x4bb3,{ 0x8c, 0x86, 0xca, 0xc7, 0xf7, 0x89, 0x1e, 0xbd } };
-
-
-    // Mouse mat
-    //! Razer Firefly device.
-    // {80F95A94-73D2-48CA-AE9A-0986789A9AF2}
-    static const GUID FIREFLY_CHROMA = 
-    { 0x80f95a94, 0x73d2, 0x48ca, { 0xae, 0x9a, 0x9, 0x86, 0x78, 0x9a, 0x9a, 0xf2 } };
-
-
-    // Keypads
-    //! Razer Tartarus device.
-    // {00F0545C-E180-4AD1-8E8A-419061CE505E}
-    static const GUID TARTARUS_CHROMA = 
-    { 0xf0545c, 0xe180, 0x4ad1, { 0x8e, 0x8a, 0x41, 0x90, 0x61, 0xce, 0x50, 0x5e } };
-
-    //! Razer Orbweaver device.
-    // {9D24B0AB-0162-466C-9640-7A924AA4D9FD}
-    static const GUID ORBWEAVER_CHROMA = 
-    { 0x9d24b0ab, 0x162, 0x466c, { 0x96, 0x40, 0x7a, 0x92, 0x4a, 0xa4, 0xd9, 0xfd } };
-
-
-    // Chroma Linked devices
-    // {35F6F18D-1AE5-436C-A575-AB44A127903A}
-    static const GUID LENOVO_Y900 = 
-    { 0x35f6f18d, 0x1ae5, 0x436c, { 0xa5, 0x75, 0xab, 0x44, 0xa1, 0x27, 0x90, 0x3a } };
-
-    // {47DB1FA7-6B9B-4EE6-B6F4-4071A3B2053B}
-    static const GUID LENOVO_Y27 = 
-    { 0x47db1fa7, 0x6b9b, 0x4ee6, { 0xb6, 0xf4, 0x40, 0x71, 0xa3, 0xb2, 0x5, 0x3b } };
-
-    // {0201203B-62F3-4C50-83DD-598BABD208E0}
-    static const GUID CORE_CHROMA = 
-    { 0x201203b, 0x62f3, 0x4c50, { 0x83, 0xdd, 0x59, 0x8b, 0xab, 0xd2, 0x8, 0xe0 } };
-
-    // {BB2E9C9B-B0D2-461A-BA52-230B5D6C3609}
-    static const GUID CHROMABOX =
-    { 0xbb2e9c9b, 0xb0d2, 0x461a,{ 0xba, 0x52, 0x23, 0xb, 0x5d, 0x6c, 0x36, 0x9 } };
-
-
-    // Speakers
-    //! Razer Nommo
-    // {45B308F2-CD44-4594-8375-4D5945AD880E}
-    static const GUID NOMMO_CHROMA =
-    { 0x45b308f2, 0xcd44, 0x4594,{ 0x83, 0x75, 0x4d, 0x59, 0x45, 0xad, 0x88, 0xe } };
-
-
-    //! Razer Nommo Pro
-    // {3017280B-D7F9-4D7B-930E-7B47181B46B5}
-    static const GUID NOMMO_CHROMA_PRO =
-    { 0x3017280b, 0xd7f9, 0x4d7b,{ 0x93, 0xe, 0x7b, 0x47, 0x18, 0x1b, 0x46, 0xb5 } };
-
-}
-
-#endif

dependencies/razer-chroma-2.9.0/inc/RzChromaSDKTypes.h

@@ -1,832 +0,0 @@
-//! \file RzChromaSDKTypes.h
-//! \brief Data types.
-
-#ifndef _RZCHROMASDKTYPES_H_
-#define _RZCHROMASDKTYPES_H_
-
-#pragma once
-
-typedef LONG            RZRESULT;           //!< Return result.
-typedef GUID            RZEFFECTID;         //!< Effect Id.
-typedef GUID            RZDEVICEID;         //!< Device Id.
-typedef unsigned int    RZDURATION;         //!< Milliseconds.
-typedef size_t          RZSIZE;             //!< Size.
-typedef void*           PRZPARAM;           //!< Context sensitive pointer.
-typedef DWORD           RZID;               //!< Generic data type for Identifier.
-typedef DWORD           RZCOLOR;            //!< Color data. 1st byte = Red; 2nd byte = Green; 3rd byte = Blue; 4th byte = Alpha (if applicable)
-
-namespace ChromaSDK
-{
-    //! Event notification Window message
-    const UINT WM_CHROMA_EVENT = WM_APP+0x2000;
-
-    //! Application information.
-    typedef struct APPINFOTYPE
-    {
-        TCHAR Title[256];           //!< Title of the application.
-        TCHAR Description[1024];    //!< A short description of the application.
-        //! Author information
-        struct Author
-        {
-            TCHAR Name[256];        //!< Name of the developer/company.
-            TCHAR Contact[256];     //!< Contact info.
-        } Author;
-        DWORD SupportedDevice;
-        DWORD Category;             //!< 0 = Utility; 1 = Game; 2 = Chroma Link Broadcast
-    } APPINFOTYPE;
-
-    //! Chroma generic effects. Note: Not all devices supported the listed effects.
-    typedef enum EFFECT_TYPE
-    {
-        CHROMA_NONE = 0,            //!< No effect.
-        CHROMA_WAVE,                //!< Wave effect (Deprecated and should not be used).
-        CHROMA_SPECTRUMCYCLING,     //!< Spectrum cycling effect (Deprecated and should not be used).
-        CHROMA_BREATHING,           //!< Breathing effect (Deprecated and should not be used).
-        CHROMA_BLINKING,            //!< Blinking effect (Deprecated and should not be used).
-        CHROMA_REACTIVE,            //!< Reactive effect (Deprecated and should not be used).
-        CHROMA_STATIC,              //!< Static single color effect.
-        CHROMA_CUSTOM,              //!< Custom effect. For mice, please see Mouse::CHROMA_CUSTOM2.
-        CHROMA_RESERVED,            //!< Reserved
-        CHROMA_INVALID              //!< Invalid effect.
-    } EFFECT_TYPE;
-
-    //! Device info.
-    typedef struct DEVICE_INFO_TYPE
-    {
-        //! Device types.
-        enum DeviceType
-        {
-            DEVICE_KEYBOARD    = 1, //!< Keyboard device.
-            DEVICE_MOUSE       = 2, //!< Mouse device.
-            DEVICE_HEADSET     = 3, //!< Headset device.
-            DEVICE_MOUSEPAD    = 4, //!< Mousepad device.
-            DEVICE_KEYPAD      = 5, //!< Keypad device.
-            DEVICE_SYSTEM      = 6, //!< System device.
-            DEVICE_SPEAKERS    = 7, //!< Speakers.
-            DEVICE_INVALID          //!< Invalid device.
-        } DeviceType;
-
-        DWORD Connected;            //!< Number of devices connected.
-    } DEVICE_INFO_TYPE;
-
-    const RZSIZE MAX_ROW = 30;      //!< Maximum rows for custom effects.
-    const RZSIZE MAX_COLUMN = 30;   //!< Maximum columns for custom effects.
-
-    //! Blinking effect (Deprecated and should not be used).
-    typedef struct BLINKING_EFFECT_TYPE
-    {
-        RZSIZE Size;        //!< Size of the structure. Size = sizeof(BLINKING_EFFECT_TYPE)
-        DWORD Param;        //!< Extra parameters.
-
-        COLORREF Color;     //!< Blinking color
-    } BLINKING_EFFECT_TYPE;
-
-    //! Breathing effect (Deprecated and should not be used).
-    typedef struct BREATHING_EFFECT_TYPE
-    {
-        RZSIZE Size;        //!< Size of ths structure. Size = sizeof(BREATHING_EFFECT_TYPE)
-        DWORD Param;        //!< Extra parameters.
-
-        //! Breathing effect types.
-        enum _Type
-        {
-            ONE_COLOR = 1,  //!< 1 color (Only fill Color1).
-            TWO_COLORS,     //!< 2 colors.
-            RANDOM_COLORS   //!< Random colors
-        } Type;
-
-        COLORREF Color1;    //!< First color.
-        COLORREF Color2;    //!< Second color.
-    } BREATHING_EFFECT_TYPE;
-
-    //! Custom effect (Deprecated and should not be used).
-    typedef struct CUSTOM_EFFECT_TYPE
-    {
-        RZSIZE Size;        //!< Size of the structure. Size = sizeof(CUSTOM_EFFECT_TYPE)
-        DWORD Param;        //!< Extra parameters.
-
-        RZCOLOR Color[MAX_ROW][MAX_COLUMN];
-    } CUSTOM_EFFECT_TYPE;
-
-    //! No effect.
-    typedef struct NO_EFFECT_TYPE
-    {
-        RZSIZE Size;        //!< Size of the structure. Size = sizeof(NO_EFFECT_TYPE)
-        DWORD Param;        //!< Extra parameters.
-    } NO_EFFECT_TYPE;
-
-    //! Reactive effect (Deprecated and should not be used).
-    typedef struct REACTIVE_EFFECT_TYPE
-    {
-        RZSIZE Size;        //!< Size of the structure. Size = sizeof(REACTIVE_EFFECT_TYPE)
-        DWORD Param;        //!< Extra parameters.
-
-        //! Duration of the effect.
-        enum _Duration
-        {
-            DURATION_SHORT = 1, //!< Short duration.
-            DURATION_MEDIUM,    //!< Medium duration.
-            DURATION_LONG       //!< Long duration.
-        } Duration;             //!< The time taken for the effect to fade away.
-
-        COLORREF Color;         //!< Color of the effect.
-    } REACTIVE_EFFECT_TYPE;
-
-    //! Spectrum cycling effect (Deprecated and should not be used).
-    typedef struct SPECTRUMCYCLING_EFFECT_TYPE
-    {
-        RZSIZE Size;        //!< Size of the structure. Size = sizeof(SPECTRUMCYCLING_EFFECT_TYPE)
-        DWORD Param;        //!< Extra parameters.
-    } SPECTRUMCYCLING_EFFECT_TYPE;
-
-    //! Starlight effect (Deprecated and should not be used).
-    typedef struct STARLIGHT_EFFECT_TYPE
-    {
-        RZSIZE Size;        //!< Size of the structure. Size = sizeof(SPECTRUMCYCLING_EFFECT_TYPE)
-        DWORD Param;        //!< Extra parameters.
-
-        //! Starlight effect types.
-        enum _Type
-        {
-            TWO_COLORS = 1, //!< 2 colors.
-            RANDOM_COLORS   //!< Random colors
-        } Type;
-
-        COLORREF Color1;    //!< First color.
-        COLORREF Color2;    //!< Second color.
-
-        //! Duration of the effect.
-        enum _Duration
-        {
-            DURATION_SHORT = 1, //!< Short duration.
-            DURATION_MEDIUM,    //!< Medium duration.
-            DURATION_LONG       //!< Long duration.
-        } Duration;             //!< The time taken for the effect to fade away.
-
-    } STARLIGHT_EFFECT_TYPE;
-
-    //! Static effect (Deprecated and should not be used).
-    typedef struct STATIC_EFFECT_TYPE
-    {
-        RZSIZE Size;        //!< Size of the structure. Size = sizeof(STATIC_EFFECT_TYPE)
-        DWORD Param;        //!< Extra parameters.
-
-        COLORREF Color;     //!< Color of the effect.
-    } STATIC_EFFECT_TYPE;
-
-    //! Wave effect (Deprecated and should not be used).
-    typedef struct WAVE_EFFECT_TYPE
-    {
-        RZSIZE Size;        //!< Size of the structure. Size = sizeof(WAVE_EFFECT_TYPE)
-        DWORD Param;        //!< Extra parameters.
-
-        //! Direction of effect.
-        enum _Direction
-        {
-            DIRECTION_LEFT_TO_RIGHT = 1,    //!< Left to right.
-            DIRECTION_RIGHT_TO_LEFT,        //!< Right to left.
-            DIRECTION_FRONT_TO_BACK,        //!< Front to back
-            DIRECTION_BACK_TO_FRONT         //!< Back top front
-        } Direction;
-    } WAVE_EFFECT_TYPE;
-
-    //! Keyboards
-    namespace Keyboard
-    {
-        //! Definitions of keys.
-        typedef enum RZKEY
-        {
-            RZKEY_ESC = 0x0001,                 /*!< Esc (VK_ESCAPE) */
-            RZKEY_F1 = 0x0003,                  /*!< F1 (VK_F1) */
-            RZKEY_F2 = 0x0004,                  /*!< F2 (VK_F2) */
-            RZKEY_F3 = 0x0005,                  /*!< F3 (VK_F3) */
-            RZKEY_F4 = 0x0006,                  /*!< F4 (VK_F4) */
-            RZKEY_F5 = 0x0007,                  /*!< F5 (VK_F5) */
-            RZKEY_F6 = 0x0008,                  /*!< F6 (VK_F6) */
-            RZKEY_F7 = 0x0009,                  /*!< F7 (VK_F7) */
-            RZKEY_F8 = 0x000A,                  /*!< F8 (VK_F8) */
-            RZKEY_F9 = 0x000B,                  /*!< F9 (VK_F9) */
-            RZKEY_F10 = 0x000C,                 /*!< F10 (VK_F10) */
-            RZKEY_F11 = 0x000D,                 /*!< F11 (VK_F11) */
-            RZKEY_F12 = 0x000E,                 /*!< F12 (VK_F12) */
-            RZKEY_1 = 0x0102,                   /*!< 1 (VK_1) */
-            RZKEY_2 = 0x0103,                   /*!< 2 (VK_2) */
-            RZKEY_3 = 0x0104,                   /*!< 3 (VK_3) */
-            RZKEY_4 = 0x0105,                   /*!< 4 (VK_4) */
-            RZKEY_5 = 0x0106,                   /*!< 5 (VK_5) */
-            RZKEY_6 = 0x0107,                   /*!< 6 (VK_6) */
-            RZKEY_7 = 0x0108,                   /*!< 7 (VK_7) */
-            RZKEY_8 = 0x0109,                   /*!< 8 (VK_8) */
-            RZKEY_9 = 0x010A,                   /*!< 9 (VK_9) */
-            RZKEY_0 = 0x010B,                   /*!< 0 (VK_0) */
-            RZKEY_A = 0x0302,                   /*!< A (VK_A) */
-            RZKEY_B = 0x0407,                   /*!< B (VK_B) */
-            RZKEY_C = 0x0405,                   /*!< C (VK_C) */
-            RZKEY_D = 0x0304,                   /*!< D (VK_D) */
-            RZKEY_E = 0x0204,                   /*!< E (VK_E) */
-            RZKEY_F = 0x0305,                   /*!< F (VK_F) */
-            RZKEY_G = 0x0306,                   /*!< G (VK_G) */
-            RZKEY_H = 0x0307,                   /*!< H (VK_H) */
-            RZKEY_I = 0x0209,                   /*!< I (VK_I) */
-            RZKEY_J = 0x0308,                   /*!< J (VK_J) */
-            RZKEY_K = 0x0309,                   /*!< K (VK_K) */
-            RZKEY_L = 0x030A,                   /*!< L (VK_L) */
-            RZKEY_M = 0x0409,                   /*!< M (VK_M) */
-            RZKEY_N = 0x0408,                   /*!< N (VK_N) */
-            RZKEY_O = 0x020A,                   /*!< O (VK_O) */
-            RZKEY_P = 0x020B,                   /*!< P (VK_P) */
-            RZKEY_Q = 0x0202,                   /*!< Q (VK_Q) */
-            RZKEY_R = 0x0205,                   /*!< R (VK_R) */
-            RZKEY_S = 0x0303,                   /*!< S (VK_S) */
-            RZKEY_T = 0x0206,                   /*!< T (VK_T) */
-            RZKEY_U = 0x0208,                   /*!< U (VK_U) */
-            RZKEY_V = 0x0406,                   /*!< V (VK_V) */
-            RZKEY_W = 0x0203,                   /*!< W (VK_W) */
-            RZKEY_X = 0x0404,                   /*!< X (VK_X) */
-            RZKEY_Y = 0x0207,                   /*!< Y (VK_Y) */
-            RZKEY_Z = 0x0403,                   /*!< Z (VK_Z) */
-            RZKEY_NUMLOCK = 0x0112,             /*!< Numlock (VK_NUMLOCK) */
-            RZKEY_NUMPAD0 = 0x0513,             /*!< Numpad 0 (VK_NUMPAD0) */
-            RZKEY_NUMPAD1 = 0x0412,             /*!< Numpad 1 (VK_NUMPAD1) */
-            RZKEY_NUMPAD2 = 0x0413,             /*!< Numpad 2 (VK_NUMPAD2) */
-            RZKEY_NUMPAD3 = 0x0414,             /*!< Numpad 3 (VK_NUMPAD3) */
-            RZKEY_NUMPAD4 = 0x0312,             /*!< Numpad 4 (VK_NUMPAD4) */
-            RZKEY_NUMPAD5 = 0x0313,             /*!< Numpad 5 (VK_NUMPAD5) */
-            RZKEY_NUMPAD6 = 0x0314,             /*!< Numpad 6 (VK_NUMPAD6) */
-            RZKEY_NUMPAD7 = 0x0212,             /*!< Numpad 7 (VK_NUMPAD7) */
-            RZKEY_NUMPAD8 = 0x0213,             /*!< Numpad 8 (VK_NUMPAD8) */
-            RZKEY_NUMPAD9 = 0x0214,             /*!< Numpad 9 (VK_ NUMPAD9*/
-            RZKEY_NUMPAD_DIVIDE = 0x0113,       /*!< Divide (VK_DIVIDE) */
-            RZKEY_NUMPAD_MULTIPLY = 0x0114,     /*!< Multiply (VK_MULTIPLY) */
-            RZKEY_NUMPAD_SUBTRACT = 0x0115,     /*!< Subtract (VK_SUBTRACT) */
-            RZKEY_NUMPAD_ADD = 0x0215,          /*!< Add (VK_ADD) */
-            RZKEY_NUMPAD_ENTER = 0x0415,        /*!< Enter (VK_RETURN - Extended) */
-            RZKEY_NUMPAD_DECIMAL = 0x0514,      /*!< Decimal (VK_DECIMAL) */
-            RZKEY_PRINTSCREEN = 0x000F,         /*!< Print Screen (VK_PRINT) */
-            RZKEY_SCROLL = 0x0010,              /*!< Scroll Lock (VK_SCROLL) */
-            RZKEY_PAUSE = 0x0011,               /*!< Pause (VK_PAUSE) */
-            RZKEY_INSERT = 0x010F,              /*!< Insert (VK_INSERT) */
-            RZKEY_HOME = 0x0110,                /*!< Home (VK_HOME) */
-            RZKEY_PAGEUP = 0x0111,              /*!< Page Up (VK_PRIOR) */
-            RZKEY_DELETE = 0x020f,              /*!< Delete (VK_DELETE) */
-            RZKEY_END = 0x0210,                 /*!< End (VK_END) */
-            RZKEY_PAGEDOWN = 0x0211,            /*!< Page Down (VK_NEXT) */
-            RZKEY_UP = 0x0410,                  /*!< Up (VK_UP) */
-            RZKEY_LEFT = 0x050F,                /*!< Left (VK_LEFT) */
-            RZKEY_DOWN = 0x0510,                /*!< Down (VK_DOWN) */
-            RZKEY_RIGHT = 0x0511,               /*!< Right (VK_RIGHT) */
-            RZKEY_TAB = 0x0201,                 /*!< Tab (VK_TAB) */
-            RZKEY_CAPSLOCK = 0x0301,            /*!< Caps Lock(VK_CAPITAL) */
-            RZKEY_BACKSPACE = 0x010E,           /*!< Backspace (VK_BACK) */
-            RZKEY_ENTER = 0x030E,               /*!< Enter (VK_RETURN) */
-            RZKEY_LCTRL = 0x0501,               /*!< Left Control(VK_LCONTROL) */
-            RZKEY_LWIN = 0x0502,                /*!< Left Window (VK_LWIN) */
-            RZKEY_LALT = 0x0503,                /*!< Left Alt (VK_LMENU) */
-            RZKEY_SPACE = 0x0507,               /*!< Spacebar (VK_SPACE) */
-            RZKEY_RALT = 0x050B,                /*!< Right Alt (VK_RMENU) */
-            RZKEY_FN = 0x050C,                  /*!< Function key. */
-            RZKEY_RMENU = 0x050D,               /*!< Right Menu (VK_APPS) */
-            RZKEY_RCTRL = 0x050E,               /*!< Right Control (VK_RCONTROL) */
-            RZKEY_LSHIFT = 0x0401,              /*!< Left Shift (VK_LSHIFT) */
-            RZKEY_RSHIFT = 0x040E,              /*!< Right Shift (VK_RSHIFT) */
-            RZKEY_MACRO1 = 0x0100,              /*!< Macro Key 1 */
-            RZKEY_MACRO2 = 0x0200,              /*!< Macro Key 2 */
-            RZKEY_MACRO3 = 0x0300,              /*!< Macro Key 3 */
-            RZKEY_MACRO4 = 0x0400,              /*!< Macro Key 4 */
-            RZKEY_MACRO5 = 0x0500,              /*!< Macro Key 5 */
-            RZKEY_OEM_1 = 0x0101,               /*!< ~ (tilde/半角/全角) (VK_OEM_3) */
-            RZKEY_OEM_2 = 0x010C,               /*!< -- (minus) (VK_OEM_MINUS) */
-            RZKEY_OEM_3 = 0x010D,               /*!< = (equal) (VK_OEM_PLUS) */
-            RZKEY_OEM_4 = 0x020C,               /*!< [ (left sqaure bracket) (VK_OEM_4) */
-            RZKEY_OEM_5 = 0x020D,               /*!< ] (right square bracket) (VK_OEM_6) */
-            RZKEY_OEM_6 = 0x020E,               /*!< \ (backslash) (VK_OEM_5) */
-            RZKEY_OEM_7 = 0x030B,               /*!< ; (semi-colon) (VK_OEM_1) */
-            RZKEY_OEM_8 = 0x030C,               /*!< ' (apostrophe) (VK_OEM_7) */
-            RZKEY_OEM_9 = 0x040A,               /*!< , (comma) (VK_OEM_COMMA) */
-            RZKEY_OEM_10 = 0x040B,              /*!< . (period) (VK_OEM_PERIOD) */
-            RZKEY_OEM_11 = 0x040C,              /*!< / (forward slash) (VK_OEM_2) */
-            RZKEY_EUR_1 = 0x030D,               /*!< "#" (VK_OEM_5) */
-            RZKEY_EUR_2 = 0x0402,               /*!< \ (VK_OEM_102) */
-            RZKEY_JPN_1 = 0x0015,               /*!< ¥ (0xFF) */
-            RZKEY_JPN_2 = 0x040D,               /*!< \ (0xC1) */
-            RZKEY_JPN_3 = 0x0504,               /*!< 無変換 (VK_OEM_PA1) */
-            RZKEY_JPN_4 = 0x0509,               /*!< 変換 (0xFF) */
-            RZKEY_JPN_5 = 0x050A,               /*!< ひらがな/カタカナ (0xFF) */
-            RZKEY_KOR_1 = 0x0015,               /*!< | (0xFF) */
-            RZKEY_KOR_2 = 0x030D,               /*!< (VK_OEM_5) */
-            RZKEY_KOR_3 = 0x0402,               /*!< (VK_OEM_102) */
-            RZKEY_KOR_4 = 0x040D,               /*!< (0xC1) */
-            RZKEY_KOR_5 = 0x0504,               /*!< (VK_OEM_PA1) */
-            RZKEY_KOR_6 = 0x0509,               /*!< 한/영 (0xFF) */
-            RZKEY_KOR_7 = 0x050A,               /*!< (0xFF) */
-            RZKEY_INVALID = 0xFFFF              /*!< Invalid keys. */
-        } RZKEY;
-
-        //! Definition of LEDs.
-        typedef enum RZLED
-        {
-            RZLED_LOGO = 0x0014                 /*!< Razer logo */
-        } RZLED;
-
-        //! Maximum number of rows in a keyboard.
-        const RZSIZE MAX_ROW = 6;
-
-        //! Maximum number of columns in a keyboard.
-        const RZSIZE MAX_COLUMN = 22;
-
-        //! Maximum number of keys.
-        const RZSIZE MAX_KEYS = MAX_ROW * MAX_COLUMN;
-
-        //! Maximum number of custom effects.
-        const RZSIZE MAX_CUSTOM_EFFECTS = MAX_KEYS;
-
-        //! Keyboard LED layout.
-        const COLORREF RZKEY_LAYOUT[MAX_ROW][MAX_COLUMN] = {};
-
-        //! Chroma keyboard effect types
-        typedef enum EFFECT_TYPE
-        {
-            CHROMA_NONE = 0,            //!< No effect.
-            CHROMA_BREATHING,           //!< Breathing effect (Deprecated and should not be used.).
-            CHROMA_CUSTOM,              //!< Custom effect.
-            CHROMA_REACTIVE,            //!< Reactive effect (Deprecated and should not be used).
-            CHROMA_STATIC,              //!< Static single color effect.
-            CHROMA_SPECTRUMCYCLING,     //!< Spectrum cycling effect (Deprecated and should not be used).
-            CHROMA_WAVE,                //!< Wave effect (Deprecated and should not be used).
-            CHROMA_RESERVED,            //!< Reserved.
-            CHROMA_CUSTOM_KEY,          //!< Custom effects with keys.
-            CHROMA_INVALID              //!< Invalid effect.
-        } EFFECT_TYPE;
-
-        // Chroma keyboard effects
-        //! Breathing effect type (Deprecated and should not be used).
-        typedef struct BREATHING_EFFECT_TYPE
-        {
-            //! Breathing effects.
-            enum Type
-            {
-                TWO_COLORS = 1,     //!< 2 colors
-                RANDOM_COLORS,      //!< Random colors
-                INVALID             //!< Invalid type
-            } Type;
-            COLORREF Color1;        //!< First color.
-            COLORREF Color2;        //!< Second color.
-        } BREATHING_EFFECT_TYPE;
-
-        //! Custom effect using a matrix type.
-        typedef struct CUSTOM_EFFECT_TYPE
-        {
-            COLORREF Color[MAX_ROW][MAX_COLUMN];      //!< Grid layout. 6 rows by 22 columns.
-        } CUSTOM_EFFECT_TYPE;
-
-        //! Custom effect with keys.
-        typedef struct CUSTOM_KEY_EFFECT_TYPE
-        {
-            COLORREF Color[MAX_ROW][MAX_COLUMN];        //!< Grid layout. 6 rows by 22 columns.
-            COLORREF Key[MAX_ROW][MAX_COLUMN];          //!< Keys information. 6 rows by 22 columns. To indidate there is a key effect, OR with 0x01000000. i.e. Key[0][1] = 0x01000000 | Color;
-        } CUSTOM_KEY_EFFECT_TYPE;
-
-        //! Reactive effect type (Deprecated and should not be used).
-        typedef struct REACTIVE_EFFECT_TYPE
-        {
-            //! Duration of the effect.
-            enum Duration
-            {
-                DURATION_NONE=0,    //!< No duration.
-                DURATION_SHORT,     //!< Short duration.
-                DURATION_MEDIUM,    //!< Medium duration.
-                DURATION_LONG,      //!< Long duration.
-                DURATION_INVALID    //!< Invalid duration.
-            } Duration;             //!< The time taken for the effect to fade away.
-
-            COLORREF Color;         //!< Color of the effect
-        } REACTIVE_EFFECT_TYPE;
-
-        //! Starlight effect (Deprecated and should not be used).
-        typedef struct STARLIGHT_EFFECT_TYPE
-        {
-            //! Starlight effect types.
-            enum _Type
-            {
-                TWO_COLORS = 1, //!< 2 colors.
-                RANDOM_COLORS   //!< Random colors
-            } Type;
-
-            COLORREF Color1;    //!< First color.
-            COLORREF Color2;    //!< Second color.
-
-            //! Duration of the effect.
-            enum _Duration
-            {
-                DURATION_SHORT = 1, //!< Short duration.
-                DURATION_MEDIUM,    //!< Medium duration.
-                DURATION_LONG       //!< Long duration.
-            } Duration;             //!< The time taken for the effect to fade away.
-
-        } STARLIGHT_EFFECT_TYPE;
-
-        //! Static effect type
-        typedef struct STATIC_EFFECT_TYPE
-        {
-            COLORREF Color;     //!< Color of the effect
-        } STATIC_EFFECT_TYPE;
-
-        //! Wave effect type (Deprecated and should not be used).
-        typedef struct WAVE_EFFECT_TYPE
-        {
-            //! Direction of the wave effect.
-            enum Direction
-            {
-                DIRECTION_NONE=0,           //!< No direction.
-                DIRECTION_LEFT_TO_RIGHT,    //!< Left to right.
-                DIRECTION_RIGHT_TO_LEFT,    //!< Right to left.
-                DIRECTION_INVALID           //!< Invalid direction.
-            } Direction;                    //!< Direction of the wave.
-        } WAVE_EFFECT_TYPE;
-    }
-
-    //! Mice
-    namespace Mouse
-    {
-        //! Maximum number of custom LEDs (old definition to maintain backward compatibility).
-        const RZSIZE MAX_LEDS = 30;
-
-        //! Mice LED layout (old definition to maintain backward compatibility).
-        const RZCOLOR RZLED_LAYOUT[MAX_LEDS] = {};
-
-        //! Maximum number of rows of the virtual grid.
-        const RZSIZE MAX_ROW = 9;
-
-        //! Maximum number of columns of the virtual grid.
-        const RZSIZE MAX_COLUMN = 7;
-
-        //! Maximum number of LEDs of the virtual grid.
-        const RZSIZE MAX_LEDS2 = MAX_ROW * MAX_COLUMN;
-
-        //! Mice LED virtual grid layout.
-        const RZCOLOR RZLED_LAYOUT2[MAX_ROW][MAX_COLUMN] = {};
-
-        //! Mouse LED Id defintion (Deprecated and should not be used).
-        typedef enum RZLED
-        {
-            RZLED_NONE          = 0,    //!< No LED.
-            RZLED_SCROLLWHEEL   = 1,    //!< Scroll Wheel LED.
-            RZLED_LOGO          = 2,    //!< Logo LED.
-            RZLED_BACKLIGHT     = 3,    //!< Backlight or numpad.
-            RZLED_SIDE_STRIP1   = 4,    //!< Side strip LED 1. (For Mamba TE, starts from top left hand)
-            RZLED_SIDE_STRIP2   = 5,    //!< Side strip LED 2. (For Mamba TE)
-            RZLED_SIDE_STRIP3   = 6,    //!< Side strip LED 3. (For Mamba TE)
-            RZLED_SIDE_STRIP4   = 7,    //!< Side strip LED 4. (For Mamba TE)
-            RZLED_SIDE_STRIP5   = 8,    //!< Side strip LED 5. (For Mamba TE)
-            RZLED_SIDE_STRIP6   = 9,    //!< Side strip LED 6. (For Mamba TE)
-            RZLED_SIDE_STRIP7   = 10,   //!< Side strip LED 7. (For Mamba TE)
-            RZLED_SIDE_STRIP8   = 11,   //!< Side strip LED 8. (For Mamba TE)
-            RZLED_SIDE_STRIP9   = 12,   //!< Side strip LED 9. (For Mamba TE)
-            RZLED_SIDE_STRIP10  = 13,   //!< Side strip LED 10. (For Mamba TE)
-            RZLED_SIDE_STRIP11  = 14,   //!< Side strip LED 11. (For Mamba TE)
-            RZLED_SIDE_STRIP12  = 15,   //!< Side strip LED 12. (For Mamba TE)
-            RZLED_SIDE_STRIP13  = 16,   //!< Side strip LED 13. (For Mamba TE)
-            RZLED_SIDE_STRIP14  = 17,   //!< Side strip LED 14. (For Mamba TE)
-            RZLED_ALL           = 0xFFFF
-        } RZLED;
-
-        //! Mouse LED Id defintion for the virtual grid.
-        typedef enum RZLED2
-        {
-            RZLED2_SCROLLWHEEL   = 0x0203,  //!< Scroll Wheel LED.
-            RZLED2_LOGO          = 0x0703,  //!< Logo LED.
-            RZLED2_BACKLIGHT     = 0x0403,  //!< Backlight LED.
-            RZLED2_LEFT_SIDE1    = 0x0100,  //!< Left LED 1.
-            RZLED2_LEFT_SIDE2    = 0x0200,  //!< Left LED 2.
-            RZLED2_LEFT_SIDE3    = 0x0300,  //!< Left LED 3.
-            RZLED2_LEFT_SIDE4    = 0x0400,  //!< Left LED 4.
-            RZLED2_LEFT_SIDE5    = 0x0500,  //!< Left LED 5.
-            RZLED2_LEFT_SIDE6    = 0x0600,  //!< Left LED 6.
-            RZLED2_LEFT_SIDE7    = 0x0700,  //!< Left LED 7.
-            RZLED2_BOTTOM1       = 0x0801,  //!< Bottom LED 1.
-            RZLED2_BOTTOM2       = 0x0802,  //!< Bottom LED 2.
-            RZLED2_BOTTOM3       = 0x0803,  //!< Bottom LED 3.
-            RZLED2_BOTTOM4       = 0x0804,  //!< Bottom LED 4.
-            RZLED2_BOTTOM5       = 0x0805,  //!< Bottom LED 5.
-            RZLED2_RIGHT_SIDE1   = 0x0106,  //!< Right LED 1.
-            RZLED2_RIGHT_SIDE2   = 0x0206,  //!< Right LED 2.
-            RZLED2_RIGHT_SIDE3   = 0x0306,  //!< Right LED 3.
-            RZLED2_RIGHT_SIDE4   = 0x0406,  //!< Right LED 4.
-            RZLED2_RIGHT_SIDE5   = 0x0506,  //!< Right LED 5.
-            RZLED2_RIGHT_SIDE6   = 0x0606,  //!< Right LED 6.
-            RZLED2_RIGHT_SIDE7   = 0x0706   //!< Right LED 7.
-        } RZLED2;
-
-        //! Chroma mouse effect types
-        typedef enum EFFECT_TYPE
-        {
-            CHROMA_NONE = 0,            //!< No effect.
-            CHROMA_BLINKING,            //!< Blinking effect (Deprecated and should not be used).
-            CHROMA_BREATHING,           //!< Breathing effect (Deprecated and should not be used).
-            CHROMA_CUSTOM,              //!< Custom effect (Deprecated and should not be used).
-            CHROMA_REACTIVE,            //!< Reactive effect (Deprecated and should not be used).
-            CHROMA_SPECTRUMCYCLING,     //!< Spectrum cycling effect (Deprecated and should not be used).
-            CHROMA_STATIC,              //!< Static single color effect.
-            CHROMA_WAVE,                //!< Wave effect (Deprecated and should not be used).
-            CHROMA_CUSTOM2,             //!< Custom effects using a virtual grid.
-            CHROMA_INVALID              //!< Invalid effect.
-        } EFFECT_TYPE;
-
-        //! Static effect type
-        typedef struct STATIC_EFFECT_TYPE
-        {
-            RZLED LEDId;        //!< LED Id
-            COLORREF Color;     //!< Color of the effect.
-        } STATIC_EFFECT_TYPE;
-
-        //! Blinking effect type (Deprecated and should not be used).
-        typedef struct BLINKING_EFFECT_TYPE
-        {
-            RZLED LEDId;        //!< LED Id
-            COLORREF Color;     //!< Color.
-        } BLINKING_EFFECT_TYPE;
-
-        //! Breathing effect (Deprecated and should not be used).
-        typedef struct BREATHING_EFFECT_TYPE
-        {
-            RZLED LEDId;        //!< LED Id
-
-            //! Breathing type.
-            enum Type
-            {
-                ONE_COLOR = 1,  //!< 1 color (Only fill Color1).
-                TWO_COLORS,     //!< 2 colors.
-                RANDOM_COLORS,  //!< Random colors
-                INVALID         //!< Invalid type
-            } Type;
-
-            COLORREF Color1;    //!< First color.
-            COLORREF Color2;    //!< Second color.
-        } BREATHING_EFFECT_TYPE;
-
-        //! Custom effect (Deprecated and should not be used).
-        typedef struct CUSTOM_EFFECT_TYPE
-        {
-            RZCOLOR Color[MAX_LEDS]; //!< Array of colors.
-        } CUSTOM_EFFECT_TYPE;
-
-        //! Custom effect using virtual grid. 
-        //! Indexes of the LED are defined in RZLED2.i.e. Row = HIBYTE(RZLED2_SCROLLWHEEL), Column = LOBYTE(RZLED2_SCROLLWHEEL)
-        typedef struct CUSTOM_EFFECT_TYPE2
-        {
-            RZCOLOR Color[MAX_ROW][MAX_COLUMN]; //!< Array of colors.
-        } CUSTOM_EFFECT_TYPE2;
-
-        //! Reactive effect (Deprecated and should not be used).
-        typedef struct REACTIVE_EFFECT_TYPE
-        {
-            RZLED LEDId;        //!< LED Id
-
-            //! Duration of the effect.
-            enum Duration
-            {
-                DURATION_NONE=0,    //!< No duration.
-                DURATION_SHORT,     //!< Short duration.
-                DURATION_MEDIUM,    //!< Medium duration.
-                DURATION_LONG       //!< Long duration.
-            } Duration;
-
-            RZCOLOR Color;          //!< Color of the effect.
-        } REACTIVE_EFFECT_TYPE;
-
-        //! No effect (Deprecated and should not be used).
-        typedef struct NO_EFFECT_TYPE
-        {
-            RZLED LEDId;        //!< LED Id
-        } NO_EFFECT_TYPE;
-
-        //! Spectrum cycling (Deprecated and should not be used).
-        typedef struct SPECTRUMCYCLING_EFFECT_TYPE
-        {
-            RZLED LEDId;            //!< LED id.
-        } SPECTRUMCYCLING_EFFECT_TYPE;
-
-        //! Wave effect (Deprecated and should not be used).
-        typedef struct WAVE_EFFECT_TYPE
-        {
-            //! Direction of the wave effect.
-            enum Direction
-            {
-                FRONT_TO_BACK,      //!< Front to back
-                BACK_TO_FRONT       //!< Back to front
-            } Direction;
-        } WAVE_EFFECT_TYPE;
-    }
-
-    //! Headsets
-    namespace Headset
-    {
-        //! Maximum number of LEDs
-        const RZSIZE MAX_LEDS = 5;
-
-        //! Chroma headset effect types
-        typedef enum EFFECT_TYPE
-        {
-            CHROMA_NONE = 0,            //!< No effect.
-            CHROMA_STATIC,              //!< Static single color effect.
-            CHROMA_BREATHING,           //!< Breathing effect (Deprecated and should not be used).
-            CHROMA_SPECTRUMCYCLING,     //!< Spectrum cycling effect (Deprecated and should not be used).
-            CHROMA_CUSTOM,              //!< Custom effects.
-            CHROMA_INVALID              //!< Invalid effect.
-        } EFFECT_TYPE;
-
-        //! Static effect type
-        typedef struct STATIC_EFFECT_TYPE
-        {
-            COLORREF Color;             //!< Color of the effect.
-        } STATIC_EFFECT_TYPE;
-
-        //! Breathing effect type (Deprecated and should not be used).
-        typedef struct BREATHING_EFFECT_TYPE
-        {
-            COLORREF Color;             //!< Color.
-        } BREATHING_EFFECT_TYPE;
-
-        //! Custom effect type.
-        typedef struct CUSTOM_EFFECT_TYPE
-        {
-            RZCOLOR Color[MAX_LEDS];    //!< Array of colors.
-        } CUSTOM_EFFECT_TYPE;
-    }
-
-    //! Mousepads
-    namespace Mousepad
-    {
-        //! Maximum number of LEDs
-        const RZSIZE MAX_LEDS = 15;
-
-        //! Chroma mousepad effect types
-        typedef enum EFFECT_TYPE
-        {
-            CHROMA_NONE = 0,            //!< No effect.
-            CHROMA_BREATHING,           //!< Breathing effect (Deprecated and should not be used).
-            CHROMA_CUSTOM,              //!< Custom effect.
-            CHROMA_SPECTRUMCYCLING,     //!< Spectrum cycling effect (Deprecated and should not be used).
-            CHROMA_STATIC,              //!< Static single color effect.
-            CHROMA_WAVE,                //!< Wave effect (Deprecated and should not be used).
-            CHROMA_INVALID              //!< Invalid effect.
-        } EFFECT_TYPE;
-
-        // Chroma mousepad effects
-        //! Breathing effect type (Deprecated and should not be used).
-        typedef struct BREATHING_EFFECT_TYPE
-        {
-            //! Breathing effects.
-            enum Type
-            {
-                TWO_COLORS = 1,     //!< 2 colors
-                RANDOM_COLORS,      //!< Random colors
-                INVALID
-            } Type;
-            COLORREF Color1;    //!< First color.
-            COLORREF Color2;    //!< Second color.
-        } BREATHING_EFFECT_TYPE;
-
-        //! Custom effect type.
-        typedef struct CUSTOM_EFFECT_TYPE
-        {
-            RZCOLOR Color[MAX_LEDS];    //!< An array of colors for all the sides of the mousepad. First LED starts from top-right corner.
-                                        //!< LED 0-4 right side, 5-9 bottom side, 10-14 left side.
-        } CUSTOM_EFFECT_TYPE;
-
-        //! Static effect type
-        typedef struct STATIC_EFFECT_TYPE
-        {
-            COLORREF Color;     //!< Color of the effect
-        } STATIC_EFFECT_TYPE;
-
-        //! Wave effect type
-        typedef struct WAVE_EFFECT_TYPE
-        {
-            //! Direction of the wave effect.
-            enum Direction
-            {
-                DIRECTION_NONE=0,           //!< No direction.
-                DIRECTION_LEFT_TO_RIGHT,    //!< Left to right.
-                DIRECTION_RIGHT_TO_LEFT,    //!< Right to left.
-                DIRECTION_INVALID           //!< Invalid direction.
-            } Direction;                    //!< Direction of the wave.
-        } WAVE_EFFECT_TYPE;
-    }
-
-    //! Keypads
-    namespace Keypad
-    {
-        //! Maximum number of rows.
-        const RZSIZE MAX_ROW = 4;
-
-        //! Maximum number of columns.
-        const RZSIZE MAX_COLUMN = 5;
-
-        //! Total number of keys.
-        const RZSIZE MAX_KEYS = MAX_ROW * MAX_COLUMN;
-
-        //! Chroma keypad effect types
-        typedef enum EFFECT_TYPE
-        {
-            CHROMA_NONE = 0,            //!< No effect.
-            CHROMA_BREATHING,           //!< Breathing effect (Deprecated and should not be used).
-            CHROMA_CUSTOM,              //!< Custom effect.
-            CHROMA_REACTIVE,            //!< Reactive effect (Deprecated and should not be used).
-            CHROMA_SPECTRUMCYCLING,     //!< Spectrum cycling effect (Deprecated and should not be used).
-            CHROMA_STATIC,              //!< Static single color effect.
-            CHROMA_WAVE,                //!< Wave effect (Deprecated and should not be used).
-            CHROMA_INVALID              //!< Invalid effect.
-        } EFFECT_TYPE;
-
-        // Chroma keypad effects
-        //! Breathing effect type (Deprecated and should not be used).
-        typedef struct BREATHING_EFFECT_TYPE
-        {
-            //! Breathing effects.
-            enum Type
-            {
-                TWO_COLORS = 1,     //!< 2 colors
-                RANDOM_COLORS,      //!< Random colors
-                INVALID             //!< Invalid type
-            } Type;
-            COLORREF Color1;    //!< First color.
-            COLORREF Color2;    //!< Second color.
-        } BREATHING_EFFECT_TYPE;
-
-        //! Custom effect type
-        typedef struct CUSTOM_EFFECT_TYPE
-        {
-            RZCOLOR Color[MAX_ROW][MAX_COLUMN]; //!< Custom effect.
-                                                //!< For Razer Tartarus Chroma only Color[0] is valid. Use index '0' to change the keypad color.
-        } CUSTOM_EFFECT_TYPE;
-
-        //! Reactive effect type (Deprecated and should not be used).
-        typedef struct REACTIVE_EFFECT_TYPE
-        {
-            //! Duration of the effect.
-            enum Duration
-            {
-                DURATION_NONE=0,    //!< No duration.
-                DURATION_SHORT,     //!< Short duration.
-                DURATION_MEDIUM,    //!< Medium duration.
-                DURATION_LONG,      //!< Long duration.
-                DURATION_INVALID    //!< Invalid duration.
-            } Duration;             //!< The time taken for the effect to fade away.
-
-            COLORREF Color;         //!< Color of the effect
-        } REACTIVE_EFFECT_TYPE;
-
-        //! Static effect type
-        typedef struct STATIC_EFFECT_TYPE
-        {
-            RZCOLOR Color;  //!< Color of the effect.
-        } STATIC_EFFECT_TYPE;
-
-        //! Wave effect type (Deprecated and should not be used).
-        typedef struct WAVE_EFFECT_TYPE
-        {
-            //! Direction of the wave effect.
-            enum Direction
-            {
-                DIRECTION_NONE=0,           //!< No direction.
-                DIRECTION_LEFT_TO_RIGHT,    //!< Left to right.
-                DIRECTION_RIGHT_TO_LEFT,    //!< Right to left.
-                DIRECTION_INVALID           //!< Invalid direction.
-            } Direction;                    //!< Direction of the wave.
-        } WAVE_EFFECT_TYPE;
-    }
-
-    //! Chroma Link
-    namespace ChromaLink
-    {
-        //! Maximum number of elements/LEDs
-        const RZSIZE MAX_LEDS = 5;
-
-        //! Chroma Link effect types
-        typedef enum EFFECT_TYPE
-        {
-            CHROMA_NONE = 0,            //!< No effect.
-            CHROMA_CUSTOM,              //!< Custom effect.
-            CHROMA_STATIC,              //!< Static single color effect.
-            CHROMA_INVALID              //!< Invalid effect.
-        } EFFECT_TYPE;
-
-        //! Custom effect type.\n
-        //! Use Custom type to create a sequence of animated effects.\n
-        //! [ChromaLinkL#1|ChromaLinkL#2|ChromaLinkL#3|ChromaLinkL#4|ChromaLinkL#5].\n
-        typedef struct CUSTOM_EFFECT_TYPE
-        {
-            RZCOLOR Color[MAX_LEDS];    //!< Array of colors. 
-        } CUSTOM_EFFECT_TYPE;
-
-        //! Static effect type.\n
-        //! Use Static type to create effects for all LEDs (ChromaLinkL#1).
-        typedef struct STATIC_EFFECT_TYPE
-        {
-            RZCOLOR Color;  //!< Color of the effect.
-        } STATIC_EFFECT_TYPE;
-    }
-}
-
-#endif

dependencies/razer-chroma-2.9.0/inc/RzErrors.h

@@ -1,46 +0,0 @@
-
-//! \file RzErrors.h
-//! \brief Error codes for Chroma SDK. If the error is not defined here, refer to WinError.h from the Windows SDK.
-
-#ifndef _RZERRORS_H_
-#define _RZERRORS_H_
-
-#pragma once
-
-// Error codes
-//! Invalid
-#define     RZRESULT_INVALID                    -1L
-//! Success
-#define     RZRESULT_SUCCESS                    0L
-//! Access denied
-#define     RZRESULT_ACCESS_DENIED              5L
-//! Invalid handle
-#define     RZRESULT_INVALID_HANDLE             6L
-//! Not supported
-#define     RZRESULT_NOT_SUPPORTED              50L
-//! Invalid parameter.
-#define     RZRESULT_INVALID_PARAMETER          87L
-//! The service has not been started
-#define     RZRESULT_SERVICE_NOT_ACTIVE         1062L
-//! Cannot start more than one instance of the specified program.
-#define     RZRESULT_SINGLE_INSTANCE_APP        1152L
-//! Device not connected
-#define     RZRESULT_DEVICE_NOT_CONNECTED       1167L
-//! Element not found.
-#define     RZRESULT_NOT_FOUND                  1168L
-//! Request aborted.
-#define     RZRESULT_REQUEST_ABORTED            1235L
-//! An attempt was made to perform an initialization operation when initialization has already been completed.
-#define     RZRESULT_ALREADY_INITIALIZED        1247L
-//! Resource not available or disabled
-#define     RZRESULT_RESOURCE_DISABLED          4309L
-//! Device not available or supported
-#define     RZRESULT_DEVICE_NOT_AVAILABLE       4319L
-//! The group or resource is not in the correct state to perform the requested operation.
-#define     RZRESULT_NOT_VALID_STATE            5023L
-//! No more items
-#define     RZRESULT_NO_MORE_ITEMS              259L
-//! General failure.
-#define     RZRESULT_FAILED                     2147500037L
-
-#endif

qt/OpenRGBDevicePage.cpp

@@ -62,7 +62,7 @@ OpenRGBDevicePage::OpenRGBDevicePage(RGBController *dev, QWidget *parent) :
     ui->ButtonMagenta->update();
 
     /*-----------------------------------------------------*\
-    | Fill in the combo boxes with device information       |
+    | Fill in the mode selection box                        |
     \*-----------------------------------------------------*/
     ui->ModeBox->blockSignals(true);
     ui->ModeBox->clear();
@@ -79,29 +79,6 @@ OpenRGBDevicePage::OpenRGBDevicePage(RGBController *dev, QWidget *parent) :
     | Update mode user interface elements                   |
     \*-----------------------------------------------------*/
     UpdateModeUi();
-
-    ui->ZoneBox->blockSignals(true);
-    ui->ZoneBox->clear();
-
-    ui->ZoneBox->addItem("All Zones");
-
-    for (std::size_t i = 0; i < device->zones.size(); i++)
-    {
-        ui->ZoneBox->addItem(device->zones[i].name.c_str());
-    }
-
-    ui->ZoneBox->setCurrentIndex(0);
-    ui->ZoneBox->blockSignals(false);
-
-    /*-----------------------------------------------------*\
-    | Update LED box                                        |
-    \*-----------------------------------------------------*/
-    on_ZoneBox_currentIndexChanged(0);
-
-    /*-----------------------------------------------------*\
-    | Update color picker with color of first LED           |
-    \*-----------------------------------------------------*/
-    on_LEDBox_currentIndexChanged(0);
 }
 
 OpenRGBDevicePage::~OpenRGBDevicePage()
@@ -111,76 +88,116 @@ OpenRGBDevicePage::~OpenRGBDevicePage()
 
 void Ui::OpenRGBDevicePage::on_ZoneBox_currentIndexChanged(int /*index*/)
 {
-    unsigned int selected_zone = ui->ZoneBox->currentIndex();
+    /*-----------------------------------------------------*\
+    | Read selected mode                                    |
+    \*-----------------------------------------------------*/
+    unsigned int selected_mode   = (unsigned int)ui->ModeBox->currentIndex();
 
-    ui->LEDBox->blockSignals(true);
-    ui->LEDBox->clear();
-
-    if(selected_zone == 0)
+    switch(device->modes[selected_mode].color_mode)
     {
-        for (std::size_t i = 0; i < device->leds.size(); i++)
-        {
-            ui->LEDBox->addItem(device->leds[i].name.c_str());
-        }
-    }
-    else
-    {
-        selected_zone = selected_zone - 1;
-
-        for (std::size_t y = 0; y < device->zones[selected_zone].map.size(); y++)
-        {
-            for(std::size_t x = 0; x < device->zones[selected_zone].map[y].size(); x++)
+        case MODE_COLORS_PER_LED:
             {
-                ui->LEDBox->addItem(device->leds[device->zones[selected_zone].map[y][x]].name.c_str());
-            }
-        }
-    }
+                unsigned int selected_zone = ui->ZoneBox->currentIndex();
 
-    ui->LEDBox->setCurrentIndex(0);
-    on_LEDBox_currentIndexChanged(0);
-    ui->LEDBox->blockSignals(false);
+                ui->LEDBox->blockSignals(true);
+                ui->LEDBox->clear();
+
+                if(selected_zone == 0)
+                {
+                    for (std::size_t i = 0; i < device->leds.size(); i++)
+                    {
+                        ui->LEDBox->addItem(device->leds[i].name.c_str());
+                    }
+                }
+                else
+                {
+                    selected_zone = selected_zone - 1;
+
+                    for (std::size_t y = 0; y < device->zones[selected_zone].map.size(); y++)
+                    {
+                        for(std::size_t x = 0; x < device->zones[selected_zone].map[y].size(); x++)
+                        {
+                            ui->LEDBox->addItem(device->leds[device->zones[selected_zone].map[y][x]].name.c_str());
+                        }
+                    }
+                }
+
+                ui->LEDBox->setCurrentIndex(0);
+                on_LEDBox_currentIndexChanged(0);
+                ui->LEDBox->blockSignals(false);
+            }
+            break;
+    }
 }
 
 void Ui::OpenRGBDevicePage::on_LEDBox_currentIndexChanged(int index)
 {
-    unsigned int selected_zone = ui->ZoneBox->currentIndex();
-
-    if(selected_zone > 0)
-    {
-        selected_zone = selected_zone - 1;
-
-        unsigned int count = 0;
-
-        for (std::size_t y = 0; y < device->zones[selected_zone].map.size(); y++)
-        {
-            for(std::size_t x = 0; x < device->zones[selected_zone].map[y].size(); x++)
-            {
-                if(count == index)
-                {
-                    index = device->zones[selected_zone].map[y][x];
-                    break;
-                }
-                else
-                {
-                    count++;
-                }
-            }
-        }
-    }
-    
     /*-----------------------------------------------------*\
-    | Update color picker with color of selected LED        |
+    | Read selected mode                                    |
     \*-----------------------------------------------------*/
-    RGBColor color = device->GetLED(index);
-    UpdatingColor = true;
-    ui->RedSpinBox->setValue(RGBGetRValue(color));
-    ui->GreenSpinBox->setValue(RGBGetGValue(color));
-    ui->BlueSpinBox->setValue(RGBGetBValue(color));
-    UpdatingColor = false;
-    updateHSV();
+    unsigned int selected_mode   = (unsigned int)ui->ModeBox->currentIndex();
+
+    switch(device->modes[selected_mode].color_mode)
+    {
+        case MODE_COLORS_PER_LED:
+            {
+                unsigned int selected_zone = ui->ZoneBox->currentIndex();
+
+                if(selected_zone > 0)
+                {
+                    selected_zone = selected_zone - 1;
+
+                    unsigned int count = 0;
+
+                    for (std::size_t y = 0; y < device->zones[selected_zone].map.size(); y++)
+                    {
+                        for(std::size_t x = 0; x < device->zones[selected_zone].map[y].size(); x++)
+                        {
+                            if(count == index)
+                            {
+                                index = device->zones[selected_zone].map[y][x];
+                                break;
+                            }
+                            else
+                            {
+                                count++;
+                            }
+                        }
+                    }
+                }
+
+                /*-----------------------------------------------------*\
+                | Update color picker with color of selected LED        |
+                \*-----------------------------------------------------*/
+                RGBColor color = device->GetLED(index);
+                UpdatingColor = true;
+                ui->RedSpinBox->setValue(RGBGetRValue(color));
+                ui->GreenSpinBox->setValue(RGBGetGValue(color));
+                ui->BlueSpinBox->setValue(RGBGetBValue(color));
+                UpdatingColor = false;
+                updateHSV();
+            }
+            break;
+
+        case MODE_COLORS_MODE_SPECIFIC:
+            {
+            /*-----------------------------------------------------*\
+            | Update color picker with color of selected mode       |
+            \*-----------------------------------------------------*/
+            RGBColor color = device->modes[selected_mode].colors[index];
+            UpdatingColor = true;
+            ui->RedSpinBox->setValue(RGBGetRValue(color));
+            ui->GreenSpinBox->setValue(RGBGetGValue(color));
+            ui->BlueSpinBox->setValue(RGBGetBValue(color));
+            UpdatingColor = false;
+            updateHSV();
+            }
+            break;
+    }
+
 }
 
-void Ui::OpenRGBDevicePage::on_ModeBox_currentIndexChanged(int /*index*/)
+void Ui::OpenRGBDevicePage::on_ModeBox_currentIndexChanged(int index)
 {
     /*-----------------------------------------------------*\
     | Update mode user interface elements                   |
@@ -193,12 +210,43 @@ void Ui::OpenRGBDevicePage::on_ModeBox_currentIndexChanged(int /*index*/)
     UpdateMode();
 }
 
+void Ui::OpenRGBDevicePage::on_PerLEDCheck_clicked()
+{
+    /*-----------------------------------------------------*\
+    | Change device mode                                    |
+    \*-----------------------------------------------------*/
+    UpdateMode();
+
+    /*-----------------------------------------------------*\
+    | Update mode user interface elements                   |
+    \*-----------------------------------------------------*/
+    UpdateModeUi();
+}
+
+void Ui::OpenRGBDevicePage::on_ModeSpecificCheck_clicked()
+{
+    /*-----------------------------------------------------*\
+    | Change device mode                                    |
+    \*-----------------------------------------------------*/
+    UpdateMode();
+
+    /*-----------------------------------------------------*\
+    | Update mode user interface elements                   |
+    \*-----------------------------------------------------*/
+    UpdateModeUi();
+}
+
 void Ui::OpenRGBDevicePage::on_RandomCheck_clicked()
 {
     /*-----------------------------------------------------*\
     | Change device mode                                    |
     \*-----------------------------------------------------*/
     UpdateMode();
+
+    /*-----------------------------------------------------*\
+    | Update mode user interface elements                   |
+    \*-----------------------------------------------------*/
+    UpdateModeUi();
 }
 
 void Ui::OpenRGBDevicePage::on_SpeedSlider_valueChanged(int /*value*/)
@@ -220,23 +268,26 @@ void Ui::OpenRGBDevicePage::on_DirectionBox_currentIndexChanged(int /*index*/)
 void Ui::OpenRGBDevicePage::UpdateModeUi()
 {
     /*-----------------------------------------------------*\
-    | Read new mode flags and settings                      |
+    | Read selected mode                                    |
     \*-----------------------------------------------------*/
-    int  selected_mode   = ui->ModeBox->currentIndex();
+    unsigned int selected_mode   = (unsigned int)ui->ModeBox->currentIndex();
 
     /*-----------------------------------------------------*\
     | Don't update the UI if the current mode is invalid    |
     \*-----------------------------------------------------*/
     if(selected_mode < device->modes.size())
     {
-        bool supports_random = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_COLOR )
-                            && ( device->modes[selected_mode].flags & MODE_FLAG_RANDOM_COLOR );
-        bool supports_speed  = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_SPEED );
-        bool supports_dir_lr = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_DIRECTION_LR );
-        bool supports_dir_ud = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_DIRECTION_UD );
-        bool supports_dir_hv = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_DIRECTION_HV );
-        bool random          = device->modes[selected_mode].random;
-        unsigned int dir     = device->modes[selected_mode].direction;
+        bool supports_per_led       = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_PER_LED_COLOR );
+        bool supports_mode_specific = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR );
+        bool supports_random        = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_RANDOM_COLOR );
+        bool supports_speed         = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_SPEED );
+        bool supports_dir_lr        = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_DIRECTION_LR );
+        bool supports_dir_ud        = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_DIRECTION_UD );
+        bool supports_dir_hv        = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_DIRECTION_HV );
+        bool per_led                = device->modes[selected_mode].color_mode == MODE_COLORS_PER_LED;
+        bool mode_specific          = device->modes[selected_mode].color_mode == MODE_COLORS_MODE_SPECIFIC;
+        bool random                 = device->modes[selected_mode].color_mode == MODE_COLORS_RANDOM;
+        unsigned int dir            = device->modes[selected_mode].direction;
 
         if(supports_speed)
         {
@@ -266,6 +317,7 @@ void Ui::OpenRGBDevicePage::UpdateModeUi()
             ui->SpeedSlider->blockSignals(false);
         }
 
+        ui->DirectionBox->blockSignals(true);
         ui->DirectionBox->clear();
         
         if(supports_dir_lr)
@@ -334,15 +386,108 @@ void Ui::OpenRGBDevicePage::UpdateModeUi()
             ui->DirectionBox->setEnabled(false);
         }
         
+        ui->DirectionBox->blockSignals(false);
+
+        if(supports_per_led)
+        {
+            ui->PerLEDCheck->setEnabled(true);
+            ui->PerLEDCheck->setChecked(per_led);
+        }
+        else
+        {
+            ui->PerLEDCheck->setEnabled(false);
+            ui->PerLEDCheck->setAutoExclusive(false);
+            ui->PerLEDCheck->setChecked(false);
+            ui->PerLEDCheck->setAutoExclusive(true);
+        }
+
+        if(supports_mode_specific)
+        {
+            ui->ModeSpecificCheck->setEnabled(true);
+            ui->ModeSpecificCheck->setChecked(mode_specific);
+        }
+        else
+        {
+            ui->ModeSpecificCheck->setEnabled(false);
+            ui->ModeSpecificCheck->setAutoExclusive(false);
+            ui->ModeSpecificCheck->setChecked(false);
+            ui->ModeSpecificCheck->setAutoExclusive(true);
+        }
+
         if(supports_random)
         {
             ui->RandomCheck->setEnabled(true);
-            ui->RandomCheck->setCheckState(random ? Qt::CheckState::Checked : Qt::CheckState::Unchecked);
+            ui->RandomCheck->setChecked(random);
         }
         else
         {
             ui->RandomCheck->setEnabled(false);
-            ui->RandomCheck->setCheckState(random ? Qt::CheckState::Checked : Qt::CheckState::Unchecked);
+            ui->RandomCheck->setAutoExclusive(false);
+            ui->RandomCheck->setChecked(false);
+            ui->RandomCheck->setAutoExclusive(true);
+        }
+
+        /*-----------------------------------------------------*\
+        | Fill in the zone box based on color mode              |
+        \*-----------------------------------------------------*/
+        switch(device->modes[selected_mode].color_mode)
+        {
+            case MODE_COLORS_NONE:
+            case MODE_COLORS_RANDOM:
+                ui->ZoneBox->blockSignals(true);
+                ui->ZoneBox->clear();
+                ui->ZoneBox->blockSignals(false);
+
+                ui->LEDBox->blockSignals(true);
+                ui->LEDBox->clear();
+                ui->LEDBox->blockSignals(false);
+                break;
+
+            case MODE_COLORS_PER_LED:
+                ui->ZoneBox->blockSignals(true);
+                ui->ZoneBox->clear();
+
+                ui->ZoneBox->addItem("All Zones");
+
+                for (std::size_t i = 0; i < device->zones.size(); i++)
+                {
+                    ui->ZoneBox->addItem(device->zones[i].name.c_str());
+                }
+
+                ui->ZoneBox->setCurrentIndex(0);
+                ui->ZoneBox->blockSignals(false);
+
+                /*-----------------------------------------------------*\
+                | Update LED box                                        |
+                \*-----------------------------------------------------*/
+                on_ZoneBox_currentIndexChanged(0);
+
+                /*-----------------------------------------------------*\
+                | Update color picker with color of first LED           |
+                \*-----------------------------------------------------*/
+                on_LEDBox_currentIndexChanged(0);
+                break;
+
+            case MODE_COLORS_MODE_SPECIFIC:
+                ui->ZoneBox->blockSignals(true);
+                ui->ZoneBox->clear();
+                ui->ZoneBox->addItem("Mode Specific");
+                ui->ZoneBox->blockSignals(false);
+
+                ui->LEDBox->blockSignals(true);
+                ui->LEDBox->clear();
+
+                for (std::size_t i = 0; i < device->modes[selected_mode].colors.size(); i++)
+                {
+                    char id_buf[32];
+                    snprintf(id_buf, 16, "Mode Color %d", i);
+                    ui->LEDBox->addItem(id_buf);
+                }
+
+                ui->LEDBox->setCurrentIndex(0);
+                on_LEDBox_currentIndexChanged(0);
+                ui->LEDBox->blockSignals(false);
+                break;
         }
     }
 }
@@ -350,14 +495,16 @@ void Ui::OpenRGBDevicePage::UpdateModeUi()
 void Ui::OpenRGBDevicePage::UpdateMode()
 {
     /*-----------------------------------------------------*\
-    | Read user interface                                   |
+    | Read selected mode                                    |
     \*-----------------------------------------------------*/
-    int  current_mode      = ui->ModeBox->currentIndex();
+    unsigned int current_mode   = (unsigned int)ui->ModeBox->currentIndex();
 
     if(current_mode >= 0)
     {
         int  current_speed     = 0;
-        bool current_random    = ui->RandomCheck->checkState();
+        bool current_per_led   = ui->PerLEDCheck->isChecked();
+        bool current_mode_specific = ui->ModeSpecificCheck->isChecked();
+        bool current_random    = ui->RandomCheck->isChecked();
         int  current_dir_idx   = ui->DirectionBox->currentIndex();
         int  current_direction = 0;
         bool supports_dir_lr = ( device->modes[current_mode].flags & MODE_FLAG_HAS_DIRECTION_LR );
@@ -428,7 +575,23 @@ void Ui::OpenRGBDevicePage::UpdateMode()
             | Update mode parameters                                |
             \*-----------------------------------------------------*/
             device->modes[current_mode].speed  = current_speed;
-            device->modes[current_mode].random = current_random;
+
+            if(current_per_led)
+            {
+                device->modes[current_mode].color_mode = MODE_COLORS_PER_LED;
+            }
+            else if(current_mode_specific)
+            {
+                device->modes[current_mode].color_mode = MODE_COLORS_MODE_SPECIFIC;
+            }
+            else if(current_random)
+            {
+                device->modes[current_mode].color_mode = MODE_COLORS_RANDOM;
+            }
+            else
+            {
+                device->modes[current_mode].color_mode = MODE_COLORS_NONE;
+            }
 
             /*-----------------------------------------------------*\
             | Change device mode                                    |
@@ -463,80 +626,153 @@ void Ui::OpenRGBDevicePage::SetCustomMode()
 void Ui::OpenRGBDevicePage::on_SetDeviceButton_clicked()
 {
     /*-----------------------------------------------------*\
-    | Set all device LEDs to the current color              |
+    | Read selected mode                                    |
     \*-----------------------------------------------------*/
-    RGBColor color = ToRGBColor(
-        ui->RedSpinBox->text().toInt(),
-        ui->GreenSpinBox->text().toInt(),
-        ui->BlueSpinBox->text().toInt()
-    );
+    unsigned int selected_mode   = (unsigned int)ui->ModeBox->currentIndex();
 
-    device->SetAllLEDs(color);
+    switch(device->modes[selected_mode].color_mode)
+    {
+        case MODE_COLORS_PER_LED:
+            {
+                /*-----------------------------------------------------*\
+                | Set all device LEDs to the current color              |
+                \*-----------------------------------------------------*/
+                RGBColor color = ToRGBColor(
+                    ui->RedSpinBox->text().toInt(),
+                    ui->GreenSpinBox->text().toInt(),
+                    ui->BlueSpinBox->text().toInt()
+                );
+
+                device->SetAllLEDs(color);
+            }
+            break;
+
+        case MODE_COLORS_MODE_SPECIFIC:
+            {
+                /*-----------------------------------------------------*\
+                | Set all device LEDs to the current color              |
+                \*-----------------------------------------------------*/
+                RGBColor color = ToRGBColor(
+                    ui->RedSpinBox->text().toInt(),
+                    ui->GreenSpinBox->text().toInt(),
+                    ui->BlueSpinBox->text().toInt()
+                );
+
+                for(int i = 0; i < device->modes[selected_mode].colors.size(); i++)
+                {
+                    device->modes[selected_mode].colors[i] = color;
+                }
+
+                device->UpdateMode();
+            }
+            break;
+    }
 }
 
 void Ui::OpenRGBDevicePage::on_SetZoneButton_clicked()
 {
-    unsigned int index = ui->ZoneBox->currentIndex();
+    /*-----------------------------------------------------*\
+    | Read selected mode                                    |
+    \*-----------------------------------------------------*/
+    unsigned int selected_mode   = (unsigned int)ui->ModeBox->currentIndex();
 
-    if(index == 0)
+    switch(device->modes[selected_mode].color_mode)
     {
-        on_SetDeviceButton_clicked();
-    }
-    else
-    {
-        index = index - 1;
+        case MODE_COLORS_PER_LED:
+            {
+                unsigned int index = ui->ZoneBox->currentIndex();
 
-        /*-----------------------------------------------------*\
-        | Set all LEDs in the selected zone to the current color|
-        \*-----------------------------------------------------*/
-        RGBColor color = ToRGBColor(
-            ui->RedSpinBox->text().toInt(),
-            ui->GreenSpinBox->text().toInt(),
-            ui->BlueSpinBox->text().toInt()
-        );
+                if(index == 0)
+                {
+                    on_SetDeviceButton_clicked();
+                }
+                else
+                {
+                    index = index - 1;
 
-        device->SetAllZoneLEDs(index, color);
+                    /*-----------------------------------------------------*\
+                    | Set all LEDs in the selected zone to the current color|
+                    \*-----------------------------------------------------*/
+                    RGBColor color = ToRGBColor(
+                        ui->RedSpinBox->text().toInt(),
+                        ui->GreenSpinBox->text().toInt(),
+                        ui->BlueSpinBox->text().toInt()
+                    );
+
+                    device->SetAllZoneLEDs(index, color);
+                }
+            }
+            break;
     }
 }
 
 void Ui::OpenRGBDevicePage::on_SetLEDButton_clicked()
 {
-    unsigned int index = ui->LEDBox->currentIndex();
-    unsigned int selected_zone = ui->ZoneBox->currentIndex();
-
-    if(selected_zone > 0)
-    {
-        selected_zone = selected_zone - 1;
-
-        unsigned int count = 0;
-
-        for (std::size_t y = 0; y < device->zones[selected_zone].map.size(); y++)
-        {
-            for(std::size_t x = 0; x < device->zones[selected_zone].map[y].size(); x++)
-            {
-                if(count == index)
-                {
-                    index = device->zones[selected_zone].map[y][x];
-                    break;
-                }
-                else
-                {
-                    count++;
-                }
-            }
-        }
-    }
-
     /*-----------------------------------------------------*\
-    | Set the selected LED to the current color             |
+    | Read selected mode                                    |
     \*-----------------------------------------------------*/
-    RGBColor color = ToRGBColor(
-        ui->RedSpinBox->text().toInt(),
-        ui->GreenSpinBox->text().toInt(),
-        ui->BlueSpinBox->text().toInt()
-    );
+    unsigned int selected_mode   = (unsigned int)ui->ModeBox->currentIndex();
+    unsigned int index = ui->LEDBox->currentIndex();
 
-    device->SetLED(index, color);
+    switch(device->modes[selected_mode].color_mode)
+    {
+        case MODE_COLORS_PER_LED:
+            {
+                unsigned int selected_zone = ui->ZoneBox->currentIndex();
+
+                if(selected_zone > 0)
+                {
+                    selected_zone = selected_zone - 1;
+
+                    unsigned int count = 0;
+
+                    for (std::size_t y = 0; y < device->zones[selected_zone].map.size(); y++)
+                    {
+                        for(std::size_t x = 0; x < device->zones[selected_zone].map[y].size(); x++)
+                        {
+                            if(count == index)
+                            {
+                                index = device->zones[selected_zone].map[y][x];
+                                break;
+                            }
+                            else
+                            {
+                                count++;
+                            }
+                        }
+                    }
+                }
+
+                /*-----------------------------------------------------*\
+                | Set the selected LED to the current color             |
+                \*-----------------------------------------------------*/
+                RGBColor color = ToRGBColor(
+                    ui->RedSpinBox->text().toInt(),
+                    ui->GreenSpinBox->text().toInt(),
+                    ui->BlueSpinBox->text().toInt()
+                );
+
+                device->SetLED(index, color);
+            }
+            break;
+
+        case MODE_COLORS_MODE_SPECIFIC:
+            {
+                /*-----------------------------------------------------*\
+                | Set all device LEDs to the current color              |
+                \*-----------------------------------------------------*/
+                RGBColor color = ToRGBColor(
+                    ui->RedSpinBox->text().toInt(),
+                    ui->GreenSpinBox->text().toInt(),
+                    ui->BlueSpinBox->text().toInt()
+                );
+
+                device->modes[selected_mode].colors[index] = color;
+
+                device->UpdateMode();
+            }
+            break;
+    }
 }
 
 void Ui::OpenRGBDevicePage::on_ButtonRed_clicked()

qt/OpenRGBDevicePage.h

@@ -51,6 +51,10 @@ private slots:
 
     void on_DirectionBox_currentIndexChanged(int index);
 
+    void on_PerLEDCheck_clicked();
+
+    void on_ModeSpecificCheck_clicked();
+
 private:
     Ui::OpenRGBDevicePageUi *ui;
     RGBController *device;

qt/OpenRGBDevicePage.ui

@@ -122,13 +122,6 @@
      </property>
     </widget>
    </item>
-   <item row="6" column="1" colspan="3">
-    <widget class="QCheckBox" name="RandomCheck">
-     <property name="text">
-      <string>Random Color</string>
-     </property>
-    </widget>
-   </item>
    <item row="1" column="1" colspan="3">
     <widget class="QComboBox" name="LEDBox"/>
    </item>
@@ -236,6 +229,34 @@
      </property>
     </widget>
    </item>
+   <item row="6" column="1">
+    <widget class="QRadioButton" name="PerLEDCheck">
+     <property name="text">
+      <string>Per-LED</string>
+     </property>
+    </widget>
+   </item>
+   <item row="6" column="2">
+    <widget class="QRadioButton" name="ModeSpecificCheck">
+     <property name="text">
+      <string>Mode-Specific</string>
+     </property>
+    </widget>
+   </item>
+   <item row="6" column="3">
+    <widget class="QRadioButton" name="RandomCheck">
+     <property name="text">
+      <string>Random</string>
+     </property>
+    </widget>
+   </item>
+   <item row="6" column="0">
+    <widget class="QLabel" name="ColorLabel">
+     <property name="text">
+      <string>Colors:</string>
+     </property>
+    </widget>
+   </item>
   </layout>
  </widget>
  <resources/>