Remove some detection checks for Corsair Vengeance RGB Pro detection as it was no longer detecting my modules with them

.gitignore

@@ -1 +0,0 @@
-*.pro.user*

.gitmodules

@@ -1,6 +1,3 @@
 [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/AuraController/AuraControllerDetect.cpp

@@ -20,7 +20,7 @@ static void Sleep(unsigned int milliseconds)
 /*----------------------------------------------------------------------*\
 | This list contains the available SMBus addresses for mapping Aura RAM  |
 \*----------------------------------------------------------------------*/
-#define AURA_RAM_ADDRESS_COUNT  21
+#define AURA_RAM_ADDRESS_COUNT  17
 
 static const unsigned char aura_ram_addresses[] =
 {
@@ -40,11 +40,7 @@ static const unsigned char aura_ram_addresses[] =
     0x7F,
     0x4F,
     0x66,
-    0x67,
-    0x39,
-    0x3B,
-    0x3C,
-    0x3D
+    0x67
 };
 
 /*---------------------------------------------------------------------------------*\
@@ -135,7 +131,7 @@ void DetectAuraControllers(std::vector<i2c_smbus_interface*> &busses, std::vecto
 
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
-        int address_list_idx = -1;
+        int address_list_idx = 0;
 
         // Remap Aura-enabled RAM modules on 0x77
         for (unsigned int slot = 0; slot < 8; slot++)
@@ -151,8 +147,8 @@ void DetectAuraControllers(std::vector<i2c_smbus_interface*> &busses, std::vecto
             {
                 if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
                 {
-                    address_list_idx++;
                     res = busses[bus]->i2c_smbus_write_quick(aura_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
+                    address_list_idx++;
                 }
                 else
                 {

Controllers/AuraGPUController/AuraGPUController.cpp

@@ -1,84 +0,0 @@
-/*-----------------------------------------*\
-|  AuraGPUController.cpp                    |
-|                                           |
-|  Driver for ASUS Aura RGB on GPUs         |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
-
-#include "AuraGPUController.h"
-#include <cstring>
-
-AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-
-    strcpy(device_name, "ASUS Aura GPU");                                               // Would be nice to get the actual GPU name. Using this as a placeholder.
-}
-
-AuraGPUController::~AuraGPUController()
-{
-
-}
-
-std::string AuraGPUController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string AuraGPUController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return(return_string);
-}
-
-unsigned char AuraGPUController::GetLEDRed()
-{
-    return(AuraGPURegisterRead(AURA_GPU_REG_RED));
-}
-
-unsigned char AuraGPUController::GetLEDGreen()
-{
-    return(AuraGPURegisterRead(AURA_GPU_REG_GREEN));
-}
-
-unsigned char AuraGPUController::GetLEDBlue()
-{
-    return(AuraGPURegisterRead(AURA_GPU_REG_BLUE));
-}
-
-void AuraGPUController::SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue)                  // Direct Mode is just Static Mode without applying color changes
-{
-    AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
-    AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
-    AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
-}
-
-void AuraGPUController::SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
-    AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
-    AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
-    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
-}
-
-void AuraGPUController::SetMode(unsigned char mode)
-{
-    AuraGPURegisterWrite(AURA_GPU_REG_MODE, mode);
-    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
-}
-
-unsigned char AuraGPUController::AuraGPURegisterRead(unsigned char reg)
-{
-    return(bus->i2c_smbus_read_byte_data(dev, reg));
-}
-
-void AuraGPUController::AuraGPURegisterWrite(unsigned char reg, unsigned char val)
-{
-    bus->i2c_smbus_write_byte_data(dev, reg, val);
-}

Controllers/AuraGPUController/AuraGPUController.h

@@ -1,64 +0,0 @@
-/*-----------------------------------------*\
-|  AuraGPUController.h                      |
-|                                           |
-|  Definitions for ASUS Aura RGB on GPUs    |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
-
-#include <string>
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char aura_gpu_dev_id;
-
-#define AURA_GPU_MAGIC_VAL 0x1589                   /* This magic value is present in all Aura GPU controllers */
-#define AURA_GPU_APPLY_VAL 0x01                     /* Value for Apply Changes Register     */
-
-enum
-{
-    AURA_GPU_REG_RED                        = 0x04,    /* AURA GPU RED Register            */
-    AURA_GPU_REG_GREEN                      = 0x05,    /* AURA GPU GREEN Register          */
-    AURA_GPU_REG_BLUE                       = 0x06,    /* AURA GPU BLUE Register           */
-    AURA_GPU_REG_MODE                       = 0x07,    /* AURA GPU Mode Selection Register */
-    AURA_GPU_REG_SYNC                       = 0x0C,    /* AURA GPU "Sync" Register         */
-    AURA_GPU_REG_APPLY                      = 0x0E,    /* AURA GPU Apply Chnages Register  */
-};
-
-enum
-{
-    AURA_GPU_MODE_OFF                       = 0,        /* OFF mode (not a real Mode! Doesn't do anything!)    */
-    AURA_GPU_MODE_STATIC                    = 1,        /* Static color mode                                   */
-    AURA_GPU_MODE_BREATHING                 = 2,        /* Breathing effect mode                               */
-    AURA_GPU_MODE_FLASHING                  = 3,        /* Flashing effect mode                                */
-    AURA_GPU_MODE_SPECTRUM_CYCLE            = 4,        /* Spectrum Cycle mode                                 */
-    AURA_GPU_MODE_DIRECT                    = 5,        /* Direct mode (not a real Mode! Doesn't do anything!) */
-    AURA_GPU_NUMBER_MODES
-};
-
-class AuraGPUController
-{
-public:
-    AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id);
-    ~AuraGPUController();
-
-    std::string   GetDeviceName();
-    std::string   GetDeviceLocation();
-    unsigned char GetLEDRed();
-    unsigned char GetLEDGreen();
-    unsigned char GetLEDBlue();
-    void          SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetMode(unsigned char mode);
-
-    unsigned char AuraGPURegisterRead(unsigned char reg);
-    void          AuraGPURegisterWrite(unsigned char reg, unsigned char val);
-
-    bool          direct = false;                                                // Temporary solution to check if we are in "Direct" mode
-
-private:
-    char                    device_name[16];
-    i2c_smbus_interface *   bus;
-    aura_gpu_dev_id         dev;
-};

Controllers/AuraGPUController/AuraGPUControllerDetect.cpp

@@ -1,94 +0,0 @@
-/*-----------------------------------------*\
-|  AuraGPUControllerDetect.cpp              |
-|                                           |
-|  Driver for ASUS Aura RGB on GPUs         |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
-
-#include "AuraGPUController.h"
-#include "RGBController.h"
-#include "RGBController_AuraGPU.h"
-#include "i2c_smbus.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef WIN32
-#include <Windows.h>
-#else
-#include <unistd.h>
-
-static void Sleep(unsigned int milliseconds)
-{
-    usleep(1000 * milliseconds);
-}
-#endif
-
-/*-------------------------------------------------------------*\
-| This list contains the available I2C addresses for Aura GPUs  |
-\*-------------------------------------------------------------*/
-#define AURA_GPU_ADDRESS_COUNT 3
-
-static const unsigned char aura_gpu_addresses[] =
-{
-    0x29,
-    0x2A,
-    0x60
-};
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForAuraGPUController                                                               *
-*                                                                                          *
-*       Tests the given address to see if an Aura GPU controller exists there.             *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    unsigned char aura_gpu_magic_high = bus->i2c_smbus_read_byte_data(address, 0x20);                        // High Byte of magic (0x15)                        
-    unsigned char aura_gpu_magic_low = bus->i2c_smbus_read_byte_data(address, 0x21);                         // Low Byte of magic (0x89)
-
-    if((aura_gpu_magic_high << 8) + aura_gpu_magic_low == AURA_GPU_MAGIC_VAL)
-    {
-        pass = true;
-    }
-
-    return(pass);
-
-}   /* TestForAuraGPUController() */
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraGPUControllers                                                               *
-*                                                                                          *
-*       Detect Aura GPU controllers on the enumerated I2C busses.                          *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
-{
-    AuraGPUController* new_aura_gpu;
-    RGBController_AuraGPU* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        // Add Aura-enabled GPU controllers
-        for (unsigned int address_list_idx = 0; address_list_idx < AURA_GPU_ADDRESS_COUNT; address_list_idx++)
-        {
-            if (TestForAuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]))
-            {
-                new_aura_gpu = new AuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]);
-                new_controller = new RGBController_AuraGPU(new_aura_gpu);
-                rgb_controllers.push_back(new_controller);
-            }
-
-            Sleep(1);
-        }
-    }
-} /* DetectAuraGPUControllers() */

Controllers/CorsairCmdrProController/CorsairCmdrProController.cpp

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

Controllers/CorsairCmdrProController/CorsairCmdrProController.h

@@ -80,6 +80,7 @@ public:
     CorsairCmdrProController(libusb_device_handle* dev_handle);
     ~CorsairCmdrProController();
     
+    char*           GetLEDString();
     unsigned int    GetStripsOnChannel(unsigned int channel);
 
     void            SetChannelEffect(unsigned char channel,
@@ -92,10 +93,7 @@ public:
                                      unsigned char blu1,
                                      unsigned char red2,
                                      unsigned char grn2,
-                                     unsigned char blu2,
-                                     unsigned char red3,
-                                     unsigned char grn3,
-                                     unsigned char blu3
+                                     unsigned char blu2
                                     );
 
     void            SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors);

Controllers/CorsairController/CorsairControllerDetect.cpp

@@ -104,22 +104,6 @@ void DetectCorsairControllers(std::vector<i2c_smbus_interface*> &busses, std::ve
             new_controller = new RGBController_Corsair(new_corsair);
             rgb_controllers.push_back(new_controller);
         }
-
-        // Check for Corsair controller at 0x5E
-        if (TestForCorsairController(busses[bus], 0x5E))
-        {
-            new_corsair = new CorsairController(busses[bus], 0x5E);
-            new_controller = new RGBController_Corsair(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x5F
-        if (TestForCorsairController(busses[bus], 0x5F))
-        {
-            new_corsair = new CorsairController(busses[bus], 0x5F);
-            new_controller = new RGBController_Corsair(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
     }
 
 }   /* DetectCorsairControllers() */

Controllers/CorsairKeyboardController/CorsairKeyboardController.cpp

@@ -1,253 +0,0 @@
-/*-----------------------------------------*\
-|  CorsairKeyboardController.cpp            |
-|                                           |
-|  Driver for Corsair RGB keyboard lighting |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/9/2020    |
-\*-----------------------------------------*/
-
-#include "CorsairKeyboardController.h"
-
-#include <cstring>
-
-static unsigned int keys[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0C, 0x0D, 0x0E, 0x0F, 0x11, 0x12,
-                              0x14, 0x15, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x24, 0x25, 0x26,
-                              0x27, 0x28, 0x2A, 0x2B, 0x2C, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
-                              0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x42, 0x43, 0x44, 0x45, 0x48, 73,   74,   75,   76,   78,
-                              79,   80,   81,   84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   96,   97,
-                              98,   99,   100,  101,  102,  103,  104,  105,  108,  109,  110,  111,  112,  113,  115,
-                              116,  117,  120,  121,  122,  123,  124,  126,  127,  128,  129,  132,  133,  134,  135,
-                              136,  137,  139,  140,  141};
-
-static void send_usb_msg(hid_device* dev, char * data_pkt)
-{
-    char usb_pkt[65];
-    usb_pkt[0] = 0x00;
-    for(int i = 1; i < 65; i++)
-    {
-        usb_pkt[i] = data_pkt[i-1];
-    }
-    int bytes = hid_send_feature_report(dev, (unsigned char *)usb_pkt, 65);
-    bytes++;
-}
-
-static void get_usb_msg(hid_device* dev, char* data_pkt)
-{
-    char usb_pkt[65];
-    usb_pkt[0] = 0x00;
-    for(int i = 1; i < 65; i++)
-    {
-        usb_pkt[i] = data_pkt[i-1];
-    }
-    int bytes = hid_get_feature_report(dev, (unsigned char*)data_pkt, 64);
-    bytes++;
-}
-
-CorsairKeyboardController::CorsairKeyboardController(hid_device* dev_handle)
-{
-    dev = dev_handle;
-
-    char data_pkt[64] = { 0 };
-
-    LightingControl();
-}
-
-CorsairKeyboardController::~CorsairKeyboardController()
-{
-
-}
-
-void CorsairKeyboardController::SetLEDs(std::vector<RGBColor> colors)
-{
-    unsigned char data_pkt[216];
-    unsigned char red_val[144];
-    unsigned char grn_val[144];
-    unsigned char blu_val[144];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffers                                      |
-    \*-----------------------------------------------------*/
-    memset(data_pkt, 0x00, sizeof( data_pkt ));
-    memset(red_val, 0x00, sizeof( red_val ));
-    memset(grn_val, 0x00, sizeof( grn_val ));
-    memset(blu_val, 0x00, sizeof( blu_val ));
-
-    /*-----------------------------------------------------*\
-    | Scale color values to 9-bit                           |
-    \*-----------------------------------------------------*/
-    for(int color_idx = 0; color_idx < colors.size(); color_idx++)
-    {
-        RGBColor      color = colors[color_idx];
-        unsigned char red   = RGBGetRValue(color);
-        unsigned char grn   = RGBGetGValue(color);
-        unsigned char blu   = RGBGetBValue(color);
-
-        if( red > 7 ) red = 7;
-        if( grn > 7 ) grn = 7;
-        if( blu > 7 ) blu = 7;
-
-        red = 7 - red;
-        grn = 7 - grn;
-        blu = 7 - blu;
-
-        red_val[keys[color_idx]] = red;
-        grn_val[keys[color_idx]] = grn;
-        blu_val[keys[color_idx]] = blu;
-    }
-
-    /*-----------------------------------------------------*\
-    | Pack the color values, 2 values per byte              |
-    \*-----------------------------------------------------*/
-    for(int red_idx = 0; red_idx < 72; red_idx++)
-    {
-        data_pkt[red_idx] = red_val[(red_idx * 2) + 1] << 4 | red_val[red_idx * 2];
-    }
-
-    for(int grn_idx = 0; grn_idx < 72; grn_idx++)
-    {
-        data_pkt[grn_idx + 72] = grn_val[(grn_idx * 2) + 1] << 4 | grn_val[grn_idx * 2];
-    }
-
-    for(int blu_idx = 0; blu_idx < 72; blu_idx++)
-    {
-        data_pkt[blu_idx + 144] = blu_val[(blu_idx * 2) + 1] << 4 | blu_val[blu_idx * 2];
-    }
-
-    /*-----------------------------------------------------*\
-    | Send the packets                                      |
-    \*-----------------------------------------------------*/
-    StreamPacket(1, 60, &data_pkt[0]);
-    StreamPacket(2, 60, &data_pkt[60]);
-    StreamPacket(3, 60, &data_pkt[120]);
-    StreamPacket(4, 36, &data_pkt[180]);
-    
-    SubmitLimitedColors(216);
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void CorsairKeyboardController::LightingControl()
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_LIGHTING_CONTROL;
-    usb_buf[0x02]   = CORSAIR_LIGHTING_CONTROL_SOFTWARE;
-    usb_buf[0x04]   = 0x03;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
-}
-
-void CorsairKeyboardController::ReadFirmwareInfo()
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Read Firmware Info packet                      |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_READ;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
-    get_usb_msg(dev, usb_buf);
-}
-
-void CorsairKeyboardController::StreamPacket
-    (
-    unsigned char   packet_id,
-    unsigned char   data_sz,
-    unsigned char*  data_ptr
-    )
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Stream packet                                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_STREAM;
-    usb_buf[0x01]   = packet_id;
-    usb_buf[0x02]   = data_sz;
-
-    /*-----------------------------------------------------*\
-    | Copy in data bytes                                    |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x04], data_ptr, data_sz);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
-}
-
-void CorsairKeyboardController::SubmitColors()
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Keyboard 24-Bit Colors packet           |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_24;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
-}
-
-void CorsairKeyboardController::SubmitLimitedColors
-    (
-    unsigned char   byte_count
-    )
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Keyboard 9-Bit Colors packet            |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_9;
-    usb_buf[0x04]   = byte_count;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
-}

Controllers/CorsairKeyboardController/CorsairKeyboardController.h

@@ -1,78 +0,0 @@
-/*-----------------------------------------*\
-|  CorsairKeyboardController.h              |
-|                                           |
-|  Definitions and types for Corsair RGB    |
-|  keyboard lighting controller             |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/9/2020    |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    CORSAIR_COMMAND_WRITE       = 0x07,
-    CORSAIR_COMMAND_READ        = 0x0E,
-    CORSAIR_COMMAND_STREAM      = 0x7F
-};
-
-enum
-{
-    CORSAIR_PROPERTY_FIRMWARE_INFO              = 0x01,
-    CORSAIR_PROPERTY_RESET                      = 0x02,
-    CORSAIR_PROPERTY_SPECIAL_FUNCTION           = 0x04,
-    CORSAIR_PROPERTY_LIGHTING_CONTROL           = 0x05,
-    CORSAIR_PROPERTY_HARDWARE_PROFILE           = 0x13,
-    CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR         = 0x22,
-    CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_9    = 0x27,
-    CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_24   = 0x28,
-};
-
-enum
-{
-    CORSAIR_LIGHTING_CONTROL_HARDWARE           = 0x01,
-    CORSAIR_LIGHTING_CONTROL_SOFTWARE           = 0x02
-};
-
-enum
-{
-    CORSAIR_COLOR_CHANNEL_RED       = 0x01,
-    CORSAIR_COLOR_CHANNEL_GREEN     = 0x02,
-    CORSAIR_COLOR_CHANNEL_BLUE      = 0x03
-};
-
-class CorsairKeyboardController
-{
-public:
-    CorsairKeyboardController(hid_device* dev_handle);
-    ~CorsairKeyboardController();
-
-    void SetLEDsDirect(std::vector<RGBColor> colors);
-    void SetLEDs(std::vector<RGBColor> colors);
-
-private:
-    hid_device*             dev;
-
-    void    LightingControl();
-
-    void    ReadFirmwareInfo();
-    
-    void    StreamPacket
-                (
-                unsigned char   packet_id,
-                unsigned char   data_sz,
-                unsigned char*  data_ptr
-                );
-
-    void    SubmitColors();
-
-    void    SubmitLimitedColors
-                (
-                unsigned char   byte_count
-                );
-};

Controllers/CorsairKeyboardController/CorsairKeyboardControllerDetect.cpp

@@ -1,52 +0,0 @@
-#include "CorsairKeyboardController.h"
-#include "RGBController.h"
-#include "RGBController_CorsairKeyboard.h"
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#define CORSAIR_RGB_KEYBOARD_VID        0x1B1C
-#define CORSAIR_RGB_KEYBOARD_K70_PID    0x1B13
-#define CORSAIR_RGB_KEYBOARD_K95_PID    0x1B11
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairKeyboardControllers                                                       *
-*                                                                                          *
-*       Tests the USB address to see if a Corsair RGB Keyboard controller exists there.    *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairKeyboardControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    hid_device_info* info;
-    hid_device* dev = NULL;
-
-    hid_init();
-
-    info = hid_enumerate(CORSAIR_RGB_KEYBOARD_VID, CORSAIR_RGB_KEYBOARD_K70_PID);
-
-    //Look for Corsair RGB Keyboard, interface 1
-    while(info)
-    {
-        if((info->vendor_id == CORSAIR_RGB_KEYBOARD_VID)
-         &&(info->product_id == CORSAIR_RGB_KEYBOARD_K70_PID)
-         &&(info->interface_number == 1))
-        {
-            dev = hid_open_path(info->path);
-            break;
-        }
-        else
-        {
-            info = info->next;
-        }
-    }
-
-    if( dev )
-    {
-        CorsairKeyboardController* controller = new CorsairKeyboardController(dev);
-
-        RGBController_CorsairKeyboard* rgb_controller = new RGBController_CorsairKeyboard(controller);
-
-        rgb_controllers.push_back(rgb_controller);
-    }
-}

Controllers/CorsairNodeProController/CorsairNodeProController.cpp

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

Controllers/CorsairNodeProController/CorsairNodeProController.h

@@ -87,6 +87,7 @@ public:
     CorsairNodeProController(libusb_device_handle* dev_handle);
     ~CorsairNodeProController();
     
+    char*           GetLEDString();
     unsigned int    GetStripsOnChannel(unsigned int channel);
 
     void            SetChannelEffect(unsigned char channel,
@@ -99,10 +100,7 @@ public:
                                      unsigned char blu1,
                                      unsigned char red2,
                                      unsigned char grn2,
-                                     unsigned char blu2,
-                                     unsigned char red3,
-                                     unsigned char grn3,
-                                     unsigned char blu3
+                                     unsigned char blu2
                                     );
 
     void            SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors);

Controllers/CorsairProController/CorsairProControllerDetect.cpp

@@ -121,22 +121,6 @@ void DetectCorsairProControllers(std::vector<i2c_smbus_interface*> &busses, std:
             new_controller = new RGBController_CorsairPro(new_corsair_pro);
             rgb_controllers.push_back(new_controller);
         }
-
-        // Check for Corsair controller at 0x5E
-        if (TestForCorsairProController(busses[bus], 0x5E))
-        {
-            new_corsair_pro = new CorsairProController(busses[bus], 0x5E);
-            new_controller = new RGBController_CorsairPro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x5F
-        if (TestForCorsairProController(busses[bus], 0x5F))
-        {
-            new_corsair_pro = new CorsairProController(busses[bus], 0x5F);
-            new_controller = new RGBController_CorsairPro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
     }
 
 }   /* DetectCorsairProControllers() */

Controllers/CrucialController/CrucialController.cpp

@@ -1,133 +0,0 @@
-/*-----------------------------------------*\
-|  CrucialController.cpp                    |
-|                                           |
-|  Driver for Crucial Ballistix RGB lighting|
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/19/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "CrucialController.h"
-#include <cstring>
-
-CrucialController::CrucialController(i2c_smbus_interface* bus, crucial_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-}
-
-CrucialController::~CrucialController()
-{
-
-}
-
-std::string CrucialController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string CrucialController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return(return_string);
-}
-
-unsigned int CrucialController::GetLEDCount()
-{
-    return(led_count);
-}
-
-void CrucialController::SetMode(unsigned char mode)
-{
-    SendEffectMode(mode, 0x10);
-}
-
-void CrucialController::SetAllColorsDirect(RGBColor* colors)
-{
-    SendDirectColors(colors);
-}
-
-void CrucialController::SendEffectColors(unsigned char red, unsigned char green, unsigned char blue)
-{
-    CrucialRegisterWrite(0x82E9, 0xFF);
-    CrucialRegisterWrite(0x82EA, 0x00);
-    CrucialRegisterWrite(0x82EB, 0x00);
-    CrucialRegisterWrite(0x82EC, 0x00);
-    CrucialRegisterWrite(0x82ED, red);
-    CrucialRegisterWrite(0x82EE, green);
-    CrucialRegisterWrite(0x82EF, blue);
-    CrucialRegisterWrite(0x82F0, 0x01);
-}
-
-void CrucialController::SendBrightness(unsigned char brightness)
-{
-    CrucialRegisterWrite(0x82EE, 0xFF);
-    CrucialRegisterWrite(0x82EF, brightness);
-    CrucialRegisterWrite(0x82F0, 0x83);
-}
-
-void CrucialController::SendEffectMode(unsigned char mode, unsigned char speed)
-{
-    CrucialRegisterWrite(0x820F, mode);
-    CrucialRegisterWrite(0x82EE, 0x00);
-    CrucialRegisterWrite(0x82EF, speed);
-    CrucialRegisterWrite(0x82F0, 0x84);
-}
-
-void CrucialController::SendDirectColors(RGBColor* color_buf)
-{
-    //Red Channels
-    CrucialRegisterWrite(0x8300, RGBGetRValue(color_buf[0]));
-    CrucialRegisterWrite(0x8301, RGBGetRValue(color_buf[1]));
-    CrucialRegisterWrite(0x8302, RGBGetRValue(color_buf[2]));
-    CrucialRegisterWrite(0x8303, RGBGetRValue(color_buf[3]));
-    CrucialRegisterWrite(0x8304, RGBGetRValue(color_buf[4]));
-    CrucialRegisterWrite(0x8305, RGBGetRValue(color_buf[5]));
-    CrucialRegisterWrite(0x8306, RGBGetRValue(color_buf[6]));
-    CrucialRegisterWrite(0x8307, RGBGetRValue(color_buf[7]));
-
-    //Green Channels
-    CrucialRegisterWrite(0x8340, RGBGetGValue(color_buf[0]));
-    CrucialRegisterWrite(0x8341, RGBGetGValue(color_buf[1]));
-    CrucialRegisterWrite(0x8342, RGBGetGValue(color_buf[2]));
-    CrucialRegisterWrite(0x8343, RGBGetGValue(color_buf[3]));
-    CrucialRegisterWrite(0x8344, RGBGetGValue(color_buf[4]));
-    CrucialRegisterWrite(0x8345, RGBGetGValue(color_buf[5]));
-    CrucialRegisterWrite(0x8346, RGBGetGValue(color_buf[6]));
-    CrucialRegisterWrite(0x8347, RGBGetGValue(color_buf[7]));
-
-    //Blue Channels
-    CrucialRegisterWrite(0x8380, RGBGetBValue(color_buf[0]));
-    CrucialRegisterWrite(0x8381, RGBGetBValue(color_buf[1]));
-    CrucialRegisterWrite(0x8382, RGBGetBValue(color_buf[2]));
-    CrucialRegisterWrite(0x8383, RGBGetBValue(color_buf[3]));
-    CrucialRegisterWrite(0x8384, RGBGetBValue(color_buf[4]));
-    CrucialRegisterWrite(0x8385, RGBGetBValue(color_buf[5]));
-    CrucialRegisterWrite(0x8386, RGBGetBValue(color_buf[6]));
-    CrucialRegisterWrite(0x8387, RGBGetBValue(color_buf[7]));
-}
-
-unsigned char CrucialController::CrucialRegisterRead(crucial_register reg)
-{
-    //Write Crucial register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Read Crucial value
-    return(bus->i2c_smbus_read_byte_data(dev, 0x81));
-
-}
-
-void CrucialController::CrucialRegisterWrite(crucial_register reg, unsigned char val)
-{
-    //Write Crucial register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Write Crucial value
-    bus->i2c_smbus_write_byte_data(dev, 0x01, val);
-
-}

Controllers/CrucialController/CrucialController.h

@@ -1,62 +0,0 @@
-/*-----------------------------------------*\
-|  CrucialController.h                      |
-|                                           |
-|  Definitions and types for Crucial        |
-|  Ballistix RGB lighting controller        |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/19/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <string>
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char	crucial_dev_id;
-typedef unsigned short	crucial_register;
-
-enum
-{
-    CRUCIAL_MODE_SHIFT              = 0x1F,     /* Shift effect mode                */
-    CRUCIAL_MODE_GRADIENT_SHIFT     = 0x2F,     /* Gradient shift mode              */
-    CRUCIAL_MODE_FILL               = 0x3F,     /* Fill effect mode                 */
-    CRUCIAL_MODE_STACK              = 0x4F,     /* Stack effect mode                */
-    CRUCIAL_MODE_DOUBLE_STACK       = 0x5F,     /* Double stack effect mode         */
-    CRUCIAL_MODE_BREATHING          = 0x6F,     /* Breathing effect mode            */
-    CRUCIAL_MODE_MOTION_POINT       = 0x7F,     /* Motion point effect mode         */
-    CRUCIAL_MODE_INSIDE_OUT         = 0x8F,     /* Inside out effect mode           */
-    CRUCIAL_MODE_COLOR_STEP         = 0x9F,     /* Color step effect mode           */
-    CRUCIAL_MODE_WATER_WAVE         = 0xAF,     /* Water wave effect mode           */
-    CRUCIAL_MODE_FLASHING           = 0xBF,     /* Flashing effect mode             */
-    CRUCIAL_MODE_STATIC             = 0xCF,     /* Static effect mode               */
-};
-
-class CrucialController
-{
-public:
-    CrucialController(i2c_smbus_interface* bus, crucial_dev_id dev);
-    ~CrucialController();
-
-    std::string   GetDeviceName();
-    std::string   GetDeviceLocation();
-    unsigned int  GetLEDCount();
-    void          SetAllColorsDirect(RGBColor* colors);
-    void          SetMode(unsigned char mode);
-
-    unsigned char CrucialRegisterRead(crucial_register reg);
-    void          CrucialRegisterWrite(crucial_register reg, unsigned char val);
-
-private:
-    char                    device_name[16];
-    unsigned char           config_table[64];
-    unsigned int            led_count;
-    unsigned char           channel_cfg;
-    i2c_smbus_interface *   bus;
-    crucial_dev_id          dev;
-
-    void            SendDirectColors(RGBColor* color_buf);
-    void            SendEffectColors(unsigned char red, unsigned char green, unsigned char blue);
-    void            SendBrightness(unsigned char brightness);
-    void            SendEffectMode(unsigned char mode, unsigned char speed);
-};

Controllers/CrucialController/CrucialControllerDetect.cpp

@@ -1,88 +0,0 @@
-#include "CrucialController.h"
-#include "RGBController.h"
-#include "RGBController_Crucial.h"
-#include "i2c_smbus.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-/*----------------------------------------------------------------------*\
-| This list contains the available SMBus addresses for Crucial RAM       |
-\*----------------------------------------------------------------------*/
-#define CRUCIAL_ADDRESS_COUNT  4
-
-static const unsigned char crucial_addresses[] =
-{
-    0x20,
-    0x21,
-    0x22,
-    0x23
-};
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForCrucialController                                                               *
-*                                                                                          *
-*       Tests the given address to see if an Crucial controller exists there.  First does a*
-*       quick write to test for a response, and if so does a simple read at 0xA0 to test   *
-*       for incrementing values 0...F which was observed at this location during data dump *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForCrucialController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-
-    if (res >= 0)
-    {
-        pass = true;
-
-        for (int i = 0xA0; i < 0xB0; i++)
-        {
-            res = bus->i2c_smbus_read_byte_data(address, i);
-
-            if (res != (i - 0xA0))
-            {
-                pass = false;
-            }
-        }
-    }
-
-    return(pass);
-
-}   /* TestForCrucialController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCrucialControllers                                                               *
-*                                                                                          *
-*       Detect Crucial controllers on the enumerated I2C busses.                           *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
-{
-    CrucialController* new_crucial;
-    RGBController_Crucial* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        // Add Crucial controllers
-        for (unsigned int address_list_idx = 0; address_list_idx < CRUCIAL_ADDRESS_COUNT; address_list_idx++)
-        {
-            if (TestForCrucialController(busses[bus], crucial_addresses[address_list_idx]))
-            {
-                new_crucial = new CrucialController(busses[bus], crucial_addresses[address_list_idx]);
-                new_controller = new RGBController_Crucial(new_crucial);
-                rgb_controllers.push_back(new_controller);
-            }
-        }
-    }
-
-}   /* DetectCrucialControllers() */

Controllers/Hue2Controller/Hue2Controller.cpp

@@ -72,11 +72,7 @@ unsigned int Hue2Controller::GetStripsOnChannel(unsigned int /*channel*/)
                 num_leds_on_channel += 10;
                 break;
             
-            case 0x0B: //Aer 2 fan (120mm)
-                num_leds_on_channel += 8;
-                break;
-
-            case 0x0C: //Aer 2 fan (140mm)
+            case 0x0B: //Aer 2 fan
                 num_leds_on_channel += 8;
                 break;
 

Controllers/Hue2Controller/Hue2Controller.h

@@ -55,7 +55,8 @@ class Hue2Controller
 public:
     Hue2Controller(libusb_device_handle* dev_handle);
     ~Hue2Controller();
-
+    
+    char*           GetLEDString();
     unsigned int    GetStripsOnChannel(unsigned int channel);
     void            SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors);
     void            SetMode(unsigned char mode, unsigned char speed, bool direction);

Controllers/Hue2Controller/Hue2ControllerDetect.cpp

@@ -6,7 +6,6 @@
 
 #define NZXT_HUE_2_VID 0x1E71
 #define NZXT_HUE_2_PID 0x2001
-#define NZXT_SMART_DEVICE_V2_PID 0x2006
 
 /******************************************************************************************\
 *                                                                                          *
@@ -22,29 +21,14 @@ void DetectHue2Controllers(std::vector<RGBController*> &rgb_controllers)
     libusb_init(&ctx);
 
     //Look for NZXT Hue 2
-    libusb_device_handle * hue_2_dev = libusb_open_device_with_vid_pid(ctx, NZXT_HUE_2_VID, NZXT_HUE_2_PID);
+    libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, NZXT_HUE_2_VID, NZXT_HUE_2_PID);
 
-    if( hue_2_dev )
+    if( dev )
     {
-        libusb_detach_kernel_driver(hue_2_dev, 0);
-        libusb_claim_interface(hue_2_dev, 0);
+        libusb_detach_kernel_driver(dev, 0);
+        libusb_claim_interface(dev, 0);
 
-        Hue2Controller* controller = new Hue2Controller(hue_2_dev);
-
-        RGBController_Hue2* rgb_controller = new RGBController_Hue2(controller);
-
-        rgb_controllers.push_back(rgb_controller);
-    }
-
-    //Look for NZXT Smart Device V2
-    libusb_device_handle * smart_dev_2_dev = libusb_open_device_with_vid_pid(ctx, NZXT_HUE_2_VID, NZXT_SMART_DEVICE_V2_PID);
-
-    if( smart_dev_2_dev )
-    {
-        libusb_detach_kernel_driver(smart_dev_2_dev, 0);
-        libusb_claim_interface(smart_dev_2_dev, 0);
-
-        Hue2Controller* controller = new Hue2Controller(smart_dev_2_dev);
+        Hue2Controller* controller = new Hue2Controller(dev);
 
         RGBController_Hue2* rgb_controller = new RGBController_Hue2(controller);
 

Controllers/HuePlusController/HuePlusController.cpp

@@ -9,7 +9,7 @@
 #include <fstream>
 #include <iostream>
 #include <string>
-#include <cstring>
+
 
 #ifdef WIN32
 #include <Windows.h>
@@ -92,75 +92,43 @@ 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[125];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(serial_buf, 0x00, sizeof(serial_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up main packet                                    |
-    \*-----------------------------------------------------*/
-    serial_buf[0x00]    = 0x4B;
+    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
+    };
 
     /*-----------------------------------------------------*\
     | Set channel in serial packet                          |
@@ -199,4 +167,4 @@ void HuePlusController::SetChannelLEDs(unsigned char channel, std::vector<RGBCol
     serialport->serial_flush_tx();
 
     Sleep(10);
-}
+}

Controllers/HuePlusController/HuePlusController.h

@@ -75,7 +75,6 @@ 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

@@ -1,483 +0,0 @@
-/*-----------------------------------------*\
-|  HyperXKeyboardController.cpp             |
-|                                           |
-|  Driver for HyperX RGB Keyboard lighting  |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/30/2020   |
-\*-----------------------------------------*/
-
-#include "HyperXKeyboardController.h"
-
-#include <cstring>
-
-#ifdef WIN32
-#include <Windows.h>
-#else
-#include <unistd.h>
-
-static void Sleep(unsigned int milliseconds)
-{
-    usleep(1000 * milliseconds);
-}
-#endif
-
-
-static unsigned int keys[] = {0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14,
-                              0x15, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1D, 0x1E, 0x20, 0x21, 0x22, 0x23, 0x24,
-                              0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32,
-                              0x33, 0x34, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3E, 0x3F, 0x41, 0x44, 0x45,
-                              0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x51, 0x54, 0x55, 0x58, 0x59,
-                              0x5A, 0x5B, 0x5C, 0x5E, 0x5F, 0x61, 0x64, 0x65, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
-                              0x6E, 0x6F, 0x74, 0x75, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x81,
-                              0x84, 0x85, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x91, 0x94, 0x95 };
-
-static unsigned int extended_red[] = {0x08, 0x48, 0x88, 0x09, 0x89, 0x0A, 0x8A, 0x0B, 0x8B, 0x0C, 0x8C, 0x0D, 0x8D, 0x0E, 0x8F, 0x8E, 0x0F, 0x4F, 0x92, 0x13, 0x93, 0x12 };
-static unsigned int extended_grn[] = {0x29, 0x28, 0x78, 0x19, 0x79, 0x1A, 0x7A, 0x1B, 0x7B, 0x1C, 0x7C, 0x1D, 0x7D, 0x1E, 0x6E, 0x7E, 0x1F, 0x6F, 0x82, 0x23, 0x83, 0x22 };
-static unsigned int extended_blu[] = {0x39, 0x38, 0x68, 0x3A, 0x69, 0x2A, 0x6A, 0x2B, 0x6B, 0x2C, 0x6C, 0x2D, 0x6D, 0x2E, 0x5E, 0x5D, 0x2F, 0x5F, 0x72, 0x33, 0x73, 0x32 };
-
-HyperXKeyboardController::HyperXKeyboardController(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-HyperXKeyboardController::~HyperXKeyboardController()
-{
-
-}
-
-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,
-        active_mode,
-        active_direction,
-        HYPERX_REACTIVE_MODE_NONE,
-        active_speed,
-        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)
-{
-    unsigned char red_color_data[104];
-    unsigned char grn_color_data[104];
-    unsigned char blu_color_data[104];
-    unsigned char ext_color_data[150];
-
-    for(std::size_t i = 0; i < 104; i++)
-    {
-        red_color_data[i] = RGBGetRValue(colors[i]);
-        grn_color_data[i] = RGBGetGValue(colors[i]);
-        blu_color_data[i] = RGBGetBValue(colors[i]);
-    }
-
-    for(std::size_t i = 0; i < 22; i++)
-    {
-        ext_color_data[extended_red[i]] = RGBGetRValue(colors[i + 104]);
-        ext_color_data[extended_grn[i]] = RGBGetGValue(colors[i + 104]);
-        ext_color_data[extended_blu[i]] = RGBGetBValue(colors[i + 104]);
-    }
-
-    SendDirect
-        (
-        HYPERX_COLOR_CHANNEL_RED,
-        red_color_data
-        );
-
-    Sleep(2);
-
-    SendDirect
-        (
-        HYPERX_COLOR_CHANNEL_GREEN,
-        grn_color_data
-        );
-
-    Sleep(2);
-
-    SendDirect
-        (
-        HYPERX_COLOR_CHANNEL_BLUE,
-        blu_color_data
-        );
-
-    Sleep(2);
-
-    SendDirectExtended
-        (
-        ext_color_data
-        );
-}
-
-void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
-{
-    unsigned char red_color_data[104];
-    unsigned char grn_color_data[104];
-    unsigned char blu_color_data[104];
-    unsigned char ext_color_data[150];
-
-    for(std::size_t i = 0; i < 104; i++)
-    {
-        red_color_data[i] = RGBGetRValue(colors[i]);
-        grn_color_data[i] = RGBGetGValue(colors[i]);
-        blu_color_data[i] = RGBGetBValue(colors[i]);
-    }
-
-    for(std::size_t i = 0; i < 22; i++)
-    {
-        ext_color_data[extended_red[i]] = RGBGetRValue(colors[i + 104]);
-        ext_color_data[extended_grn[i]] = RGBGetGValue(colors[i + 104]);
-        ext_color_data[extended_blu[i]] = RGBGetBValue(colors[i + 104]);
-    }
-
-    SendColor
-        (
-        0x01,
-        HYPERX_COLOR_CHANNEL_RED,
-        red_color_data
-        );
-
-    SendColor
-        (
-        0x01,
-        HYPERX_COLOR_CHANNEL_GREEN,
-        grn_color_data
-        );
-
-    SendColor
-        (
-        0x01,
-        HYPERX_COLOR_CHANNEL_BLUE,
-        blu_color_data
-        );
-
-    SendExtendedColor
-        (
-        0x01,
-        ext_color_data
-        );
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void HyperXKeyboardController::SelectProfile
-    (
-    unsigned char   profile
-    )
-{
-    unsigned char buf[264];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Select Profile packet                          |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x07;
-    buf[0x01]   = 0x01;
-    buf[0x02]   = profile;
-
-    buf[0x06]   = 0x03;
-    buf[0x07]   = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 264);
-}
-
-void HyperXKeyboardController::SendEffect
-    (
-    unsigned char   profile,
-    unsigned char   mode,
-    unsigned char   direction,
-    unsigned char   reactive_mode,
-    unsigned char   speed,
-    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];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Effect packet                                  |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x07;
-    buf[0x01]   = HYPERX_PACKET_ID_SET_EFFECT;
-    buf[0x02]   = profile;
-
-    /*-----------------------------------------------------*\
-    | Set mode                                              |
-    \*-----------------------------------------------------*/
-    buf[0x09]   = 0x01;
-    buf[0x0A]   = mode;
-
-    /*-----------------------------------------------------*\
-    | Set direction                                         |
-    \*-----------------------------------------------------*/
-    buf[0x0D]   = direction;
-    buf[0x0E]   = direction;
-
-    /*-----------------------------------------------------*\
-    | Set reactive mode                                     |
-    \*-----------------------------------------------------*/
-    buf[0x1B]   = reactive_mode;
-    buf[0x1C]   = reactive_mode;
-    buf[0x1D]   = reactive_mode;
-    buf[0x1E]   = reactive_mode;
-    buf[0x1F]   = reactive_mode;
-    buf[0x20]   = reactive_mode;
-    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;
-    buf[0x6E]   = 0x05;
-    buf[0x6F]   = 0x06;
-    buf[0x70]   = 0x05;
-
-    /*-----------------------------------------------------*\
-    | Set speed                                             |
-    \*-----------------------------------------------------*/
-    buf[0x71]   = speed;
-
-    buf[0x72]   = 0x09;
-
-    /*-----------------------------------------------------*\
-    | Set color mode                                        |
-    \*-----------------------------------------------------*/
-    buf[0x73]   = color_mode;
-    buf[0x74]   = color_mode;
-    buf[0x75]   = color_mode;
-    buf[0x76]   = color_mode;
-    buf[0x77]   = color_mode;
-    buf[0x78]   = color_mode;
-    buf[0x79]   = color_mode;
-    buf[0x7A]   = color_mode;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 264);
-}
-
-void HyperXKeyboardController::SendColor
-    (
-    unsigned char   profile,
-    unsigned char   color_channel,
-    unsigned char*  color_data
-    )
-{
-    unsigned char buf[264];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Color packet                                   |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x07;
-    buf[0x01]   = HYPERX_PACKET_ID_SET_COLOR;
-    buf[0x02]   = profile;
-    buf[0x03]   = color_channel;
-
-    /*-----------------------------------------------------*\
-    | Fill in color data                                    |
-    \*-----------------------------------------------------*/
-    for(int i = 0; i < 104; i++)
-    {
-        buf[keys[i]] = color_data[i];
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 264);
-}
-
-void HyperXKeyboardController::SendExtendedColor
-    (
-    unsigned char   profile,
-    unsigned char*  color_data
-    )
-{
-    unsigned char buf[264];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Color packet                                   |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x07;
-    buf[0x01]   = HYPERX_PACKET_ID_SET_COLOR;
-    buf[0x02]   = profile;
-    buf[0x03]   = HYPERX_COLOR_CHANNEL_EXTENDED;
-
-    /*-----------------------------------------------------*\
-    | Fill in color data                                    |
-    \*-----------------------------------------------------*/
-    for(int i = 0x08; i <= 0x93; i++)
-    {
-        buf[i] = color_data[i];
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 264);
-}
-
-void HyperXKeyboardController::SendDirect
-    (
-    unsigned char   color_channel,
-    unsigned char*  color_data
-    )
-{
-    unsigned char buf[264];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Direct packet                                  |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x07;
-    buf[0x01]   = HYPERX_PACKET_ID_DIRECT;
-    buf[0x02]   = color_channel;
-
-    /*-----------------------------------------------------*\
-    | Fill in color data                                    |
-    \*-----------------------------------------------------*/
-    for(int i = 0; i < 104; i++)
-    {
-        buf[keys[i]] = color_data[i];
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 264);
-}
-
-void HyperXKeyboardController::SendDirectExtended
-    (
-    unsigned char*  color_data
-    )
-{
-    unsigned char buf[264];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Direct packet                                  |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x07;
-    buf[0x01]   = HYPERX_PACKET_ID_DIRECT;
-    buf[0x02]   = HYPERX_COLOR_CHANNEL_EXTENDED;
-
-    /*-----------------------------------------------------*\
-    | Fill in color data                                    |
-    \*-----------------------------------------------------*/
-    for(int i = 0x08; i <= 0x93; i++)
-    {
-        buf[i] = color_data[i];
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 264);
-}

Controllers/HyperXKeyboardController/HyperXKeyboardController.h

@@ -1,135 +0,0 @@
-/*-----------------------------------------*\
-|  HyperXKeyboardController.h               |
-|                                           |
-|  Definitions and types for HyperX RGB     |
-|  Keyboard lighting controller             |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/30/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    HYPERX_PACKET_ID_SET_EFFECT                 = 0x02,     /* Set profile effect packet            */
-    HYPERX_PACKET_ID_SET_COLOR                  = 0x06,     /* Set profile color packet             */
-    HYPERX_PACKET_ID_DIRECT                     = 0x16,     /* Direct control packet                */
-};
-
-
-enum
-{
-    HYPERX_DIRECTION_RIGHT  = 0x00,
-    HYPERX_DIRECTION_LEFT   = 0x01,
-    HYPERX_DIRECTION_UP     = 0x02,
-    HYPERX_DIRECTION_DOWN   = 0x03,
-    HYPERX_DIRECTION_IN     = 0x04,
-    HYPERX_DIRECTION_OUT    = 0x05
-};
-
-enum
-{
-    HYPERX_MODE_WAVE                    = 0x00,
-    HYPERX_MODE_STATIC                  = 0x01,
-    HYPERX_MODE_BREATHING               = 0x02,
-};
-
-enum
-{
-    HYPERX_REACTIVE_MODE_TRIGGER        = 0x03,
-    HYPERX_REACTIVE_MODE_EXPLOSION      = 0x04,
-    HYPERX_REACTIVE_MODE_HYPERX_FLAME   = 0x05,
-    HYPERX_REACTIVE_MODE_NONE           = 0xFF
-};
-
-enum
-{
-    HYPERX_COLOR_MODE_SINGLE            = 0x00,
-    HYPERX_COLOR_MODE_DUAL              = 0x01,
-    HYPERX_COLOR_MODE_SPECTRUM          = 0x02
-};
-
-enum
-{
-    HYPERX_COLOR_CHANNEL_RED                = 0x01,
-    HYPERX_COLOR_CHANNEL_GREEN              = 0x02,
-    HYPERX_COLOR_CHANNEL_BLUE               = 0x03,
-    HYPERX_COLOR_CHANNEL_EXTENDED           = 0x04
-};
-
-class HyperXKeyboardController
-{
-public:
-    HyperXKeyboardController(hid_device* dev_handle);
-    ~HyperXKeyboardController();
-
-    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);
-
-private:
-    hid_device*             dev;
-    unsigned char           active_mode;
-    unsigned char           active_direction;
-    unsigned char           active_speed;
-
-    void    SelectProfile
-                (
-                unsigned char   profile
-                );
-
-    void    SendEffect
-                (
-                unsigned char   profile,
-                unsigned char   mode,
-                unsigned char   direction,
-                unsigned char   reactive_mode,
-                unsigned char   speed,
-                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
-                (
-                unsigned char   profile,
-                unsigned char   color_channel,
-                unsigned char*  color_data
-                );
-
-    void    SendExtendedColor
-                (
-                unsigned char   profile,
-                unsigned char*  color_data
-                );
-
-    void    SendDirect
-                (
-                unsigned char   color_channel,
-                unsigned char*  color_data
-                );
-
-    void    SendDirectExtended
-                (
-                unsigned char*  color_data
-                );
-};

Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp

@@ -1,51 +0,0 @@
-#include "HyperXKeyboardController.h"
-#include "RGBController.h"
-#include "RGBController_HyperXKeyboard.h"
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#define HYPERX_KEYBOARD_VID         0x0951
-#define HYPERX_ALLOY_ELITE_PID      0x16BE
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectHyperXKeyboardControllers                                                        *
-*                                                                                          *
-*       Tests the USB address to see if a HyperX Keyboard controller exists there.         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectHyperXKeyboardControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    hid_device_info* info;
-    hid_device* dev = NULL;
-
-    hid_init();
-
-    info = hid_enumerate(HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID);
-
-    //Look for HyperX Keyboard, Interface 2
-    while(info)
-    {
-        if((info->vendor_id == HYPERX_KEYBOARD_VID)
-         &&(info->product_id == HYPERX_ALLOY_ELITE_PID)
-         &&(info->interface_number == 2))
-        {
-            dev = hid_open_path(info->path);
-            break;
-        }
-        else
-        {
-            info = info->next;
-        }
-    }
-
-    if( dev )
-    {
-        HyperXKeyboardController* controller = new HyperXKeyboardController(dev);
-
-        RGBController_HyperXKeyboard* rgb_controller = new RGBController_HyperXKeyboard(controller);
-
-        rgb_controllers.push_back(rgb_controller);
-    }
-}

Controllers/MSIRGBController/MSIRGBController.cpp

@@ -1,99 +0,0 @@
-/*-----------------------------------------*\
-|  MSIRGBController.cpp                     |
-|                                           |
-|  Driver for MSI-RGB lighting controller   |
-|                                           |
-|  Logic adapted from:                      |
-|     https://github.com/nagisa/msi-rgb     |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/11/2020   |
-\*-----------------------------------------*/
-
-#include "MSIRGBController.h"
-#include "super_io.h"
-
-MSIRGBController::MSIRGBController(int sioaddr)
-{
-    msi_sioaddr = sioaddr;
-
-    /*-----------------------------------------------------*\
-    | This setup step isn't well documented                 |
-    | Without this, pulsing does not work                   |
-    \*-----------------------------------------------------*/
-    superio_outb(msi_sioaddr, SIO_REG_LOGDEV, 0x09);
-
-    int val_at_2c = superio_inb(msi_sioaddr, 0x2C);
-
-    val_at_2c &= 0b11110111;
-    val_at_2c |= 0b00010000;
-
-    superio_outb(msi_sioaddr, 0x2C, val_at_2c);
-    
-
-    /*-----------------------------------------------------*\
-    | Set logical device register to RGB controller         |
-    \*-----------------------------------------------------*/
-    superio_outb(msi_sioaddr, SIO_REG_LOGDEV, MSI_SIO_LOGDEV_RGB);
-
-    /*-----------------------------------------------------*\
-    | Test if RGB is enabled.  If it is not, enable it.     |
-    \*-----------------------------------------------------*/
-    int enable = superio_inb(msi_sioaddr, MSI_SIO_RGB_REG_ENABLE);
-
-    if((enable & MSI_SIO_RGB_ENABLE_MASK) != MSI_SIO_RGB_ENABLE_MASK)
-    {
-        superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_ENABLE, MSI_SIO_RGB_ENABLE_MASK & (enable & !MSI_SIO_RGB_ENABLE_MASK));
-    }
-
-    /*-----------------------------------------------------*\
-    | Lighting enabled, no pulsing or blinking              |
-    \*-----------------------------------------------------*/
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_CFG_1, 0x00);
-
-    /*-----------------------------------------------------*\
-    | Lighting enabled, RGB non-inverted, header on         |
-    \*-----------------------------------------------------*/
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_CFG_3, 0xE2);
-}
-
-MSIRGBController::~MSIRGBController()
-{
-
-}
-
-void MSIRGBController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
-{
-    /*-----------------------------------------------------*\
-    | The MSI RGB controller uses 4 bits per color rather   |
-    | than 8.  Shift the values by 4 so that the 4 most     |
-    | significant bits of each color are the new color value|
-    \*-----------------------------------------------------*/
-    red     = red >> 4;
-    green   = green >> 4;
-    blue    = blue >> 4;
-
-    /*-----------------------------------------------------*\
-    | Set logical device register to RGB controller         |
-    \*-----------------------------------------------------*/
-    superio_outb(msi_sioaddr, SIO_REG_LOGDEV, MSI_SIO_LOGDEV_RGB);
-
-    /*-----------------------------------------------------*\
-    | Write the colors to the color sequence registers      |
-    | Only static mode is supported right now - all colors  |
-    | are the same.                                         |
-    \*-----------------------------------------------------*/
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_RED_1_0, (red | (red << 4)));
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_RED_3_2, (red | (red << 4)));
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_RED_5_4, (red | (red << 4)));
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_RED_7_6, (red | (red << 4)));
-
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_GREEN_1_0, (green | (green << 4)));
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_GREEN_3_2, (green | (green << 4)));
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_GREEN_5_4, (green | (green << 4)));
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_GREEN_7_6, (green | (green << 4)));
-
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_BLUE_1_0, (blue | (blue << 4)));
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_BLUE_3_2, (blue | (blue << 4)));
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_BLUE_5_4, (blue | (blue << 4)));
-    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_BLUE_7_6, (blue | (blue << 4)));
-}

Controllers/MSIRGBController/MSIRGBController.h

@@ -1,56 +0,0 @@
-/*-----------------------------------------*\
-|  MSIRGBController.h                       |
-|                                           |
-|  Definitions and types for MSI-RGB        |
-|  lighting controller                      |
-|                                           |
-|  Logic adapted from:                      |
-|     https://github.com/nagisa/msi-rgb     |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/11/2020   |
-\*-----------------------------------------*/
-
-#include <string>
-
-#pragma once
-
-#define MSI_SIO_LOGDEV_RGB      0x12
-
-enum
-{
-    MSI_SIO_RGB_REG_ENABLE      = 0xE0,
-    MSI_SIO_RGB_REG_CFG_1       = 0xE4,
-    MSI_SIO_RGB_REG_RED_1_0     = 0xF0,
-    MSI_SIO_RGB_REG_RED_3_2     = 0xF1,
-    MSI_SIO_RGB_REG_RED_5_4     = 0xF2,
-    MSI_SIO_RGB_REG_RED_7_6     = 0xF3,
-    MSI_SIO_RGB_REG_GREEN_1_0   = 0xF4,
-    MSI_SIO_RGB_REG_GREEN_3_2   = 0xF5,
-    MSI_SIO_RGB_REG_GREEN_5_4   = 0xF6,
-    MSI_SIO_RGB_REG_GREEN_7_6   = 0xF7,
-    MSI_SIO_RGB_REG_BLUE_1_0    = 0xF8,
-    MSI_SIO_RGB_REG_BLUE_3_2    = 0xF9,
-    MSI_SIO_RGB_REG_BLUE_5_4    = 0xFA,
-    MSI_SIO_RGB_REG_BLUE_7_6    = 0xFB,
-    MSI_SIO_RGB_REG_CFG_2       = 0xFE,
-    MSI_SIO_RGB_REG_CFG_3       = 0xFF,
-};
-
-#define MSI_SIO_RGB_ENABLE_MASK 0xE0
-
-class MSIRGBController
-{
-public:
-    MSIRGBController(int sioaddr);
-    ~MSIRGBController();
-
-    std::string     GetDeviceName();
-    std::string     GetDeviceLocation();
-
-    unsigned int    GetMode();
-    void            SetMode(unsigned char new_mode, unsigned char new_speed);
-
-    void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
-private:
-    int     msi_sioaddr;
-};

Controllers/MSIRGBController/MSIRGBControllerDetect.cpp

@@ -1,40 +0,0 @@
-#include "MSIRGBController.h"
-#include "RGBController.h"
-#include "RGBController_MSIRGB.h"
-#include "super_io.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectMSIRGBControllers                                                                *
-*                                                                                          *
-*       Detect MSI-RGB compatible Super-IO chips.                                          *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectMSIRGBControllers(std::vector<RGBController*> &rgb_controllers)
-{
-    int sio_addrs[2] = {0x2E, 0x4E};
-
-    for(int sioaddr_idx = 0; sioaddr_idx < 2; sioaddr_idx++)
-    {
-        int sioaddr = sio_addrs[sioaddr_idx];
-
-        superio_enter(sioaddr);
-
-        int val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8) | superio_inb(sioaddr, SIO_REG_DEVID + 1);
-
-        switch (val & SIO_ID_MASK)
-        {
-        case SIO_NCT6795_ID:
-        case SIO_NCT6797_ID:
-            MSIRGBController* new_msi = new MSIRGBController(sioaddr);
-            RGBController_MSIRGB* new_rgb = new RGBController_MSIRGB(new_msi);
-
-            rgb_controllers.push_back(new_rgb);
-            break;
-        }
-    }
-}   /* DetectMSIRGBControllers() */

Controllers/PolychromeController/PolychromeController.cpp

@@ -25,20 +25,8 @@ PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_
 
     case FIRMWARE_VER_2_PT_00:
         led_count = 1;
-        asr_led = true;
-        strcpy(device_name, "ASRock ASR LED FW 2.00");
-        break;
-
-    case FIRMWARE_VER_2_PT_08:
-        led_count = 1;
-        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 ASR LED FW 2.10");
+        asr_led = false;
+        strcpy(device_name, "ASRock Polychrome FW 2.00");
         break;
 
     case FIRMWARE_VER_3_PT_00:
@@ -88,38 +76,45 @@ unsigned int PolychromeController::GetLEDCount()
 
 unsigned int PolychromeController::GetMode()
 {
-    return(active_mode);
+    return(0);
 }
 
-bool PolychromeController::IsAsrLed()
+void PolychromeController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
 {
-    return(asr_led);
-}
-
-void PolychromeController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char colors[3] = { red, green, blue };
-
     if (asr_led)
     {
-        bus->i2c_smbus_write_block_data(dev, active_mode, 3, colors);
+
     }
     else
     {
+        unsigned char colors[3] = { red, green, blue };
+
+        bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_COLOR, 3, colors);
+    }
+}
+
+void PolychromeController::SetLEDColor(unsigned int /*led*/, unsigned char red, unsigned char green, unsigned char blue)
+{
+    if (asr_led)
+    {
+
+    }
+    else
+    {
+        unsigned char colors[3] = { red, green, blue };
+
         bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_COLOR, 3, colors);
     }
 }
 
 void PolychromeController::SetMode(unsigned char mode)
 {
-    active_mode = mode;
-
     if (asr_led)
     {
-        bus->i2c_smbus_write_block_data(dev, ASRLED_REG_MODE, 1, &active_mode);
+
     }
     else
     {
-        bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_MODE, 1, &active_mode);
+        bus->i2c_smbus_write_byte_data(dev, POLYCHROME_REG_MODE, mode);
     }    
 }

Controllers/PolychromeController/PolychromeController.h

@@ -18,8 +18,6 @@ enum
 {
     FIRMWARE_VER_1_PT_10            = 0x010A,   /* Firmware nu51_1.10                   */
     FIRMWARE_VER_2_PT_00            = 0x0200,   /* Firmware nu51_2.00                   */
-    FIRMWARE_VER_2_PT_08            = 0x0208,   /* Firmware nu51_2.08                   */
-    FIRMWARE_VER_2_PT_10            = 0x020A,   /* Firmware nu51_2.10                   */
     FIRMWARE_VER_3_PT_00            = 0x0300,   /* Firmware nu51_3.00                   */
 };
 
@@ -79,8 +77,8 @@ public:
     char*           GetDeviceName();
     unsigned int    GetLEDCount();
     unsigned int    GetMode();
-    bool            IsAsrLed();
-    void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
+    void            SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
+    void            SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
     void            SetMode(unsigned char mode);
     unsigned short  GetFirmwareVersion();
 
@@ -88,8 +86,7 @@ private:
     bool                    asr_led;
     char                    device_name[32];
     unsigned int            led_count;
-    unsigned char           active_mode;
     i2c_smbus_interface*    bus;
     polychrome_dev_id       dev;
 
-};
+};

Controllers/PoseidonZRGBController/PoseidonZRGBController.cpp

@@ -9,8 +9,6 @@
 
 #include "PoseidonZRGBController.h"
 
-#include <cstring>
-
 #ifdef WIN32
 #include <Windows.h>
 #else
@@ -22,14 +20,15 @@ static void Sleep(unsigned int milliseconds)
 }
 #endif
 
-static unsigned int keys[] = {0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x15,
-                              0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23,
-                              0x24, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31,
-                              0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3E, 0x3F, 0x40,
-                              0x41, 0x42, 0x43, 0x44, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4E, 0x4F,
-                              0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C,
-                              0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x69, 0x6A,
-                              0x6C, 0x6D, 0x6F, 0x70, 0x72, 0x73, 0x75, 0x76, 0x77, 0x78, 0x7C, 0x80, 0x81 };
+static unsigned int keys[] = {8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21,
+                              22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35,
+                              36, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+                              50, 51, 52, 54, 55, 56, 57, 58, 59, 60, 62, 63, 64,
+                              65, 66, 67, 68, 70, 71, 72, 73, 74, 75, 76, 78, 79,
+                              80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
+                              93, 94, 95, 96, 97, 98, 99, 100, 102, 103, 104, 105,
+                              106, 108, 109, 111, 112, 114, 115, 117, 118, 119, 120,
+                              124, 128, 129 };
 
 PoseidonZRGBController::PoseidonZRGBController(hid_device* dev_handle)
 {
@@ -41,21 +40,9 @@ PoseidonZRGBController::~PoseidonZRGBController()
 
 }
 
-void PoseidonZRGBController::SetMode(unsigned char mode, unsigned char direction, unsigned char speed)
+char* PoseidonZRGBController::GetDeviceName()
 {
-    active_mode = mode;
-    active_direction = direction;
-    active_speed = speed;
-
-    SendControl
-        (
-        POSEIDONZ_PROFILE_P1,
-        POSEIDONZ_PROFILE_P1,
-        active_direction,
-        active_mode,
-        POSEIDONZ_BRIGHTNESS_MAX,
-        active_speed
-        );
+    return device_name;
 }
 
 void PoseidonZRGBController::SetLEDsDirect(std::vector<RGBColor> colors)
@@ -63,174 +50,124 @@ void PoseidonZRGBController::SetLEDsDirect(std::vector<RGBColor> colors)
     unsigned char red_grn_buf[264];
     unsigned char blu_buf[264];
 
-    /*-----------------------------------------------------*\
-    | Zero out buffers                                      |
-    \*-----------------------------------------------------*/
-    memset(red_grn_buf, 0x00, sizeof(red_grn_buf));
-    memset(blu_buf, 0x00, sizeof(blu_buf));
+    for(int i = 0; i < 264; i++)
+    {
+        red_grn_buf[i] = 0x00;
+        blu_buf[i]     = 0x00;
+    }
 
-    /*-----------------------------------------------------*\
-    | Set up Direct packets                                 |
-    \*-----------------------------------------------------*/
-    red_grn_buf[0] = 0x07;
-    red_grn_buf[1] = POSEIDONZ_PACKET_ID_SET_DIRECT;
-    red_grn_buf[2] = POSEIDONZ_PROFILE_P1;
-    red_grn_buf[3] = POSEIDONZ_DIRECT_RED_GREEN;
+    red_grn_buf[0] = POSEIDONZ_START;
+    red_grn_buf[1] = POSEIDONZ_LED_CMD;
+    red_grn_buf[2] = POSEIDONZ_PROFILE;
+    red_grn_buf[3] = POSEIDONZ_RED_GRN_CH;
     red_grn_buf[4] = 0x00;
     red_grn_buf[5] = 0x00;
     red_grn_buf[6] = 0x00;
     red_grn_buf[7] = 0x00;
 
-    blu_buf[0] = 0x07;
-    blu_buf[1] = POSEIDONZ_PACKET_ID_SET_DIRECT;
-    blu_buf[2] = POSEIDONZ_PROFILE_P1;
-    blu_buf[3] = POSEIDONZ_DIRECT_BLUE;
+    blu_buf[0] = POSEIDONZ_START;
+    blu_buf[1] = POSEIDONZ_LED_CMD;
+    blu_buf[2] = POSEIDONZ_PROFILE;
+    blu_buf[3] = POSEIDONZ_BLU_CH;
     blu_buf[4] = 0x00;
     blu_buf[5] = 0x00;
     blu_buf[6] = 0x00;
     blu_buf[7] = 0x00;
 
-    /*-----------------------------------------------------*\
-    | Fill in color data                                    |
-    \*-----------------------------------------------------*/
-    for(std::size_t i = 0; i < 104; i++)
+    for(int i = 0; i < 104; i++)
     {
         red_grn_buf[keys[i]      ] = RGBGetRValue(colors[i]);
         red_grn_buf[keys[i] + 128] = RGBGetGValue(colors[i]);
         blu_buf[    keys[i]      ] = RGBGetBValue(colors[i]);
     }
 
-    /*-----------------------------------------------------*\
-    | Send packets                                          |
-    \*-----------------------------------------------------*/
     hid_send_feature_report(dev, red_grn_buf, 264);
+    
+    Sleep(1);
+
     hid_send_feature_report(dev, blu_buf, 264);
+
 }
 
 void PoseidonZRGBController::SetLEDs(std::vector<RGBColor> colors)
 {
-    unsigned char red_color_data[104];
-    unsigned char grn_color_data[104];
-    unsigned char blu_color_data[104];
+    unsigned char buf[264] = {0};
 
-    for(std::size_t i = 0; i < 104; i++)
+    //Send Red Packet
+    for(int i = 0; i < 264; i++)
     {
-        red_color_data[i] = RGBGetRValue(colors[i]);
-        grn_color_data[i] = RGBGetGValue(colors[i]);
-        blu_color_data[i] = RGBGetBValue(colors[i]);
+        buf[i] = 0xFF;
     }
 
-    SendColor
-        (
-        POSEIDONZ_PROFILE_P1,
-        POSEIDONZ_COLOR_RED,
-        red_color_data
-        );
+    buf[0] = 0x07;
+    buf[1] = 0x09;
+    buf[2] = 0x01;
+    buf[3] = 0x01;
 
-    Sleep(10);
-
-    SendColor
-        (
-        POSEIDONZ_PROFILE_P1,
-        POSEIDONZ_COLOR_GREEN,
-        grn_color_data
-        );
-
-    Sleep(10);
-
-    SendColor
-        (
-        POSEIDONZ_PROFILE_P1,
-        POSEIDONZ_COLOR_BLUE,
-        blu_color_data
-        );
-
-    Sleep(10);
-
-    SendControl
-        (
-        POSEIDONZ_PROFILE_P1,
-        POSEIDONZ_PROFILE_P1,
-        active_direction,
-        active_mode,
-        POSEIDONZ_BRIGHTNESS_MAX,
-        active_speed
-        );
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void PoseidonZRGBController::SendColor
-    (
-    unsigned char   profile_to_edit,
-    unsigned char   color_channel,
-    unsigned char*  color_data
-    )
-{
-    unsigned char buf[264];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Color packet                                   |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x07;
-    buf[0x01]   = POSEIDONZ_PACKET_ID_SET_COLOR;
-    buf[0x02]   = profile_to_edit;
-    buf[0x03]   = color_channel;
-
-    /*-----------------------------------------------------*\
-    | Fill in color data                                    |
-    \*-----------------------------------------------------*/
     for(int i = 0; i < 104; i++)
     {
-        buf[keys[i]] = color_data[i];
+        buf[keys[i]] = RGBGetRValue(colors[i]);
     }
 
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
     hid_send_feature_report(dev, buf, 264);
-}
-
-void PoseidonZRGBController::SendControl
-    (
-    unsigned char   profile_to_activate,
-    unsigned char   profile_to_edit,
-    unsigned char   direction,
-    unsigned char   mode,
-    unsigned char   brightness,
-    unsigned char   speed
-    )
-{
-    unsigned char buf[264];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Effect packet                                  |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x07;
-    buf[0x01]   = POSEIDONZ_PACKET_ID_SET_EFFECT;
-    buf[0x02]   = profile_to_activate;
-    buf[0x08]   = profile_to_edit;
-    buf[0x0A]   = direction;
-    buf[0x0C]   = mode;
-    buf[0x0D]   = brightness;
-    buf[0x10]   = 0x08;
-    buf[0x12]   = speed;
-    buf[0x13]   = 0x50;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
+
+    Sleep(10);
+    
+    //Send Green Packet
+    for(int i = 0; i < 264; i++)
+    {
+        buf[i] = 0x00;
+    }
+
+    buf[0] = 0x07;
+    buf[1] = 0x09;
+    buf[2] = 0x01;
+    buf[3] = 0x02;
+
+    buf[8] = 0xFF;
+
+    for(int i = 0; i < 104; i++)
+    {
+        buf[keys[i]] = RGBGetGValue(colors[i]);
+    }
+
+    hid_send_feature_report(dev, buf, 264);
+
+    Sleep(10);
+    
+    //Send Blue Packet
+    for(int i = 0; i < 264; i++)
+    {
+        buf[i] = 0x11;
+    }
+
+    buf[0] = 0x07;
+    buf[1] = 0x09;
+    buf[2] = 0x01;
+    buf[3] = 0x03;
+
+    for(int i = 0; i < 104; i++)
+    {
+       buf[keys[i]] = RGBGetBValue(colors[i]);
+    }
+
+    hid_send_feature_report(dev, buf, 264);
+
+    Sleep(10);
+    
+    //Send Update Packet
+    for(int i = 0; i < 264; i++)
+    {
+        buf[i] = 0x00;
+    }
+
+    buf[0] = 0x07;
+    buf[1] = 0x02;
+    buf[2] = 0x01;
+    buf[8] = 0x01;  //Preset to save
+    buf[13] = 0x04; //Brightness?
+    buf[16] = 0x08;
+    buf[22] = 0x03;
+
     hid_send_feature_report(dev, buf, 264);
 }

Controllers/PoseidonZRGBController/PoseidonZRGBController.h

@@ -21,86 +21,18 @@
 #define POSEIDONZ_RED_GRN_CH  0x01
 #define POSEIDONZ_BLU_CH      0x02
 
-enum
-{
-    POSEIDONZ_PACKET_ID_SET_EFFECT      = 0x02,     /* Set profile effect packet            */
-    POSEIDONZ_PACKET_ID_SET_COLOR       = 0x09,     /* Set profile color packet             */
-    POSEIDONZ_PACKET_ID_SET_DIRECT      = 0x0E,     /* Set direct color packet              */
-};
-
-enum
-{
-    POSEIDONZ_MODE_STATIC       = 0x00,
-    POSEIDONZ_MODE_REACTIVE     = 0x01,
-    POSEIDONZ_MODE_ARROW_FLOW   = 0x02,
-    POSEIDONZ_MODE_WAVE         = 0x03,
-    POSEIDONZ_MODE_RIPPLE       = 0x04
-};
-
-enum
-{
-    POSEIDONZ_PROFILE_P1        = 0x01,
-    POSEIDONZ_PROFILE_P2        = 0x02,
-    POSEIDONZ_PROFILE_P3        = 0x03,
-    POSEIDONZ_PROFILE_P4        = 0x04,
-    POSEIDONZ_PROFILE_P5        = 0x05
-};
-
-enum
-{
-    POSEIDONZ_BRIGHTNESS_MIN    = 0x00,
-    POSEIDONZ_BRIGHTNESS_MAX    = 0x04
-};
-
-enum
-{
-    POSEIDONZ_COLOR_RED         = 0x01,
-    POSEIDONZ_COLOR_GREEN       = 0x02,
-    POSEIDONZ_COLOR_BLUE        = 0x03
-};
-
-enum
-{
-    POSEIDONZ_DIRECT_RED_GREEN  = 0x01,
-    POSEIDONZ_DIRECT_BLUE       = 0x02
-};
-
-enum
-{
-    POSEIDONZ_SPEED_SLOW        = 0x10,
-    POSEIDONZ_SPEED_FAST        = 0x05
-};
-
 class PoseidonZRGBController
 {
 public:
     PoseidonZRGBController(hid_device* dev_handle);
     ~PoseidonZRGBController();
 
-    void SetMode(unsigned char mode, unsigned char direction, unsigned char speed);
+    char* GetDeviceName();
+
     void SetLEDsDirect(std::vector<RGBColor> colors);
     void SetLEDs(std::vector<RGBColor> colors);
     
 private:
+    char                    device_name[32];
     hid_device*             dev;
-    unsigned char           active_mode;
-    unsigned char           active_direction;
-    unsigned char           active_speed;
-
-    void SendControl
-        (
-        unsigned char   profile_to_activate,
-        unsigned char   profile_to_edit,
-        unsigned char   direction,
-        unsigned char   mode,
-        unsigned char   brightness,
-        unsigned char   speed
-        );
-    
-    void SendColor
-        (
-        unsigned char   profile_to_edit,
-        unsigned char   color_channel,
-        unsigned char*  color_data
-        );
 };

Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp

@@ -18,28 +18,12 @@
 
 void DetectPoseidonZRGBControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device_info* info;
-    hid_device* dev = NULL;
+    hid_device* dev;
 
+    //Look for Thermaltake Poseidon Z RGB Keyboard
     hid_init();
 
-    info = hid_enumerate(TT_POSEIDON_Z_RGB_VID, TT_POSEIDON_Z_RGB_PID);
-
-    //Look for Thermaltake Poseidon Z RGB, Interface 2
-    while(info)
-    {
-        if((info->vendor_id == TT_POSEIDON_Z_RGB_VID)
-         &&(info->product_id == TT_POSEIDON_Z_RGB_PID)
-         &&(info->interface_number == 2))
-        {
-            dev = hid_open_path(info->path);
-            break;
-        }
-        else
-        {
-            info = info->next;
-        }
-    }
+    dev = hid_open(TT_POSEIDON_Z_RGB_VID, TT_POSEIDON_Z_RGB_PID, 0);
 
     if( dev )
     {

Controllers/RGBFusion2Controller/RGBFusion2Controller.cpp

@@ -1,285 +0,0 @@
-/*-----------------------------------------*\
-|  RGBFusion2Controller.cpp                 |
-|                                           |
-|  Driver for Gigabyte Aorus RGB Fusion 2.0 |
-|  lighting controller                      |
-|                                           |
-|  jackun 1/8/2020                          |
-\*-----------------------------------------*/
-
-#include "RGBFusion2Controller.h"
-#include <algorithm>
-#include <array>
-#include <thread>
-#include <chrono>
-
-static LEDCount LedCountToEnum(unsigned int c)
-{
-    if (c <= 32)
-        return(LEDS_32);
-    if (c <= 64)
-        return(LEDS_64);
-    if (c <= 256)
-        return(LEDS_256);
-    if (c <= 512)
-        return(LEDS_512);
-
-    return(LEDS_1024);
-}
-
-RGBFusion2Controller::RGBFusion2Controller(hid_device* handle, const char *path) : dev(handle)
-{
-    int res = 0;
-    char text[64] {};
-    unsigned char buffer[64] {};
-
-    if( dev ) {
-
-        SetCalibration();
-
-        // hid report read needs 0x60 packet or it gives IO error
-        SendPacket(0x60, 0x00);
-
-        buffer[0] = report_id;
-        res = hid_get_feature_report(dev, buffer, 64);
-        if( res > 0 )
-        {
-            report = *reinterpret_cast<IT8297Report*>(buffer);
-
-            name = std::string(report.str_product, 32);
-            name.erase(std::find(name.begin(), name.end(), '\0'), name.end());
-
-            snprintf(text, 11, "0x%08X", report.fw_ver);
-            version = text;
-
-            snprintf(text, 11, "0x%08X", report.chip_id);
-            chip_id = text;
-        }
-
-        loc = path;
-
-        EnableBeat(false);
-    }
-}
-
-RGBFusion2Controller::~RGBFusion2Controller()
-{
-    if( dev ) {
-        hid_close(dev);
-    }
-}
-
-void RGBFusion2Controller::SetMode(int m)
-{
-    mode = m;
-}
-
-// Sets RGB color mapping to LED pins.
-// "Custom" RGB packets don't seem to get remapped so use report.byteorderN and do it manually.
-// Of course it all depends how we send data to the controller, but bios/rgb fusion 2 itself
-// set it up like this.
-void RGBFusion2Controller::SetCalibration()
-{
-    uint8_t buffer[64] {};
-    buffer[0] = report_id;
-    buffer[1] = 0x33;
-
-     // D_LED1 WS2812 GRB, 0x00RRGGBB to 0x00GGRRBB
-    buffer[2] = 0x02; // B
-    buffer[3] = 0x00; // G
-    buffer[4] = 0x01; // R
-    buffer[5] = 0x00;
-
-     // D_LED2 WS2812 GRB
-    buffer[6] = 0x02;
-    buffer[7] = 0x00;
-    buffer[8] = 0x01;
-    buffer[9] = 0x00;
-
-    // LED C1/C2 12vGRB, seems pins already connect to LEDs correctly
-    buffer[10] = 0x00;
-    buffer[11] = 0x01;
-    buffer[12] = 0x02;
-    buffer[13] = 0x00;
-
-    SendPacket(buffer);
-}
-
-void RGBFusion2Controller::SetLedCount(unsigned int count)
-{
-    led_count = count;
-    LEDCount s0 = LedCountToEnum(count);
-    SendPacket(0x34, s0 | (s0 << 4)); // D_LED1 | D_LED2
-}
-
-bool RGBFusion2Controller::DisableBuiltinEffect(int enable_bit, int mask)
-{
-    if(effect_disabled & enable_bit)
-        return(true);
-
-    effect_disabled &= ~mask;
-    effect_disabled |= enable_bit;
-
-    int res = SendPacket(0x32, effect_disabled);
-    // Sometimes effect doesn't apply at first, delay a little and let MCU to react, if this packet is the cause
-    std::this_thread::sleep_for(std::chrono::milliseconds(50));
-    return res;
-}
-
-bool RGBFusion2Controller::EnableBeat(bool e)
-{
-    return SendPacket(0x31, e ? 1 : 0);
-}
-
-std::string RGBFusion2Controller::GetDeviceName()
-{
-    return(name);
-}
-
-std::string RGBFusion2Controller::GetFWVersion()
-{
-    return(version);
-}
-
-std::string RGBFusion2Controller::GetDeviceLocation()
-{
-    return(loc);
-}
-
-std::string RGBFusion2Controller::GetSerial()
-{
-    return(chip_id);
-}
-
-void RGBFusion2Controller::SetStripColors(unsigned int hdr, int start, int end, std::vector<RGBColor>& colors, int single_led)
-{
-    PktRGB pkt;
-    pkt.Init(hdr, report_id);
-
-     // FIXME assuming that LED strips ports are 0x58/0x59 for all boards
-    uint32_t byteorder = hdr == HDR_D_LED1_RGB ? report.byteorder0 : report.byteorder1;
-
-    unsigned char bo_r = byteorder >> 16;
-    unsigned char bo_g = byteorder >> 8;
-    unsigned char bo_b = byteorder & 0xFF;
-
-    int res;
-    int leds_left = end - start;
-    int sent_data = 0;
-    int k = 0;
-    int leds_in_pkt = sizeof(pkt.s.leds) / sizeof(*pkt.s.leds); /* 19 */
-
-    // other leds stay at whatever the builtin effect was doing at that moment
-    // if breathing/pulse effect faded out then they stay dark
-    if(single_led > -1)
-    {
-        leds_left = 1;
-        k = single_led - start;
-        sent_data = k * 3;
-        leds_in_pkt = 1;
-    }
-
-    while(leds_left > 0)
-    {
-        leds_in_pkt = (std::min)(leds_in_pkt, leds_left);
-        leds_left -= leds_in_pkt;
-
-        pkt.s.bcount = leds_in_pkt * 3;
-        pkt.s.boffset = sent_data;
-        sent_data += pkt.s.bcount;
-
-        for(int i = 0; i < leds_in_pkt; i++)
-        {
-            RGBColor      color = colors[start + k];
-            unsigned char red   = RGBGetRValue(color);
-            unsigned char grn   = RGBGetGValue(color);
-            unsigned char blu   = RGBGetBValue(color);
-
-            pkt.buffer[5 + i * 3 + bo_r] = red;
-            pkt.buffer[5 + i * 3 + bo_g] = grn;
-            pkt.buffer[5 + i * 3 + bo_b] = blu;
-            k++;
-        }
-
-        res = SendPacket(pkt.buffer);
-        if(res < 0)
-            return;
-    }
-
-    if (hdr == HDR_D_LED1_RGB)
-        DisableBuiltinEffect(0x01, 0x01);
-    else
-        DisableBuiltinEffect(0x02, 0x02);
-}
-
-static const std::array< std::array<int, 3>, 5> speeds = {
-    {
-        {1600, 1600, 200},
-        {1200, 1200, 200},
-        {800, 800, 200},
-        {400, 400, 200},
-        {200, 200, 200},
-    },
-};
-
-void RGBFusion2Controller::SetLEDEffect(unsigned int led, int mode, unsigned int speed, bool random, unsigned char r, unsigned char g, unsigned char b)
-{
-    PktEffect pkt;
-    pkt.Init(led, report_id);
-    pkt.e.effect_type = mode;
-    pkt.e.color0 = r << 16 | g << 8 | b;
-
-    if (speed < speeds.size()) {
-        const auto& s = speeds[speed];
-        pkt.e.period0 = s[0];
-        pkt.e.period1 = s[1];
-        pkt.e.period2 = s[2];
-    }
-
-    switch(mode)
-    {
-    case 0: break;
-    case 1: break; // static
-    case 2: // breathing
-    case 3: // blink
-        if (random)
-            pkt.e.effect_param0 = 7; // cycle through up to 7 (max?) colors
-        break;
-    case 4: // color cycle
-        pkt.e.effect_param0 = 7; // cycle through up to 7 (max?) colors
-        break;
-
-    // "fake" effects
-    case 10: // flashing, flashing color cycle
-        pkt.e.period0 = 200;
-        pkt.e.period1 = 200;
-        pkt.e.period2 = 5000 - 1000 * speed; // time between flashing, doesn't seem to be affected by period0/period1
-        pkt.e.effect_type = 3;
-        pkt.e.effect_param2 = 2; // flash twice
-        if (random)
-            pkt.e.effect_param0 = 7;
-        break;
-    }
-
-    SendPacket(pkt.buffer);
-}
-
-bool RGBFusion2Controller::ApplyEffect()
-{
-    return SendPacket(0x28, 0xFF);
-}
-
-bool RGBFusion2Controller::SendPacket(uint8_t a, uint8_t b, uint8_t c)
-{
-    unsigned char buffer[64] {};
-    buffer[0] = report_id;
-    buffer[1] = a;
-    buffer[2] = b;
-    buffer[3] = c;
-    return (SendPacket(buffer) == 64);
-}
-
-int RGBFusion2Controller::SendPacket(unsigned char* packet)
-{
-    return hid_send_feature_report(dev, packet, 64);
-}

Controllers/RGBFusion2Controller/RGBFusion2Controller.h

@@ -1,190 +0,0 @@
-/*-----------------------------------------*\
-|  RGBFusion2Controller.h                   |
-|                                           |
-|  Definitions and types for Gigabyte Aorus |
-|  RGB Fusion 2.0 lighting controller       |
-|                                           |
-|  jackun 1/8/2020                          |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <cstring>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-// LED "headers" 0x20..0x27, As seen on Gigabyte X570 Elite board
-const uint8_t HDR_BACK_IO  = 0x20;
-const uint8_t HDR_CPU      = 0x21;
-const uint8_t HDR_LED_2    = 0x22;
-const uint8_t HDR_PCIE     = 0x23;
-const uint8_t HDR_LED_C1C2 = 0x24;
-const uint8_t HDR_D_LED1   = 0x25;
-const uint8_t HDR_D_LED2   = 0x26;
-const uint8_t HDR_LED_7    = 0x27;
-
-const uint8_t HDR_D_LED1_RGB = 0x58; // FIXME assuming that it is 0x58 for all boards
-const uint8_t HDR_D_LED2_RGB = 0x59;
-
-enum EffectType
-{
-    EFFECT_NONE = 0,
-    EFFECT_STATIC = 1,
-    EFFECT_PULSE = 2,
-    EFFECT_BLINKING = 3,
-    EFFECT_COLORCYCLE = 4,
-    // to be continued...
-};
-
-enum LEDCount
-{
-    LEDS_32 = 0,
-    LEDS_64,
-    LEDS_256,
-    LEDS_512,
-    LEDS_1024,
-};
-
-struct LEDs
-{
-    uint8_t r;
-    uint8_t g;
-    uint8_t b;
-};
-
-#pragma pack(push, 1)
-
-union PktRGB
-{
-    unsigned char buffer[64];
-    struct RGBData
-    {
-        uint8_t     report_id;
-        uint8_t     header;
-        uint16_t    boffset; // in bytes, absolute
-        uint8_t     bcount;
-        LEDs        leds[19];
-        uint16_t    padding0;
-    } s;
-
-    PktRGB() : s {}
-    {
-    }
-
-    void Init(uint8_t header, uint8_t report_id)
-    {
-        s.report_id = report_id;
-        s.header    = header;
-        s.boffset   = 0;
-        s.bcount    = 0;
-        memset(s.leds, 0, sizeof(s.leds));
-    }
-};
-
-union PktEffect
-{
-    unsigned char buffer[64];
-    struct Effect
-    {
-        uint8_t report_id;
-        uint8_t header;
-        uint32_t zone0; // rgb fusion seems to set it to pow(2, header - 0x20)
-        uint32_t zone1;
-        uint8_t reserved0;
-        uint8_t effect_type;
-        uint8_t max_brightness;
-        uint8_t min_brightness;
-        uint32_t color0;
-        uint32_t color1;
-        uint16_t period0; // fade in
-        uint16_t period1; // fade out
-        uint16_t period2; // hold
-        uint16_t period3;
-        uint8_t effect_param0;
-        uint8_t effect_param1;
-        uint8_t effect_param2;
-        uint8_t effect_param3;
-        uint8_t padding0[30];
-    } e;
-
-    PktEffect() : e {}
-    {
-    }
-
-    void Init(int header, uint8_t report_id)
-    {
-        memset(buffer, 0, sizeof(buffer));
-        e.report_id = report_id;
-        if (header < 8)
-            e.header = 32 + header; // set as default
-        else
-            e.header = header;
-        e.zone0 = (uint32_t)(1 << (e.header - 32));
-        e.effect_type = EFFECT_STATIC;
-        e.max_brightness = 100;
-        e.min_brightness = 0;
-        e.color0 = 0x00FF2100; //orange
-        e.period0 = 1200;
-        e.period1 = 1200;
-        e.period2 = 200;
-        e.period3 = 200;
-        e.effect_param0 = 0; // ex color count to cycle through (max seems to be 7)
-        e.effect_param1 = 0;
-        e.effect_param2 = 1; // ex flash repeat count
-        e.effect_param3 = 0;
-    }
-};
-
-struct IT8297Report
-{
-    uint8_t report_id;
-    uint8_t product;
-    uint8_t device_num;
-    uint8_t total_leds;
-    uint32_t fw_ver;
-    uint16_t curr_led_count;
-    uint16_t reserved0;
-    char str_product[32]; // might be 28 and an extra byteorder3
-    uint32_t byteorder0; // is little-endian 0x00RRGGBB ?
-    uint32_t byteorder1;
-    uint32_t byteorder2;
-    uint32_t chip_id;
-    uint32_t reserved1;
-};
-
-#pragma pack(pop)
-
-class RGBFusion2Controller
-{
-public:
-    RGBFusion2Controller(hid_device* handle, const char *path);
-    ~RGBFusion2Controller();
-
-    void            SetStripColors(unsigned int hdr, int start, int end, std::vector<RGBColor>& colors, int single_led = -1);
-    void            SetLEDEffect(unsigned int led, int mode, unsigned int speed, bool random, unsigned char red, unsigned char green, unsigned char blue);
-    void            SetLedCount(unsigned int count);
-    void            SetMode(int mode);
-    bool            ApplyEffect();
-    bool            DisableBuiltinEffect(int enable_bit, int mask);
-    void            SetCalibration();
-    std::string     GetDeviceName();
-    std::string     GetDeviceLocation();
-    std::string     GetFWVersion();
-    std::string     GetSerial();
-
-private:
-    bool            EnableBeat(bool enable);
-    bool            SendPacket(uint8_t a, uint8_t b, uint8_t c = 0);
-    int             SendPacket(unsigned char* packet);
-
-    hid_device*             dev;
-    int                     mode;
-    unsigned int            led_count;
-    IT8297Report            report;
-    std::string             name;
-    std::string             loc;
-    std::string             version;
-    std::string             chip_id;
-    int                     effect_disabled = 0;
-    int                     report_id = 0xCC;
-};

Controllers/RGBFusion2Controller/RGBFusion2ControllerDetect.cpp

@@ -1,37 +0,0 @@
-#include "RGBFusion2Controller.h"
-#include "RGBController_RGBFusion2.h"
-
-#define IT8297_VID 0x048D
-#define IT8297_PID 0x8297
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectRGBFusion2Controllers                                                            *
-*                                                                                          *
-*       Detect RGB Fusion 2 devices that use IT8297 RGB controller                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectRGBFusion2Controllers(std::vector<RGBController*> &rgb_controllers)
-{
-    if (hid_init() < 0)
-        return;
-
-    hid_device_info * device_list = hid_enumerate(IT8297_VID, IT8297_PID);
-    if (!device_list)
-        return;
-
-    hid_device_info * device = device_list;
-    while (device)
-    {
-        hid_device * dev = hid_open_path(device->path);
-        if (dev) {
-            RGBFusion2Controller * controller = new RGBFusion2Controller(dev, device_list->path);
-            RGBController_RGBFusion2 * rgb_controller = new RGBController_RGBFusion2(controller);
-            rgb_controllers.push_back(rgb_controller);
-        }
-        device = device->next;
-    }
-
-    hid_free_enumeration(device_list);
-}

Controllers/RGBFusionGPUController/RGBFusionGPUController.cpp

@@ -1,47 +0,0 @@
-/*-----------------------------------------*\
-|  RGBFusionGPUController.cpp               |
-|                                           |
-|  Driver for Gigabyte Aorus RGB Fusion GPU |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/20/2020   |
-\*-----------------------------------------*/
-
-#include "RGBFusionGPUController.h"
-
-RGBFusionGPUController::RGBFusionGPUController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-}
-
-RGBFusionGPUController::~RGBFusionGPUController()
-{
-
-}
-
-std::string RGBFusionGPUController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return(return_string);
-}
-
-void RGBFusionGPUController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
-{
-    bus->i2c_smbus_write_byte(dev, RGB_FUSION_GPU_REG_COLOR);
-    bus->i2c_smbus_write_byte(dev, red);
-    bus->i2c_smbus_write_byte(dev, green);
-    bus->i2c_smbus_write_byte(dev, blue);
-}
-
-void RGBFusionGPUController::SetMode(unsigned char mode, unsigned char speed)
-{
-    bus->i2c_smbus_write_byte(dev, RGB_FUSION_GPU_REG_MODE);
-    bus->i2c_smbus_write_byte(dev, mode);
-    bus->i2c_smbus_write_byte(dev, speed);
-    bus->i2c_smbus_write_byte(dev, 0x63);
-}

Controllers/RGBFusionGPUController/RGBFusionGPUController.h

@@ -1,54 +0,0 @@
-/*-----------------------------------------*\
-|  RGBFusionGPUController.h                 |
-|                                           |
-|  Definitions and types for Gigabyte Aorus |
-|  RGB Fusion GPU lighting controller       |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/20/2020   |
-\*-----------------------------------------*/
-
-#include <string>
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char	rgb_fusion_dev_id;
-
-enum
-{
-    RGB_FUSION_GPU_REG_COLOR            = 0x40,
-    RGB_FUSION_GPU_REG_MODE             = 0x88
-};
-
-enum
-{
-    RGB_FUSION_GPU_MODE_STATIC          = 0x01,
-    RGB_FUSION_GPU_MODE_BREATHING       = 0x02,
-    RGB_FUSION_GPU_MODE_FLASHING        = 0x04,
-    RGB_FUSION_GPU_MODE_DUAL_FLASHING   = 0x08,
-    RGB_FUSION_GPU_MODE_SPECTRUM_CYCLE  = 0x11
-};
-
-enum
-{
-    RGB_FUSION_GPU_SPEED_SLOWEST        = 0x00,
-    RGB_FUSION_GPU_SPEED_NORMAL         = 0x05,
-    RGB_FUSION_GPU_SPEED_FASTEST        = 0x09
-};
-
-class RGBFusionGPUController
-{
-public:
-    RGBFusionGPUController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev);
-    ~RGBFusionGPUController();
-
-    std::string     GetDeviceLocation();
-
-    void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
-    void            SetMode(unsigned char mode, unsigned char speed);
-
-private:
-    i2c_smbus_interface*    bus;
-    rgb_fusion_dev_id       dev;
-
-};

Controllers/RGBFusionGPUController/RGBFusionGPUControllerDetect.cpp

@@ -1,83 +0,0 @@
-#include "RGBFusionGPUController.h"
-#include "RGBController.h"
-#include "RGBController_RGBFusionGPU.h"
-#include "i2c_smbus.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForRGBFusionGPUController                                                          *
-*                                                                                          *
-*       Tests the given address to see if an RGB Fusion controller exists there.  First    *
-*       does a quick write to test for a response                                          *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForRGBFusionGPUController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-    int res;
-
-    //Write out 0xAB 0x00 0x00 0x00 sequence
-    res = bus->i2c_smbus_write_byte(address, 0xAB);
-
-    if (res >= 0)
-    {
-        bus->i2c_smbus_write_byte(address, 0x00);
-        bus->i2c_smbus_write_byte(address, 0x00);
-        bus->i2c_smbus_write_byte(address, 0x00);
-
-        pass = true;
-
-        res = bus->i2c_smbus_read_byte(address);
-
-        if (res != 0xAB)
-        {
-            pass = false;
-        }
-
-        res = bus->i2c_smbus_read_byte(address);
-
-        if(res != 0x14)
-        {
-            pass = false;
-        }
-
-        bus->i2c_smbus_read_byte(address);
-        bus->i2c_smbus_read_byte(address);
-    }
-
-    return(pass);
-
-}   /* TestForRGBFusionGPUController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectRGBFusionGPUControllers                                                          *
-*                                                                                          *
-*       Detect RGB Fusion controllers on the enumerated I2C busses at address 0x47.        *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected      *
-*           dev - I2C address of RGB Fusion device                                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectRGBFusionGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
-{
-    RGBFusionGPUController* new_rgb_fusion;
-    RGBController_RGBFusionGPU* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        // Check for RGB Fusion controller at 0x47
-        if (TestForRGBFusionGPUController(busses[bus], 0x47))
-        {
-            new_rgb_fusion = new RGBFusionGPUController(busses[bus], 0x47);
-            new_controller = new RGBController_RGBFusionGPU(new_rgb_fusion);
-            rgb_controllers.push_back(new_controller);
-        }
-    }
-
-}   /* DetectRGBFusionGPUControllers() */

Controllers/ThermaltakeRiingController/ThermaltakeRiingController.cpp

@@ -1,117 +0,0 @@
-/*-----------------------------------------*\
-|  ThermaltakeRiingController.cpp           |
-|                                           |
-|  Definitions and types for Thermaltake    |
-|  Riing Plus lighting controller           |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/7/2020    |
-\*-----------------------------------------*/
-
-#include "ThermaltakeRiingController.h"
-
-#include <cstring>
-
-ThermaltakeRiingController::ThermaltakeRiingController(libusb_device_handle* dev_handle)
-{
-    dev = dev_handle;
-
-    SendInit();
-
-    channel_leds[0] = 9;
-    channel_leds[1] = 9;
-    channel_leds[2] = 9;
-    channel_leds[3] = 0;
-    channel_leds[4] = 0;
-}
-
-ThermaltakeRiingController::~ThermaltakeRiingController()
-{
-
-}
-
-void ThermaltakeRiingController::SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors)
-{
-    unsigned char* color_data = new unsigned char[3 * colors.size()];
-
-    for(int color = 0; color < colors.size(); color++)
-    {
-        int color_idx = color * 3;
-        color_data[color_idx + 0] = RGBGetGValue(colors[color]);
-        color_data[color_idx + 1] = RGBGetRValue(colors[color]);
-        color_data[color_idx + 2] = RGBGetBValue(colors[color]);
-    }
-
-    SendRGB(channel, current_mode, current_speed, colors.size(), color_data);
-
-    delete[] color_data;
-}
-
-void ThermaltakeRiingController::SetMode(unsigned char mode, unsigned char speed)
-{
-    current_mode        = mode;
-    current_speed       = speed;
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void ThermaltakeRiingController::SendInit()
-{
-    unsigned char usb_buf[64];
-    int           actual;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Init packet                                    |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xFE;
-    usb_buf[0x01]   = 0x33;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
-    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
-}
-
-void ThermaltakeRiingController::SendRGB
-    (
-        unsigned char       port,
-        unsigned char       mode,
-        unsigned char       speed,
-        unsigned char       num_colors,
-        unsigned char*      color_data
-    )
-{
-    unsigned char usb_buf[64];
-    int           actual;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up RGB packet                                     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x32;
-    usb_buf[0x01]   = 0x52;
-    usb_buf[0x02]   = port;
-    usb_buf[0x03]   = mode + ( speed & 0x03 );
-
-    /*-----------------------------------------------------*\
-    | Copy in GRB color data                                |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x04], color_data, (num_colors * 3));
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
-    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
-}

Controllers/ThermaltakeRiingController/ThermaltakeRiingController.h

@@ -1,75 +0,0 @@
-/*-----------------------------------------*\
-|  ThermaltakeRiingController.h             |
-|                                           |
-|  Definitions and types for Thermaltake    |
-|  Riing Plus lighting controller           |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/7/2020    |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <vector>
-#include <libusb-1.0/libusb.h>
-
-#pragma once
-
-enum
-{
-    THERMALTAKE_PORT_1              = 0x01,
-    THERMALTAKE_PORT_2              = 0x02,
-    THERMALTAKE_PORT_3              = 0x03,
-    THERMALTAKE_PORT_4              = 0x04,
-    THERMALTAKE_PORT_5              = 0x05
-};
-
-enum
-{
-    THERMALTAKE_MODE_FLOW           = 0x00,
-    THERMALTAKE_MODE_SPECTRUM       = 0x04,
-    THERMALTAKE_MODE_RIPPLE         = 0x08,
-    THERMALTAKE_MODE_BLINK          = 0x0C,
-    THERMALTAKE_MODE_PULSE          = 0x10,
-    THERMALTAKE_MODE_WAVE           = 0x14,
-    THERMALTAKE_MODE_PER_LED        = 0x18,
-    THERMALTAKE_MODE_FULL           = 0x19
-};
-
-enum
-{
-    THERMALTAKE_SPEED_SLOW          = 0x03,
-    THERMALTAKE_SPEED_NORMAL        = 0x02,
-    THERMALTAKE_SPEED_FAST          = 0x01,
-    THERMALTAKE_SPEED_EXTREME       = 0x00
-};
-
-class ThermaltakeRiingController
-{
-public:
-    ThermaltakeRiingController(libusb_device_handle* dev_handle);
-    ~ThermaltakeRiingController();
-
-    void            SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors);
-    void            SetMode(unsigned char mode, unsigned char speed);
-    
-    unsigned int    channel_leds[5];
-
-private:
-    libusb_device_handle*   dev;
-
-    unsigned char   current_mode;
-    unsigned char   current_speed;
-
-    void    SendInit();
-
-    void SendRGB
-        (
-            unsigned char       port,
-            unsigned char       mode,
-            unsigned char       speed,
-            unsigned char       num_colors,
-            unsigned char*      color_data
-        );
-
-    void    SendFan();
-    void    SendSave();
-};

Controllers/ThermaltakeRiingController/ThermaltakeRiingControllerDetect.cpp

@@ -1,41 +0,0 @@
-#include "ThermaltakeRiingController.h"
-#include "RGBController.h"
-#include "RGBController_ThermaltakeRiing.h"
-#include <vector>
-#include <libusb-1.0/libusb.h>
-
-#define THERMALTAKE_RIING_VID       0x264A
-#define THERMALTAKE_RIING_PID_BEGIN 0x1FA5
-#define THERMALTAKE_RIING_PID_END   0x1FB5
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectThermaltakeRiingControllers                                                      *
-*                                                                                          *
-*       Tests the USB address to see if an AMD Wraith Prism controller exists there.       *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectThermaltakeRiingControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    libusb_context * ctx;
-    libusb_init(&ctx);
-
-    for(int pid = THERMALTAKE_RIING_PID_BEGIN; pid <= THERMALTAKE_RIING_PID_END; pid++)
-    {
-        //Look for Thermaltake Riing device
-        libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, THERMALTAKE_RIING_VID, pid);
-
-        if( dev )
-        {
-            libusb_detach_kernel_driver(dev, 0);
-            libusb_claim_interface(dev, 0);
-
-            ThermaltakeRiingController* controller = new ThermaltakeRiingController(dev);
-
-            RGBController_ThermaltakeRiing* rgb_controller = new RGBController_ThermaltakeRiing(controller);
-
-            rgb_controllers.push_back(rgb_controller);
-        }
-    }
-}

OpenRGB.cpp

@@ -13,13 +13,15 @@
 #include <stdlib.h>
 
 #ifdef WIN32
+
 #include <regex>
 #include "i2c_smbus_piix4.h"
 #include "i2c_smbus_i801.h"
 #include "i2c_smbus_nct6775.h"
-#include "i2c_smbus_nvapi.h"
-#include "super_io.h"
 #include "wmi.h"
+#include "inpout32.h"
+
+#pragma comment(lib, "inpout32.lib")
 #else /* WIN32 */
 
 #include "i2c_smbus_linux.h"
@@ -34,6 +36,68 @@ std::vector<i2c_smbus_interface*> busses;
 std::vector<RGBController*> rgb_controllers;
 
 #ifdef WIN32
+/******************************************************************************************\
+*                                                                                          *
+*   Nuvoton Super IO constants                                                             *
+*                                                                                          *
+\******************************************************************************************/
+
+#define SIO_NCT5577_ID      0xC330  /* Device ID for NCT5577D (C333)        */
+#define SIO_NCT6102_ID      0x1060  /* Device ID for NCT6102D/6106D (1061)  */
+#define SIO_NCT6793_ID      0xd120  /* Device ID for NCT6793D (D121)        */
+#define SIO_NCT6796_ID      0xd420  /* Device ID for NCT6796D (D421)        */
+#define SIO_REG_LOGDEV      0x07    /* Logical Device Register              */
+#define SIO_REG_DEVID       0x20    /* Device ID Register                   */
+#define SIO_REG_SMBA        0x62    /* SMBus Base Address Register          */
+#define SIO_LOGDEV_SMBUS    0x0B    /* Logical Device for SMBus             */
+#define SIO_ID_MASK         0xFFF8  /* Device ID mask                       */
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   superio_enter                                                                          *
+*                                                                                          *
+*   Put the Super IO chip into Extended Function Mode                                      *
+*                                                                                          *
+\******************************************************************************************/
+
+void superio_enter(int ioreg)
+{
+    Out32(ioreg, 0x87);
+    Out32(ioreg, 0x87);
+}
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   superio_outb                                                                           *
+*                                                                                          *
+*   Write a byte to the Super IO configuration register                                    *
+*                                                                                          *
+\******************************************************************************************/
+
+void superio_outb(int ioreg, int reg, int val)
+{
+    Out32(ioreg, reg);
+    Out32(ioreg + 1, val);
+}
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   superio_inb                                                                            *
+*                                                                                          *
+*   Read a byte to the Super IO configuration register                                     *
+*                                                                                          *
+\******************************************************************************************/
+
+int superio_inb(int ioreg, int reg)
+{
+    Out32(ioreg, reg);
+    return Inp32(ioreg + 1);
+}
+
+
 /******************************************************************************************\
 *                                                                                          *
 *   DetectNuvotonI2CBusses (Windows)                                                       *
@@ -88,33 +152,6 @@ void DetectNuvotonI2CBusses()
 
 }   /* DetectNuvotonI2CBusses() */
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectNvAPII2CBusses (Windows)                                                         *
-*                                                                                          *
-*       Detects available NVidia NvAPI I2C adapters and enumerates                         *
-*       i2c_smbus_interface objects for them.  Only enumerates the first bus for each GPU  *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectNvAPII2CBusses()
-{
-    static NV_PHYSICAL_GPU_HANDLE   gpu_handles[64];
-    static NV_S32                   gpu_count = 0;
-
-    NV_STATUS initialize = NvAPI_Initialize();
-
-    NvAPI_EnumPhysicalGPUs(gpu_handles, &gpu_count);
-
-    for(NV_S32 gpu_idx = 0; gpu_idx < gpu_count; gpu_idx++)
-    {
-        i2c_smbus_nvapi * nvapi_bus = new i2c_smbus_nvapi(gpu_handles[gpu_idx]);
-
-        sprintf(nvapi_bus->device_name, "NVidia NvAPI I2C on GPU %d", gpu_idx);
-
-        busses.push_back(nvapi_bus);
-    }
-}   /* DetectNvAPII2CBusses() */
 
 /******************************************************************************************\
 *                                                                                          *
@@ -198,9 +235,6 @@ void DetectI2CBusses()
     // Detect Nuvoton Super IO SMBus adapters
     DetectNuvotonI2CBusses();
 
-    // Detect NVidia NvAPI I2C adapters
-    DetectNvAPII2CBusses();
-
 }   /* DetectI2CBusses() */
 
 #else /* WIN32 */
@@ -249,7 +283,14 @@ void DetectI2CBusses()
                 {
                     read(test_fd, device_string, sizeof(device_string));
                     close(test_fd);
-                    
+
+                    //ignore nvidia adapters for now
+                    if(strncmp(device_string, "NVIDIA", 6) == 0)
+                    {
+                        ent = readdir(dir);
+                        continue;
+                    }
+
                     bus = new i2c_smbus_linux();
                     strcpy(bus->device_name, device_string);
 
@@ -277,31 +318,24 @@ void DetectI2CBusses()
 #endif  /* WIN32 */
 
 void DetectAuraControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
-void DetectAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
 void DetectCorsairControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
 void DetectCorsairProControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
-void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
 void DetectHyperXControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
 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 DetectRGBFusionGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
-void DetectMSIRGBControllers(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);
 void DetectMSI3ZoneControllers(std::vector<RGBController*>& rgb_controllers);
 void DetectPoseidonZRGBControllers(std::vector<RGBController*>& rgb_controllers);
 void DetectCorsairCmdrProControllers(std::vector<RGBController*> &rgb_controllers);
-void DetectCorsairKeyboardControllers(std::vector<RGBController*>& rgb_controllers);
 void DetectCorsairNodeProControllers(std::vector<RGBController*> &rgb_controllers);
-void DetectFaustusControllers(std::vector<RGBController*> &rgb_controllers);
-void DetectHyperXKeyboardControllers(std::vector<RGBController*>& rgb_controllers);
-void DetectThermaltakeRiingControllers(std::vector<RGBController*>& rgb_controllers);
-void DetectRGBFusion2Controllers(std::vector<RGBController*> &rgb_controllers);
 
 /******************************************************************************************\
 *                                                                                          *
@@ -310,23 +344,18 @@ void DetectRGBFusion2Controllers(std::vector<RGBController*> &rgb_controllers);
 *       Detect and populate RGB Controllers vector                                         *
 *                                                                                          *
 \******************************************************************************************/
-#include "RGBController_Dummy.h"
+
 void DetectRGBControllers(void)
 {
     DetectI2CBusses();
 
     DetectAuraControllers(busses, rgb_controllers);
-    DetectAuraGPUControllers(busses, rgb_controllers);
     DetectCorsairControllers(busses, rgb_controllers);
     DetectCorsairProControllers(busses, rgb_controllers);
-    DetectCrucialControllers(busses, rgb_controllers);
     DetectHyperXControllers(busses, rgb_controllers);
     DetectPatriotViperControllers(busses, rgb_controllers);
     DetectPolychromeControllers(busses, rgb_controllers);
-    DetectRGBFusionGPUControllers(busses, rgb_controllers);
-
     DetectRGBFusionControllers(busses, rgb_controllers);
-    DetectMSIRGBControllers(rgb_controllers);
 
     DetectLEDStripControllers(rgb_controllers);
     DetectHue2Controllers(rgb_controllers);
@@ -335,12 +364,8 @@ void DetectRGBControllers(void)
     DetectAMDWraithPrismControllers(rgb_controllers);
     DetectMSI3ZoneControllers(rgb_controllers);
     DetectPoseidonZRGBControllers(rgb_controllers);
-    DetectHyperXKeyboardControllers(rgb_controllers);
     DetectCorsairCmdrProControllers(rgb_controllers);
-    DetectCorsairKeyboardControllers(rgb_controllers);
     DetectCorsairNodeProControllers(rgb_controllers);
-    DetectThermaltakeRiingControllers(rgb_controllers);
-    DetectRGBFusion2Controllers(rgb_controllers);
     
     DetectE131Controllers(rgb_controllers);
 
@@ -348,13 +373,14 @@ void DetectRGBControllers(void)
     | Windows-only devices                  |
     \*-------------------------------------*/
 #ifdef WIN32
-    DetectOpenRazerControllers(rgb_controllers);
+    DetectRazerChromaSDKControllers(rgb_controllers);
+    //DetectAorusGPUControllers(rgb_controllers);
+
     /*-------------------------------------*\
     | Linux-only devices                    |
     \*-------------------------------------*/
 #else
     DetectOpenRazerControllers(rgb_controllers);
-    DetectFaustusControllers(rgb_controllers);
 #endif
 
 }   /* DetectRGBControllers() */

OpenRGB.pro

@@ -5,45 +5,33 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 TARGET = OpenRGB
 TEMPLATE = app
 
-RC_ICONS = qt/OpenRGB.ico
-
 INCLUDEPATH +=                                                          \
     dependencies/libe131/src/                                           \
     i2c_smbus/                                                          \
     i2c_tools/                                                          \
     net_port/                                                           \
     serial_port/                                                        \
-    super_io/                                                           \
     Controllers/AMDWraithPrismController/                               \
     Controllers/AuraController/                                         \
-    Controllers/AuraGPUController/                                      \
     Controllers/CorsairController/                                      \
     Controllers/CorsairCmdrProController/                               \
-    Controllers/CorsairKeyboardController/                              \
     Controllers/CorsairNodeProController/                               \
     Controllers/CorsairProController/                                   \
-    Controllers/CrucialController/                                      \
     Controllers/Hue2Controller/                                         \
     Controllers/HuePlusController/                                      \
     Controllers/HyperXController/                                       \
-    Controllers/HyperXKeyboardController/                               \
     Controllers/LEDStripController/                                     \
     Controllers/MSI3ZoneController/                                     \
-    Controllers/MSIRGBController/                                       \
     Controllers/PatriotViperController/                                 \
     Controllers/PolychromeController/                                   \
     Controllers/PoseidonZRGBController/                                 \
     Controllers/RGBFusionController/                                    \
-    Controllers/RGBFusion2Controller/                                   \
-    Controllers/RGBFusionGPUController/                                 \
-    Controllers/ThermaltakeRiingController/                             \
     RGBController/                                                      \
     qt/
 
 SOURCES +=                                                              \
     dependencies/libe131/src/e131.c                                     \
     main.cpp                                                            \
-    cli.cpp                                                             \
     OpenRGB.cpp                                                         \
     qt/OpenRGBDeviceInfoPage.cpp                                        \
     qt/OpenRGBDevicePage.cpp                                            \
@@ -52,43 +40,31 @@ SOURCES +=                                                              \
     i2c_tools/i2c_tools.cpp                                             \
     net_port/net_port.cpp                                               \
     qt/OpenRGBDialog2.cpp                                               \
-    qt/OpenRGBProfileSaveDialog.cpp \
     qt/OpenRGBSystemInfoPage.cpp                                        \
     qt/hsv.cpp                                                          \
     serial_port/serial_port.cpp                                         \
-    super_io/super_io.cpp                                               \
     Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp   \
     Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp \
     Controllers/AuraController/AuraController.cpp                       \
     Controllers/AuraController/AuraControllerDetect.cpp                 \
-    Controllers/AuraGPUController/AuraGPUController.cpp                 \
-    Controllers/AuraGPUController/AuraGPUControllerDetect.cpp           \
     Controllers/CorsairController/CorsairController.cpp                 \
     Controllers/CorsairController/CorsairControllerDetect.cpp           \
     Controllers/CorsairCmdrProController/CorsairCmdrProController.cpp   \
     Controllers/CorsairCmdrProController/CorsairCmdrProControllerDetect.cpp \
-    Controllers/CorsairKeyboardController/CorsairKeyboardController.cpp \
-    Controllers/CorsairKeyboardController/CorsairKeyboardControllerDetect.cpp \
     Controllers/CorsairNodeProController/CorsairNodeProController.cpp   \
     Controllers/CorsairNodeProController/CorsairNodeProControllerDetect.cpp \
     Controllers/CorsairProController/CorsairProController.cpp           \
     Controllers/CorsairProController/CorsairProControllerDetect.cpp     \
-    Controllers/CrucialController/CrucialController.cpp                 \
-    Controllers/CrucialController/CrucialControllerDetect.cpp           \
     Controllers/Hue2Controller/Hue2Controller.cpp                       \
     Controllers/Hue2Controller/Hue2ControllerDetect.cpp                 \
     Controllers/HuePlusController/HuePlusController.cpp                 \
     Controllers/HuePlusController/HuePlusControllerDetect.cpp           \
     Controllers/HyperXController/HyperXController.cpp                   \
     Controllers/HyperXController/HyperXControllerDetect.cpp             \
-    Controllers/HyperXKeyboardController/HyperXKeyboardController.cpp   \
-    Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp \
     Controllers/LEDStripController/LEDStripController.cpp               \
     Controllers/LEDStripController/LEDStripControllerDetect.cpp         \
     Controllers/MSI3ZoneController/MSI3ZoneController.cpp               \
     Controllers/MSI3ZoneController/MSI3ZoneControllerDetect.cpp         \
-    Controllers/MSIRGBController/MSIRGBController.cpp                   \
-    Controllers/MSIRGBController/MSIRGBControllerDetect.cpp             \
     Controllers/PatriotViperController/PatriotViperController.cpp       \
     Controllers/PatriotViperController/PatriotViperControllerDetect.cpp \
     Controllers/PolychromeController/PolychromeController.cpp           \
@@ -97,39 +73,24 @@ SOURCES +=                                                              \
     Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp \
     Controllers/RGBFusionController/RGBFusionController.cpp             \
     Controllers/RGBFusionController/RGBFusionControllerDetect.cpp       \
-    Controllers/RGBFusion2Controller/RGBFusion2Controller.cpp           \
-    Controllers/RGBFusion2Controller/RGBFusion2ControllerDetect.cpp     \
-    Controllers/RGBFusionGPUController/RGBFusionGPUController.cpp       \
-    Controllers/RGBFusionGPUController/RGBFusionGPUControllerDetect.cpp \
-    Controllers/ThermaltakeRiingController/ThermaltakeRiingController.cpp \
-    Controllers/ThermaltakeRiingController/ThermaltakeRiingControllerDetect.cpp \
     RGBController/RGBController.cpp                                     \
     RGBController/E131ControllerDetect.cpp                              \
     RGBController/RGBController_AMDWraithPrism.cpp                      \
     RGBController/RGBController_Aura.cpp                                \
-    RGBController/RGBController_AuraGPU.cpp                             \
     RGBController/RGBController_Corsair.cpp                             \
     RGBController/RGBController_CorsairCmdrPro.cpp                      \
-    RGBController/RGBController_CorsairKeyboard.cpp                     \
     RGBController/RGBController_CorsairNodePro.cpp                      \
     RGBController/RGBController_CorsairPro.cpp                          \
-    RGBController/RGBController_Crucial.cpp                             \
-    RGBController/RGBController_Dummy.cpp                               \
     RGBController/RGBController_Hue2.cpp                                \
     RGBController/RGBController_HuePlus.cpp                             \
     RGBController/RGBController_HyperX.cpp                              \
-    RGBController/RGBController_HyperXKeyboard.cpp                      \
     RGBController/RGBController_E131.cpp                                \
     RGBController/RGBController_LEDStrip.cpp                            \
     RGBController/RGBController_MSI3Zone.cpp                            \
-    RGBController/RGBController_MSIRGB.cpp                              \
     RGBController/RGBController_PatriotViper.cpp                        \
     RGBController/RGBController_Polychrome.cpp                          \
     RGBController/RGBController_PoseidonZRGB.cpp                        \
-    RGBController/RGBController_RGBFusion.cpp                           \
-    RGBController/RGBController_RGBFusion2.cpp                          \
-    RGBController/RGBController_RGBFusionGPU.cpp                        \
-    RGBController/RGBController_ThermaltakeRiing.cpp                    \
+    RGBController/RGBController_RGBFusion.cpp
 
 HEADERS +=                                                              \
     qt/OpenRGBDeviceInfoPage.h                                          \
@@ -139,59 +100,41 @@ HEADERS +=                                                              \
     i2c_tools/i2c_tools.h                                               \
     net_port/net_port.h                                                 \
     qt/OpenRGBDialog2.h                                                 \
-    qt/OpenRGBProfileSaveDialog.h \
     qt/OpenRGBSystemInfoPage.h                                          \
     serial_port/find_usb_serial_port.h                                  \
     serial_port/serial_port.h                                           \
-    super_io/super_io.h                                                 \
     Controllers/AMDWraithPrismController/AMDWraithPrismController.h     \
     Controllers/AuraController/AuraController.h                         \
-    Controllers/AuraGPUController/AuraGPUController.h                   \
     Controllers/CorsairController/CorsairController.h                   \
     Controllers/CorsairCmdrProController/CorsairCmdrProController.h     \
-    Controllers/CorsairKeyboardController/CorsairKeyboardController.h   \
     Controllers/CorsairNodeProController/CorsairNodeProController.h     \
     Controllers/CorsairProController/CorsairProController.h             \
-    Controllers/CrucialController/CrucialController.h                   \
     Controllers/Hue2Controller/Hue2Controller.h                         \
     Controllers/HuePlusController/HuePlusController.h                   \
     Controllers/HyperXController/HyperXController.h                     \
-    Controllers/HyperXKeyboardController/HyperXKeyboardController.h     \
     Controllers/LEDStripController/LEDStripController.h                 \
     Controllers/MSI3ZoneController/MSI3ZoneController.h                 \
-    Controllers/MSIRGBController/MSIRGBController.h                     \
     Controllers/PatriotViperController/PatriotViperController.h         \
     Controllers/PolychromeController/PolychromeController.h             \
     Controllers/PoseidonZRGBController/PoseidonZRGBController.h         \
     Controllers/RGBFusionController/RGBFusionController.h               \
-    Controllers/RGBFusion2Controller/RGBFusion2Controller.h             \
-    Controllers/RGBFusionGPUController/RGBFusionGPUController.h         \
-    Controllers/ThermaltakeRiingController/ThermaltakeRiingController.h \
     RGBController/RGBController.h                                       \
     RGBController/RGBController_AMDWraithPrism.h                        \
     RGBController/RGBController_Aura.h                                  \
-    RGBController/RGBController_AuraGPU.h                               \
     RGBController/RGBController_Corsair.h                               \
     RGBController/RGBController_CorsairCmdrPro.h                        \
     RGBController/RGBController_CorsairNodePro.h                        \
     RGBController/RGBController_CorsairPro.h                            \
-    RGBController/RGBController_Crucial.h                               \
-    RGBController/RGBController_Dummy.h                                 \
     RGBController/RGBController_E131.h                                  \
     RGBController/RGBController_Hue2.h                                  \
     RGBController/RGBController_HuePlus.h                               \
     RGBController/RGBController_HyperX.h                                \
-    RGBController/RGBController_HyperXKeyboard.h                        \
     RGBController/RGBController_LEDStrip.h                              \
     RGBController/RGBController_MSI3Zone.h                              \
-    RGBController/RGBController_MSIRGB.h                                \
     RGBController/RGBController_PatriotViper.h                          \
     RGBController/RGBController_Polychrome.h                            \
     RGBController/RGBController_PoseidonZRGB.h                          \
-    RGBController/RGBController_RGBFusion.h                             \
-    RGBController/RGBController_RGBFusion2.h                            \
-    RGBController/RGBController_RGBFusionGPU.h                          \
-    RGBController/RGBController_ThermaltakeRiing.h                      \
+    RGBController/RGBController_RGBFusion.h
 
 RESOURCES += \
     qt/resources.qrc
@@ -201,7 +144,6 @@ FORMS += \
     qt/OpenRGBDevicePage.ui \
     qt/OpenRGBDialog.ui \
     qt/OpenRGBDialog2.ui \
-    qt/OpenRGBProfileSaveDialog.ui \
     qt/OpenRGBSystemInfoPage.ui
 
 #-----------------------------------------------
@@ -209,48 +151,36 @@ FORMS += \
 #-----------------------------------------------
 win32:INCLUDEPATH +=                                                    \
     dependencies/inpout32_1501/Win32/                                   \
+    dependencies/razer-chroma-2.9.0/inc                                 \
     dependencies/libusb-1.0.22/include                                  \
     dependencies/hidapi                                                 \
-    dependencies/NVFC                                                   \
-    dependencies/openrazer-win32                                        \
     wmi/                                                                \
 
 win32:SOURCES +=                                                        \
-    dependencies/NVFC/nvapi.cpp                                         \
     i2c_smbus/i2c_smbus_i801.cpp                                        \
     i2c_smbus/i2c_smbus_nct6775.cpp                                     \
-    i2c_smbus/i2c_smbus_nvapi.cpp                                       \
     i2c_smbus/i2c_smbus_piix4.cpp                                       \
     serial_port/find_usb_serial_port_win.cpp                            \
     wmi/wmi.cpp                                                         \
-    RGBController/OpenRazerWindowsDetect.cpp                            \
-    RGBController/RGBController_OpenRazerWindows.cpp                    \
+    RGBController/AorusGPUDetect.cpp                                    \
+    RGBController/RGBController_AorusGPU.cpp                            \
+    RGBController/RazerChromaSDKDetect.cpp                              \
+    RGBController/RGBController_RazerChromaSDK.cpp                      \
 
 win32:HEADERS +=                                                        \
     dependencies/inpout32_1501/Win32/inpout32.h                         \
-    dependencies/NVFC/nvapi.h                                           \
     i2c_smbus/i2c_smbus_i801.h                                          \
     i2c_smbus/i2c_smbus_nct6775.h                                       \
-    i2c_smbus/i2c_smbus_nvapi.h                                         \
     i2c_smbus/i2c_smbus_piix4.h                                         \
     wmi/wmi.h                                                           \
-    RGBController/RGBController_OpenRazerWindows.h                      \
+    RGBController/RGBController_AorusGPU.h                              \
+    RGBController/RGBController_RazerChromaSDK.h                        \
 
-win32:contains(QMAKE_TARGET.arch, x86_64) {
-    LIBS +=                                                             \
-        -lws2_32                                                        \
-        -L"$$PWD/dependencies/inpout32_1501/x64/" -linpoutx64           \
-        -L"$$PWD/dependencies/libusb-1.0.22/MS64/dll" -llibusb-1.0      \
-        -L"$$PWD/dependencies/hidapi-win/x64/" -lhidapi
-}
-
-win32:contains(QMAKE_TARGET.arch, x86) {
-    LIBS +=                                                             \
-        -lws2_32                                                        \
-        -L"$$PWD/dependencies/inpout32_1501/Win32/" -linpout32          \
-        -L"$$PWD/dependencies/libusb-1.0.22/MS32/dll" -llibusb-1.0      \
-        -L"$$PWD/dependencies/hidapi-win/x86/" -lhidapi
-}
+win32:LIBS +=                                                           \
+    -lws2_32                                                            \
+    -L"$$PWD/dependencies/inpout32_1501/Win32/" -linpout32              \
+    -L"$$PWD/dependencies/libusb-1.0.22/MS32/dll" -llibusb-1.0          \
+    -L"$$PWD/dependencies/hidapi-win/x86/" -lhidapi
 
 win32:DEFINES -=                                                        \
     UNICODE
@@ -262,23 +192,6 @@ win32:DEFINES +=                                                        \
     _WINSOCK_DEPRECATED_NO_WARNINGS                                     \
     WIN32_LEAN_AND_MEAN
 
-# Copy OpenRazer.dll to output directory
-win32:contains(QMAKE_TARGET.arch, x86_64) {
-    copydata.commands = $(COPY_FILE) \"$$shell_path($$PWD\\dependencies\\openrazer-win32\\OpenRazer64.dll)\" \"$$shell_path($$OUT_PWD)\"
-    first.depends = $(first) copydata
-    export(first.depends)
-    export(copydata.commands)
-    QMAKE_EXTRA_TARGETS += first copydata
-}
-
-win32:contains(QMAKE_TARGET.arch, x86) {
-    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
 #-----------------------------------------------
@@ -286,7 +199,6 @@ unix:INCLUDEPATH +=                                                     \
 
 unix:HEADERS +=                                                         \
     i2c_smbus/i2c_smbus_linux.h                                         \
-    RGBController/RGBController_Faustus.h                               \
 
 unix:LIBS +=                                                            \
     -lusb-1.0                                                           \
@@ -306,5 +218,4 @@ unix:SOURCES +=                                                         \
     i2c_smbus/i2c_smbus_linux.cpp                                       \
     serial_port/find_usb_serial_port_linux.cpp                          \
     RGBController/OpenRazerDetect.cpp                                   \
-    RGBController/RGBController_Faustus.cpp                             \
     RGBController/RGBController_OpenRazer.cpp                           \

README.md

@@ -21,21 +21,13 @@ See the [Project Wiki](https://gitlab.com/CalcProgrammer1/OpenRGB/-/wikis/home)
 **You must run the application as Administrator the first time to allow InpOut32 to set up.  It can be run as a normal user afterwards**
 
 #### Linux:
-  1. Either open the project using QT Creator or build it using qmake.  You will need the libusb-1.0-0 (or equivalent) and libhidapi development packages from your distribution's package manager installed.
+  1. Either open the project using QT Creator or build it using qmake.  You will need the libusb-1.0-0 (or equivalent) development package from your distribution's package manager installed.
     
-    * sudo apt install qt5-default libusb-1.0-0-dev libhidapi-dev
-
-    * git clone https://gitlab.com/CalcProgrammer1/OpenRGB
-
-    * cd OpenRGB
-
-    * git submodule update --init --recursive
-
-    * qmake OpenRGB.pro
-
-    * make -j8
-    
-    * ./OpenRGB
+         git clone https://gitlab.com/CalcProgrammer1/OpenRGB
+         cd OpenRGB
+         git submodule update --init --recursive
+         qmake OpenRGB.pro
+         make
      
 
   2. Allow access to SMBus:<br>

RGBController/AorusGPUDetect.cpp

@@ -0,0 +1,21 @@
+#include "RGBController.h"
+#include "RGBController_AorusGPU.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAorusGPUControllers                                                              *
+*                                                                                          *
+*       Detect devices supported by the Aorus GPU driver                                   *
+*                                                                                          *                                                                                          *
+\******************************************************************************************/
+
+void DetectAorusGPUControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    RGBController_AorusGPU * aorus_rgb = new RGBController_AorusGPU();
+
+    rgb_controllers.push_back(aorus_rgb);
+}   /* DetectLEDStripControllers() */

RGBController/OpenRazerDetect.cpp

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

RGBController/OpenRazerWindowsDetect.cpp

@@ -1,387 +0,0 @@
-#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.cpp

@@ -1,660 +1,5 @@
 #include "RGBController.h"
 
-unsigned char * RGBController::GetDeviceDescription()
-{
-    unsigned int data_ptr = 0;
-    unsigned int data_size = 0;
-
-    /*---------------------------------------------------------*\
-    | Calculate data size                                       |
-    \*---------------------------------------------------------*/
-    unsigned short name_len         = strlen(name.c_str())          + 1;
-    unsigned short description_len  = strlen(description.c_str())   + 1;
-    unsigned short version_len      = strlen(version.c_str())       + 1;
-    unsigned short serial_len       = strlen(serial.c_str())        + 1;
-    unsigned short location_len     = strlen(location.c_str())      + 1;
-    unsigned short num_modes        = modes.size();
-    unsigned short num_zones        = zones.size();
-    unsigned short num_leds         = leds.size();
-    unsigned short num_colors       = colors.size();
-
-    unsigned short *mode_name_len   = new unsigned short[num_modes];
-    unsigned short *zone_name_len   = new unsigned short[num_zones];
-    unsigned short *led_name_len    = new unsigned short[num_leds];
-
-    unsigned short *mode_num_colors = new unsigned short[num_modes];
-
-    unsigned short *zone_map_rows   = new unsigned short[num_zones];
-
-    data_size += sizeof(data_size);
-    data_size += sizeof(device_type);
-    data_size += name_len           + sizeof(name_len);
-    data_size += description_len    + sizeof(description_len);
-    data_size += version_len        + sizeof(version_len);
-    data_size += serial_len         + sizeof(serial_len);
-    data_size += location_len       + sizeof(location_len);
-
-    data_size += sizeof(num_modes);
-    data_size += sizeof(active_mode);
-
-    for(int mode_index = 0; mode_index < num_modes; mode_index++)
-    {
-        mode_name_len[mode_index]   = strlen(modes[mode_index].name.c_str()) + 1;
-        mode_num_colors[mode_index] = modes[mode_index].colors.size();
-
-        data_size += mode_name_len[mode_index] + sizeof(mode_name_len[mode_index]);
-        data_size += sizeof(modes[mode_index].value);
-        data_size += sizeof(modes[mode_index].flags);
-        data_size += sizeof(modes[mode_index].speed_min);
-        data_size += sizeof(modes[mode_index].speed_max);
-        data_size += sizeof(modes[mode_index].colors_min);
-        data_size += sizeof(modes[mode_index].colors_max);
-        data_size += sizeof(modes[mode_index].speed);
-        data_size += sizeof(modes[mode_index].direction);
-        data_size += sizeof(modes[mode_index].color_mode);
-        data_size += sizeof(mode_num_colors[mode_index]);
-        data_size += (mode_num_colors[mode_index] * sizeof(RGBColor));
-    }
-
-    data_size += sizeof(num_zones);
-
-    for(int zone_index = 0; zone_index < num_zones; zone_index++)
-    {
-        zone_name_len[zone_index]   = strlen(zones[zone_index].name.c_str()) + 1;
-        zone_map_rows[zone_index] = zones[zone_index].map.size();
-        
-        data_size += zone_name_len[zone_index] + sizeof(zone_name_len[zone_index]);
-        data_size += sizeof(zones[zone_index].type);
-        data_size += sizeof(zone_map_rows[zone_index]);
-
-        for(int row_index = 0; row_index < zone_map_rows[zone_index]; row_index++)
-        {
-            data_size += sizeof(unsigned short);
-
-            for(int row_led_index = 0; row_led_index < zones[zone_index].map[row_index].size(); row_led_index++)
-            {
-                data_size += sizeof(int);
-            }
-        }
-    }
-
-    data_size += sizeof(num_leds);
-
-    for(int led_index = 0; led_index < num_leds; led_index++)
-    {
-        led_name_len[led_index] = strlen(leds[led_index].name.c_str()) + 1;
-
-        data_size += led_name_len[led_index] + sizeof(led_name_len[led_index]);
-    }
-
-    data_size += sizeof(num_colors);
-    data_size += num_colors * sizeof(RGBColor);
-
-    /*---------------------------------------------------------*\
-    | Create data buffer                                        |
-    \*---------------------------------------------------------*/
-    unsigned char *data_buf = new unsigned char[data_size];
-
-    /*---------------------------------------------------------*\
-    | Copy in data size                                         |
-    \*---------------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &data_size, sizeof(data_size));
-    data_ptr += sizeof(data_size);
-
-    /*---------------------------------------------------------*\
-    | Copy in type                                              |
-    \*---------------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &type, sizeof(device_type));
-    data_ptr += sizeof(device_type);
-
-    /*---------------------------------------------------------*\
-    | Copy in name (size+data)                                  |
-    \*---------------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &name_len, sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    strcpy((char *)&data_buf[data_ptr], name.c_str());
-    data_ptr += name_len;
-
-    /*---------------------------------------------------------*\
-    | Copy in description (size+data)                           |
-    \*---------------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &description_len, sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    strcpy((char *)&data_buf[data_ptr], description.c_str());
-    data_ptr += description_len;
-    
-    /*---------------------------------------------------------*\
-    | Copy in version (size+data)                               |
-    \*---------------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &version_len, sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    strcpy((char *)&data_buf[data_ptr], version.c_str());
-    data_ptr += version_len;
-
-    /*---------------------------------------------------------*\
-    | Copy in serial (size+data)                                |
-    \*---------------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &serial_len, sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    strcpy((char *)&data_buf[data_ptr], serial.c_str());
-    data_ptr += serial_len;
-
-    /*---------------------------------------------------------*\
-    | Copy in location (size+data)                              |
-    \*---------------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &location_len, sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    strcpy((char *)&data_buf[data_ptr], location.c_str());
-    data_ptr += location_len;
-
-    /*---------------------------------------------------------*\
-    | Copy in number of modes (data)                            |
-    \*---------------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &num_modes, sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    /*---------------------------------------------------------*\
-    | Copy in active mode (data)                                |
-    \*---------------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &active_mode, sizeof(active_mode));
-    data_ptr += sizeof(active_mode);
-
-    /*---------------------------------------------------------*\
-    | Copy in modes                                             |
-    \*---------------------------------------------------------*/
-    for(int mode_index = 0; mode_index < num_modes; mode_index++)
-    {
-        /*---------------------------------------------------------*\
-        | Copy in mode name (size+data)                             |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &mode_name_len[mode_index], sizeof(unsigned short));
-        data_ptr += sizeof(unsigned short);
-
-        strcpy((char *)&data_buf[data_ptr], modes[mode_index].name.c_str());
-        data_ptr += mode_name_len[mode_index];
-
-        /*---------------------------------------------------------*\
-        | Copy in mode value (data)                                 |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &modes[mode_index].value, sizeof(modes[mode_index].value));
-        data_ptr += sizeof(modes[mode_index].value);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode flags (data)                                 |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &modes[mode_index].flags, sizeof(modes[mode_index].flags));
-        data_ptr += sizeof(modes[mode_index].flags);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode speed_min (data)                             |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &modes[mode_index].speed_min, sizeof(modes[mode_index].speed_min));
-        data_ptr += sizeof(modes[mode_index].speed_min);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode speed_max (data)                             |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &modes[mode_index].speed_max, sizeof(modes[mode_index].speed_max));
-        data_ptr += sizeof(modes[mode_index].speed_max);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode colors_min (data)                            |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &modes[mode_index].colors_min, sizeof(modes[mode_index].colors_min));
-        data_ptr += sizeof(modes[mode_index].colors_min);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode colors_max (data)                            |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &modes[mode_index].colors_max, sizeof(modes[mode_index].colors_max));
-        data_ptr += sizeof(modes[mode_index].colors_max);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode speed (data)                                 |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &modes[mode_index].speed, sizeof(modes[mode_index].speed));
-        data_ptr += sizeof(modes[mode_index].speed);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode direction (data)                             |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &modes[mode_index].direction, sizeof(modes[mode_index].direction));
-        data_ptr += sizeof(modes[mode_index].direction);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode color_mode (data)                            |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &modes[mode_index].color_mode, sizeof(modes[mode_index].color_mode));
-        data_ptr += sizeof(modes[mode_index].color_mode);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode number of colors                             |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &mode_num_colors[mode_index], sizeof(unsigned short));
-        data_ptr += sizeof(unsigned short);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode mode colors                                  |
-        \*---------------------------------------------------------*/
-        for(int color_index = 0; color_index < mode_num_colors[mode_index]; color_index++)
-        {
-            /*---------------------------------------------------------*\
-            | Copy in color (data)                                      |
-            \*---------------------------------------------------------*/
-            memcpy(&data_buf[data_ptr], &modes[mode_index].colors[color_index], sizeof(modes[mode_index].colors[color_index]));
-            data_ptr += sizeof(modes[mode_index].colors[color_index]);
-        }
-    }
-
-    /*---------------------------------------------------------*\
-    | Copy in number of zones (data)                            |
-    \*---------------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &num_zones, sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    /*---------------------------------------------------------*\
-    | Copy in zones                                             |
-    \*---------------------------------------------------------*/
-    for(int zone_index = 0; zone_index < num_zones; zone_index++)
-    {
-        /*---------------------------------------------------------*\
-        | Copy in zone name (size+data)                             |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &zone_name_len[zone_index], sizeof(unsigned short));
-        data_ptr += sizeof(unsigned short);
-
-        strcpy((char *)&data_buf[data_ptr], zones[zone_index].name.c_str());
-        data_ptr += zone_name_len[zone_index];
-
-        /*---------------------------------------------------------*\
-        | Copy in zone type (data)                                  |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &zones[zone_index].type, sizeof(zones[zone_index].type));
-        data_ptr += sizeof(zones[zone_index].type);
-
-        /*---------------------------------------------------------*\
-        | Copy in zone map number of rows                           |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &zone_map_rows[zone_index], sizeof(unsigned short));
-        data_ptr += sizeof(unsigned short);
-
-        /*---------------------------------------------------------*\
-        | Copy in rows                                              |
-        \*---------------------------------------------------------*/
-        for(int row_index = 0; row_index < zone_map_rows[zone_index]; row_index++)
-        {
-            /*---------------------------------------------------------*\
-            | Copy row size                                             |
-            \*---------------------------------------------------------*/
-            unsigned short zone_map_row_size = zones[zone_index].map[row_index].size();
-            memcpy(&data_buf[data_ptr], &zone_map_row_size, sizeof(unsigned short));
-            data_ptr += sizeof(unsigned short);
-
-            /*---------------------------------------------------------*\
-            | Copy in row LEDs                                          |
-            \*---------------------------------------------------------*/
-            for(int row_led_index = 0; row_led_index < zone_map_row_size; row_led_index++)
-            {
-                /*---------------------------------------------------------*\
-                | Copy row size                                             |
-                \*---------------------------------------------------------*/
-                memcpy(&data_buf[data_ptr], &zones[zone_index].map[row_index][row_led_index], sizeof(zones[zone_index].map[row_index][row_led_index]));
-                data_ptr += sizeof(zones[zone_index].map[row_index][row_led_index]);
-            }
-        }
-    }
-
-    /*---------------------------------------------------------*\
-    | Copy in number of LEDs (data)                             |
-    \*---------------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &num_leds, sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    /*---------------------------------------------------------*\
-    | Copy in LEDs                                              |
-    \*---------------------------------------------------------*/
-    for(int led_index = 0; led_index < num_leds; led_index++)
-    {
-        /*---------------------------------------------------------*\
-        | Copy in LED name (size+data)                              |
-        \*---------------------------------------------------------*/
-        unsigned short ledname_len = strlen(leds[led_index].name.c_str()) + 1;
-        memcpy(&data_buf[data_ptr], &ledname_len, sizeof(unsigned short));
-        data_ptr += sizeof(unsigned short);
-
-        strcpy((char *)&data_buf[data_ptr], leds[led_index].name.c_str());
-        data_ptr += ledname_len;
-    }
-
-    /*---------------------------------------------------------*\
-    | Copy in number of colors (data)                           |
-    \*---------------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &num_colors, sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    /*---------------------------------------------------------*\
-    | Copy in colors                                            |
-    \*---------------------------------------------------------*/
-    for(int color_index = 0; color_index < num_colors; color_index++)
-    {
-        /*---------------------------------------------------------*\
-        | Copy in color (data)                                      |
-        \*---------------------------------------------------------*/
-        memcpy(&data_buf[data_ptr], &colors[color_index], sizeof(colors[color_index]));
-        data_ptr += sizeof(colors[color_index]);
-    }
-
-
-    delete[] mode_name_len;
-    delete[] zone_name_len;
-    delete[] led_name_len;
-
-    delete[] mode_num_colors;
-    delete[] zone_map_rows;
-
-    return(data_buf);
-}
-
-void RGBController::ReadDeviceDescription(unsigned char* data_buf)
-{
-    unsigned int data_ptr = 0;
-
-    data_ptr += sizeof(unsigned int);
-
-    /*---------------------------------------------------------*\
-    | Copy in type                                              |
-    \*---------------------------------------------------------*/
-    memcpy(&type, &data_buf[data_ptr], sizeof(device_type));
-    data_ptr += sizeof(device_type);
-
-    /*---------------------------------------------------------*\
-    | Copy in name                                              |
-    \*---------------------------------------------------------*/
-    unsigned short name_len;
-    memcpy(&name_len, &data_buf[data_ptr], sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    name = (char *)&data_buf[data_ptr];
-    data_ptr += name_len;
-
-    /*---------------------------------------------------------*\
-    | Copy in description                                       |
-    \*---------------------------------------------------------*/
-    unsigned short description_len;
-    memcpy(&description_len, &data_buf[data_ptr], sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    description = (char *)&data_buf[data_ptr];
-    data_ptr += description_len;
-
-    /*---------------------------------------------------------*\
-    | Copy in version                                           |
-    \*---------------------------------------------------------*/
-    unsigned short version_len;
-    memcpy(&version_len, &data_buf[data_ptr], sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    version = (char *)&data_buf[data_ptr];
-    data_ptr += version_len;
-    
-    /*---------------------------------------------------------*\
-    | Copy in serial                                            |
-    \*---------------------------------------------------------*/
-    unsigned short serial_len;
-    memcpy(&serial_len, &data_buf[data_ptr], sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    serial = (char *)&data_buf[data_ptr];
-    data_ptr += serial_len;
-
-    /*---------------------------------------------------------*\
-    | Copy in location                                          |
-    \*---------------------------------------------------------*/
-    unsigned short location_len;
-    memcpy(&location_len, &data_buf[data_ptr], sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    location = (char *)&data_buf[data_ptr];
-    data_ptr += location_len;
-
-    /*---------------------------------------------------------*\
-    | Copy in number of modes (data)                            |
-    \*---------------------------------------------------------*/
-    unsigned short num_modes;
-    memcpy(&num_modes, &data_buf[data_ptr], sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    /*---------------------------------------------------------*\
-    | Copy in active mode (data)                                |
-    \*---------------------------------------------------------*/
-    memcpy(&active_mode, &data_buf[data_ptr], sizeof(active_mode));
-    data_ptr += sizeof(active_mode);
-
-    /*---------------------------------------------------------*\
-    | Copy in modes                                             |
-    \*---------------------------------------------------------*/
-    for(int mode_index = 0; mode_index < num_modes; mode_index++)
-    {
-        mode new_mode;
-
-        /*---------------------------------------------------------*\
-        | Copy in mode name (size+data)                             |
-        \*---------------------------------------------------------*/
-        unsigned short modename_len;
-        memcpy(&modename_len, &data_buf[data_ptr], sizeof(unsigned short));
-        data_ptr += sizeof(unsigned short);
-
-        new_mode.name = (char *)&data_buf[data_ptr];
-        data_ptr += modename_len;
-
-        /*---------------------------------------------------------*\
-        | Copy in mode value (data)                                 |
-        \*---------------------------------------------------------*/
-        memcpy(&new_mode.value, &data_buf[data_ptr], sizeof(new_mode.value));
-        data_ptr += sizeof(new_mode.value);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode flags (data)                                 |
-        \*---------------------------------------------------------*/
-        memcpy(&new_mode.flags, &data_buf[data_ptr], sizeof(new_mode.flags));
-        data_ptr += sizeof(new_mode.flags);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode speed_min (data)                             |
-        \*---------------------------------------------------------*/
-        memcpy(&new_mode.speed_min, &data_buf[data_ptr], sizeof(new_mode.speed_min));
-        data_ptr += sizeof(new_mode.speed_min);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode speed_max (data)                             |
-        \*---------------------------------------------------------*/
-        memcpy(&new_mode.speed_max, &data_buf[data_ptr], sizeof(new_mode.speed_max));
-        data_ptr += sizeof(new_mode.speed_max);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode colors_min (data)                            |
-        \*---------------------------------------------------------*/
-        memcpy(&new_mode.colors_min, &data_buf[data_ptr], sizeof(new_mode.colors_min));
-        data_ptr += sizeof(new_mode.colors_min);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode colors_max (data)                            |
-        \*---------------------------------------------------------*/
-        memcpy(&new_mode.colors_max, &data_buf[data_ptr], sizeof(new_mode.colors_max));
-        data_ptr += sizeof(new_mode.colors_max);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode speed (data)                                 |
-        \*---------------------------------------------------------*/
-        memcpy(&new_mode.speed, &data_buf[data_ptr], sizeof(new_mode.speed));
-        data_ptr += sizeof(new_mode.speed);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode direction (data)                             |
-        \*---------------------------------------------------------*/
-        memcpy(&new_mode.direction, &data_buf[data_ptr], sizeof(new_mode.direction));
-        data_ptr += sizeof(new_mode.direction);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode color_mode (data)                            |
-        \*---------------------------------------------------------*/
-        memcpy(&new_mode.color_mode, &data_buf[data_ptr], sizeof(new_mode.color_mode));
-        data_ptr += sizeof(new_mode.color_mode);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode number of colors                             |
-        \*---------------------------------------------------------*/
-        unsigned short mode_num_colors;
-        memcpy(&mode_num_colors, &data_buf[data_ptr], sizeof(unsigned short));
-        data_ptr += sizeof(unsigned short);
-
-        /*---------------------------------------------------------*\
-        | Copy in mode mode colors                                  |
-        \*---------------------------------------------------------*/
-        for(int color_index = 0; color_index < mode_num_colors; color_index++)
-        {
-            /*---------------------------------------------------------*\
-            | Copy in color (data)                                      |
-            \*---------------------------------------------------------*/
-            RGBColor new_color;
-            memcpy(&new_color, &data_buf[data_ptr], sizeof(RGBColor));
-            data_ptr += sizeof(modes[mode_index].colors[color_index]);
-
-            new_mode.colors.push_back(new_color);
-        }
-
-        modes.push_back(new_mode);
-    }
-
-    /*---------------------------------------------------------*\
-    | Copy in number of zones (data)                            |
-    \*---------------------------------------------------------*/
-    unsigned short num_zones;
-    memcpy(&num_zones, &data_buf[data_ptr], sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    /*---------------------------------------------------------*\
-    | Copy in zones                                             |
-    \*---------------------------------------------------------*/
-    for(int zone_index = 0; zone_index < num_zones; zone_index++)
-    {
-        zone new_zone;
-
-        /*---------------------------------------------------------*\
-        | Copy in zone name (size+data)                             |
-        \*---------------------------------------------------------*/
-        unsigned short zonename_len;
-        memcpy(&zonename_len, &data_buf[data_ptr], sizeof(unsigned short));
-        data_ptr += sizeof(unsigned short);
-
-        new_zone.name = (char *)&data_buf[data_ptr];
-        data_ptr += zonename_len;
-
-        /*---------------------------------------------------------*\
-        | Copy in zone type (data)                                  |
-        \*---------------------------------------------------------*/
-        memcpy(&new_zone.type, &data_buf[data_ptr], sizeof(new_zone.type));
-        data_ptr += sizeof(new_zone.type);
-
-        /*---------------------------------------------------------*\
-        | Copy in zone map number of rows                           |
-        \*---------------------------------------------------------*/
-        unsigned short zone_map_rows;
-        memcpy(&zone_map_rows, &data_buf[data_ptr], sizeof(unsigned short));
-        data_ptr += sizeof(unsigned short);
-
-        /*---------------------------------------------------------*\
-        | Copy in rows                                              |
-        \*---------------------------------------------------------*/
-        for(int row_index = 0; row_index < zone_map_rows; row_index++)
-        {
-            std::vector<int> new_zone_map_row;
-
-            /*---------------------------------------------------------*\
-            | Copy row size                                             |
-            \*---------------------------------------------------------*/
-            unsigned short zone_map_row_size;
-            memcpy(&zone_map_row_size, &data_buf[data_ptr], sizeof(unsigned short));
-            data_ptr += sizeof(unsigned short);
-
-            /*---------------------------------------------------------*\
-            | Copy in row LEDs                                          |
-            \*---------------------------------------------------------*/
-            for(int row_led_index = 0; row_led_index < zone_map_row_size; row_led_index++)
-            {
-                int new_index;
-
-                /*---------------------------------------------------------*\
-                | Copy row size                                             |
-                \*---------------------------------------------------------*/
-                memcpy(&new_index, &data_buf[data_ptr], sizeof(int));
-                data_ptr += sizeof(int);
-
-                new_zone_map_row.push_back(new_index);
-            }
-
-            new_zone.map.push_back(new_zone_map_row);
-        }
-
-        zones.push_back(new_zone);
-    }
-
-    /*---------------------------------------------------------*\
-    | Copy in number of LEDs (data)                             |
-    \*---------------------------------------------------------*/
-    unsigned short num_leds;
-    memcpy(&num_leds, &data_buf[data_ptr], sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    /*---------------------------------------------------------*\
-    | Copy in LEDs                                              |
-    \*---------------------------------------------------------*/
-    for(int led_index = 0; led_index < num_leds; led_index++)
-    {
-        led new_led;
-
-        /*---------------------------------------------------------*\
-        | Copy in LED name (size+data)                              |
-        \*---------------------------------------------------------*/
-        unsigned short ledname_len;
-        memcpy(&ledname_len, &data_buf[data_ptr], sizeof(unsigned short));
-        data_ptr += sizeof(unsigned short);
-
-        new_led.name = (char *)&data_buf[data_ptr];
-        data_ptr += ledname_len;
-
-        leds.push_back(new_led);
-    }
-
-    /*---------------------------------------------------------*\
-    | Copy in number of colors (data)                           |
-    \*---------------------------------------------------------*/
-    unsigned short num_colors;
-    memcpy(&num_colors, &data_buf[data_ptr], sizeof(unsigned short));
-    data_ptr += sizeof(unsigned short);
-
-    /*---------------------------------------------------------*\
-    | Copy in colors                                            |
-    \*---------------------------------------------------------*/
-    for(int color_index = 0; color_index < num_colors; color_index++)
-    {
-        RGBColor new_color;
-
-        /*---------------------------------------------------------*\
-        | Copy in color (data)                                      |
-        \*---------------------------------------------------------*/
-        memcpy(&new_color, &data_buf[data_ptr], sizeof(RGBColor));
-        data_ptr += sizeof(RGBColor);
-
-        colors.push_back(new_color);
-    }
-}
-
 RGBColor RGBController::GetLED(int led)
 {
     if(led < colors.size())
@@ -710,31 +55,4 @@ void RGBController::SetMode(int mode)
     active_mode = mode;
 
     UpdateMode();
-}
-
-std::string device_type_to_str(device_type type)
-{
-    switch(type)
-    {
-    case DEVICE_TYPE_MOTHERBOARD:
-        return "Motherboard";
-    case DEVICE_TYPE_DRAM:
-        return "DRAM";
-    case DEVICE_TYPE_GPU:
-        return "GPU";
-    case DEVICE_TYPE_COOLER:
-        return "Cooler";
-    case DEVICE_TYPE_LEDSTRIP:
-        return "LED Strip";
-    case DEVICE_TYPE_KEYBOARD:
-        return "Keyboard";
-    case DEVICE_TYPE_MOUSE:
-        return "Mouse";
-    case DEVICE_TYPE_MOUSEMAT:
-        return "Mousemat";
-    case DEVICE_TYPE_HEADSET:
-        return "Headset";
-    default:
-        return "Unknown";
-    }
-}
+}

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_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     */
+    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      */
 };
 
 /*------------------------------------------------------------------*\
@@ -48,14 +48,6 @@ 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                                                          |
 \*------------------------------------------------------------------*/
@@ -69,17 +61,13 @@ 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         */
-    unsigned int        color_mode; /* Mode color selection         */
-    std::vector<RGBColor>
-                        colors; /* mode-specific colors             */
+    bool                random; /* Random color mode enabled        */
 } mode;
 
 typedef struct
@@ -112,8 +100,6 @@ enum
     DEVICE_TYPE_UNKNOWN
 };
 
-std::string device_type_to_str(device_type type);
-
 typedef struct
 {
     std::string         name;   /* Zone name        */
@@ -150,9 +136,6 @@ public:
     int                     GetMode();
     void                    SetMode(int mode);
 
-    unsigned char *         GetDeviceDescription();
-    void                    ReadDeviceDescription(unsigned char* data_buf);
-
     /*---------------------------------------------------------*\
     | Functions to be implemented in device implementation      |
     \*---------------------------------------------------------*/

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_PER_LED_COLOR;
-    Static.color_mode = MODE_COLORS_PER_LED;
+    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;
     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_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;
+    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;
     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.color_mode = MODE_COLORS_NONE;
-    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.random    = false;
+    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.color_mode = MODE_COLORS_NONE;
-    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.random    = false;
+    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.color_mode = MODE_COLORS_NONE;
-    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.random    = true;
+    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_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;
+    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;
     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_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;
+    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;
     modes.push_back(Swirl);
 
     led logo_led;
@@ -175,42 +175,40 @@ void RGBController_AMDWraithPrism::UpdateSingleLED(int led)
 
 void RGBController_AMDWraithPrism::SetCustomMode()
 {
-    active_mode = 0;
+    SetMode(0);
 }
 
 void RGBController_AMDWraithPrism::UpdateMode()
 {
-    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);
+    wraith->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, modes[active_mode].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, random);
-            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, 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);
             break;
         
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
-            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);
+            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);
             break;
 
         default:
-            if(random)
+            if(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);
+                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);
             }
             else
             {
-                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);
+                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);
             }
             break;
     }
 
     UpdateLEDs();
-}
+}

RGBController/RGBController_AorusGPU.cpp

@@ -0,0 +1,83 @@
+/*-----------------------------------------*\
+|  RGBController_AorusGPU.cpp               |
+|                                           |
+|  Generic RGB Interface for OpenAuraSDK    |
+|  Aorus GPU                                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/17/2019   |
+\*-----------------------------------------*/
+
+#include "RGBController_AorusGPU.h"
+
+#include <Windows.h>
+
+static HMODULE handle;
+static unsigned char data[] = { 0x8E, 0x00, 0x00, 0x00,
+                                0x00, 0x00, 0x00, 0x00,
+                                0x40, 0x00, 0x00, 0x00,
+                                0x00, 0x00, 0x00, 0x00,
+                                0x04, 0x00, 0x00, 0x00,
+                                0x64, 0x00, 0x00, 0x00,
+                                0x01, 0x00, 0x00, 0x00 };
+
+void RGBController_AorusGPU::UpdateLEDs()
+{
+    RGBColor color = colors[0];
+    data[9] = RGBGetRValue(color);
+    data[10] = RGBGetGValue(color);
+    data[11] = RGBGetBValue(color);
+
+    GvWriteI2C(0x00000000, data, 0x00000000);
+}
+
+void RGBController_AorusGPU::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_AorusGPU::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
+}
+
+RGBController_AorusGPU::RGBController_AorusGPU()
+{
+    name = "Aorus GPU";
+    type = DEVICE_TYPE_GPU;
+
+    handle = LoadLibrary("GvDisplay.dll");
+
+    GvWriteI2C = (_GvWriteI2C)GetProcAddress(handle, "GvWriteI2C");
+    GvFreeDispLib = (_GvFreeDispLib)GetProcAddress(handle, "GvFreeDispLib");
+    GvInitDispLib = (_GvInitDispLib)GetProcAddress(handle, "GvInitDispLib");
+    
+    GvFreeDispLib();
+    GvInitDispLib();
+
+    colors.push_back(0x00000000);
+
+    mode aorus_mode;
+    aorus_mode.name = "Static";
+    modes.push_back(aorus_mode);
+
+    led aorus_led;
+    aorus_led.name = "GPU LED";
+    leds.push_back(aorus_led);
+
+    zone aorus_zone;
+    aorus_zone.name = "GPU LED";
+    std::vector<int> aorus_zone_map;
+    aorus_zone_map.push_back(0);
+    aorus_zone.map.push_back(aorus_zone_map);
+    zones.push_back(aorus_zone);
+}
+
+void RGBController_AorusGPU::SetCustomMode()
+{
+
+}
+
+void RGBController_AorusGPU::UpdateMode()
+{
+
+}

RGBController/RGBController_AorusGPU.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_AorusGPU.h                 |
+|                                           |
+|  Generic RGB Interface for OpenAuraSDK    |
+|  Aorus GPU                                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/17/2019   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+
+typedef unsigned int uint32;
+typedef uint32(*_GvWriteI2C)(uint32, void*, uint32);
+typedef void (*_GvFreeDispLib)();
+typedef void (*_GvInitDispLib)();
+
+class RGBController_AorusGPU : public RGBController
+{
+public:
+    RGBController_AorusGPU();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+private:
+    _GvWriteI2C GvWriteI2C;
+    _GvFreeDispLib GvFreeDispLib;
+    _GvInitDispLib GvInitDispLib;
+};

RGBController/RGBController_Aura.cpp

@@ -11,45 +11,38 @@
 
 int RGBController_Aura::GetDeviceMode()
 {
-    int  dev_mode  = aura->AuraRegisterRead(AURA_REG_MODE);
-    int color_mode = MODE_COLORS_PER_LED;
+    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;
+    }
 
     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].color_mode = color_mode;
+            active_mode        = mode;
+            modes[mode].random = random;
         }
     }
 
@@ -136,73 +129,63 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
     }
 
     mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0xFFFF;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name  = "Direct";
+    Direct.value = 0xFFFF;
+    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     modes.push_back(Direct);
 
     mode Off;
-    Off.name       = "Off";
-    Off.value      = AURA_MODE_OFF;
-    Off.flags      = 0;
-    Off.color_mode = MODE_COLORS_NONE;
+    Off.name  = "Off";
+    Off.value = AURA_MODE_OFF;
+    Off.flags = 0;
     modes.push_back(Off);
 
     mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode = MODE_COLORS_PER_LED;
+    Static.name  = "Static";
+    Static.value = AURA_MODE_STATIC;
+    Static.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     modes.push_back(Static);
     
     mode Breathing;
-    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;
+    Breathing.name  = "Breathing";
+    Breathing.value = AURA_MODE_BREATHING;
+    Breathing.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR | MODE_FLAG_PER_LED_COLOR;
     modes.push_back(Breathing);
 
     mode Flashing;
-    Flashing.name       = "Flashing";
-    Flashing.value      = AURA_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Flashing.color_mode = MODE_COLORS_PER_LED;
+    Flashing.name  = "Flashing";
+    Flashing.value = AURA_MODE_FLASHING;
+    Flashing.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     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;
+    SpectrumCycle.name  = "Spectrum Cycle";
+    SpectrumCycle.value = AURA_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags = 0;
     modes.push_back(SpectrumCycle);
 
     mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = AURA_MODE_RAINBOW;
-    Rainbow.flags      = 0;
-    Rainbow.color_mode = MODE_COLORS_NONE;
+    Rainbow.name  = "Rainbow";
+    Rainbow.value = AURA_MODE_RAINBOW;
+    Rainbow.flags = 0;
     modes.push_back(Rainbow);
 
     mode ChaseFade;
-    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;
+    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;
     modes.push_back(ChaseFade);
 
     mode Chase;
-    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;
+    Chase.name  = "Chase";
+    Chase.value = AURA_MODE_CHASE;
+    Chase.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR | MODE_FLAG_PER_LED_COLOR;
     modes.push_back(Chase);
 
     mode RandomFlicker;
-    RandomFlicker.name       = "Random Flicker";
-    RandomFlicker.value      = AURA_MODE_RANDOM_FLICKER;
-    RandomFlicker.flags      = 0;
-    RandomFlicker.color_mode = MODE_COLORS_NONE;
+    RandomFlicker.name  = "Random Flicker";
+    RandomFlicker.value = AURA_MODE_RANDOM_FLICKER;
+    RandomFlicker.flags = 0;
     modes.push_back(RandomFlicker);
 
     colors.resize(aura->GetLEDCount());
@@ -214,7 +197,6 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
         led* new_led = new led();
 
         new_led->name = aura->GetChannelName(i);
-        new_led->name.append(std::to_string(i));
 
         leds.push_back(*new_led);
 
@@ -277,7 +259,7 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
 
 void RGBController_Aura::SetCustomMode()
 {
-    active_mode = 0;
+    SetMode(0);
 }
 
 void RGBController_Aura::UpdateMode()
@@ -290,7 +272,7 @@ void RGBController_Aura::UpdateMode()
     {
         int new_mode = modes[active_mode].value;
 
-        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
+        if(modes[active_mode].random == true)
         {
             switch(new_mode)
             {
@@ -309,4 +291,4 @@ void RGBController_Aura::UpdateMode()
         aura->SetMode(new_mode);
         aura->SetDirect(false);
     }
-}
+}

RGBController/RGBController_AuraGPU.cpp

@@ -1,176 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AuraGPU.h                  |
-|                                           |
-|  Generic RGB Interface for Asus Aura GPU  |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
-
-#include "RGBController_AuraGPU.h"
-
-int RGBController_AuraGPU::GetDeviceMode()
-{
-    int dev_mode = aura_gpu->AuraGPURegisterRead(AURA_GPU_REG_MODE);
-    int color_mode = MODE_COLORS_PER_LED;
-
-    if(dev_mode == AURA_GPU_MODE_STATIC)
-    {
-        if (aura_gpu->direct)
-        {
-            dev_mode = AURA_GPU_MODE_DIRECT;
-        } 
-    }
-
-    switch(dev_mode)
-    {
-    case AURA_GPU_MODE_OFF:
-    case AURA_GPU_MODE_SPECTRUM_CYCLE:
-        color_mode = MODE_COLORS_NONE;
-        break;
-    }
-
-    for(int mode = 0; mode < modes.size(); mode++)
-    {
-        if(modes[mode].value == dev_mode)
-        {
-            active_mode            = mode;
-            modes[mode].color_mode = color_mode;
-        }   
-    }
-
-    return(active_mode);
-}
-
-void RGBController_AuraGPU::UpdateLEDs()
-{
-    for(std::size_t led = 0; led < colors.size(); led++)
-    {
-        unsigned char red = RGBGetRValue(colors[led]);
-        unsigned char grn = RGBGetGValue(colors[led]);
-        unsigned char blu = RGBGetBValue(colors[led]);
-
-        if (GetMode() == 0)
-        {
-            aura_gpu->SetLEDColorsDirect(red, grn, blu);
-        }
-        else 
-        {
-            aura_gpu->SetLEDColorsEffect(red, grn, blu);
-        }
-    }
-}
-
-void RGBController_AuraGPU::UpdateZoneLEDs(int zone)
-{
-    UpdateLEDs();
-}
-
-void RGBController_AuraGPU::UpdateSingleLED(int led)
-{
-    UpdateLEDs();
-}
-
-RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * aura_gpu_ptr)
-{
-    aura_gpu = aura_gpu_ptr;
-    
-
-    name = aura_gpu->GetDeviceName();
-    version = "0.00.1";
-    location = aura_gpu->GetDeviceLocation();
-    type = DEVICE_TYPE_GPU;
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = AURA_GPU_MODE_DIRECT;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Off;
-    Off.name       = "Off";
-    Off.value      = AURA_GPU_MODE_OFF;
-    Off.flags      = 0;
-    Off.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_GPU_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_GPU_MODE_BREATHING;
-    Breathing.flags      = 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_GPU_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Flashing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Flashing);
-
-    mode Spectrum_Cycle;
-    Spectrum_Cycle.name       = "Spectrum Cycle";
-    Spectrum_Cycle.value      = AURA_GPU_MODE_SPECTRUM_CYCLE;
-    Spectrum_Cycle.flags      = 0;
-    Spectrum_Cycle.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Spectrum_Cycle);
-
-    colors.resize(1);
-
-    led aura_gpu_led;                                                       
-    aura_gpu_led.name = "GPU";
-    leds.push_back(aura_gpu_led);
-
-    zone aura_gpu_zone;
-    aura_gpu_zone.name = "GPU";
-    aura_gpu_zone.type = ZONE_TYPE_SINGLE;
-
-    std::vector<int> aura_gpu_zone_map;
-    aura_gpu_zone_map.push_back(0);
-    aura_gpu_zone.map.push_back(aura_gpu_zone_map);
-    zones.push_back(aura_gpu_zone);
-
-    unsigned char red = aura_gpu->GetLEDRed();
-    unsigned char grn = aura_gpu->GetLEDGreen();
-    unsigned char blu = aura_gpu->GetLEDBlue();
-    
-    colors[0] =  ToRGBColor(red, grn, blu);
-
-    active_mode = GetDeviceMode();
-}
-
-void RGBController_AuraGPU::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AuraGPU::UpdateMode()
-{
-    int new_mode = modes[active_mode].value;
-    aura_gpu->direct = false;
-    
-    switch(new_mode)
-    {
-        
-    // Set all LEDs to 0 and Mode to static as a workaround for the non existing Off Mode
-    case AURA_GPU_MODE_OFF:
-        aura_gpu->SetLEDColorsEffect(0, 0, 0);
-        new_mode = AURA_GPU_MODE_STATIC;
-        break;
-    
-    // Direct mode is done by switching to Static and not applying color changes
-    case AURA_GPU_MODE_DIRECT:
-        aura_gpu->direct = true;
-        new_mode = AURA_GPU_MODE_STATIC;
-        break;
-    }
-
-    aura_gpu->SetMode(new_mode);
-}

RGBController/RGBController_AuraGPU.h

@@ -1,29 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AuraGPU.h                  |
-|                                           |
-|  Generic RGB Interface for Asus Aura GPU  |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AuraGPUController.h"
-
-class RGBController_AuraGPU : public RGBController
-{
-public:
-    RGBController_AuraGPU(AuraGPUController* aura_gpu_ptr);
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        UpdateMode();
-
-private:
-    AuraGPUController* aura_gpu;
-
-    int        GetDeviceMode();
-};

RGBController/RGBController_Corsair.cpp

@@ -39,24 +39,21 @@ 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_PER_LED_COLOR;
-    Static.color_mode = MODE_COLORS_PER_LED;
+    Static.name  = "Static";
+    Static.value = CORSAIR_VENGEANCE_RGB_MODE_SINGLE;
+    Static.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     modes.push_back(Static);
 
     mode Fade;
-    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;
+    Fade.name  = "Fade";
+    Fade.value = CORSAIR_VENGEANCE_RGB_MODE_FADE;
+    Fade.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     modes.push_back(Fade);
 
     mode Pulse;
-    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;
+    Pulse.name  = "Pulse";
+    Pulse.value = CORSAIR_VENGEANCE_RGB_MODE_PULSE;
+    Pulse.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     modes.push_back(Pulse);
 
     for (unsigned int i = 0; i < corsair->GetLEDCount(); i++)
@@ -88,10 +85,10 @@ RGBController_Corsair::RGBController_Corsair(CorsairController* corsair_ptr)
 
 void RGBController_Corsair::SetCustomMode()
 {
-    active_mode = 0;
+    SetMode(0);
 }
 
 void RGBController_Corsair::UpdateMode()
 {
     corsair->SetMode(modes[active_mode].value);
-}
+}

RGBController/RGBController_CorsairCmdrPro.cpp

@@ -19,145 +19,106 @@ RGBController_CorsairCmdrPro::RGBController_CorsairCmdrPro(CorsairCmdrProControl
     type = DEVICE_TYPE_LEDSTRIP;
     
     mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0xFFFF;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name  = "Direct";
+    Direct.value = 0xFFFF;
+    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     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.color_mode = MODE_COLORS_NONE;
+    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;
     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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    ColorShift.colors_min = 2;
-    ColorShift.colors_max = 2;
+    ColorShift.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
     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_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);
+    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;
     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_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);
+    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;
     modes.push_back(ColorWave);
 
     mode Static;
-    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);
+    Static.name  = "Static";
+    Static.value = CORSAIR_CMDR_PRO_MODE_STATIC;
+    Static.flags = MODE_FLAG_HAS_COLOR;
     modes.push_back(Static);
 
     mode Temperature;
-    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);
+    Temperature.name  = "Temperature";
+    Temperature.value = CORSAIR_CMDR_PRO_MODE_TEMPERATURE;
+    Temperature.flags = MODE_FLAG_HAS_COLOR;
     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_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);
+    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;
     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_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);
+    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;
     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_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);
+    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;
     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_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);
+    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;
     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.color_mode = MODE_COLORS_NONE;
+    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;
     modes.push_back(Rainbow);
 
     /*-------------------------------------------------*\
@@ -279,7 +240,7 @@ void RGBController_CorsairCmdrPro::UpdateSingleLED(int led)
 
 void RGBController_CorsairCmdrPro::SetCustomMode()
 {
-    active_mode = 0;
+    SetMode(9);
 }
 
 void RGBController_CorsairCmdrPro::UpdateMode()
@@ -293,39 +254,23 @@ 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,
-                                      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]);
+                                      modes[active_mode].random,
+                                      RGBGetRValue(colors[0]),
+                                      RGBGetGValue(colors[0]),
+                                      RGBGetBValue(colors[0]),
+                                      RGBGetRValue(colors[1]),
+                                      RGBGetGValue(colors[1]),
+                                      RGBGetBValue(colors[1]));
         }
     }
-}
+}

RGBController/RGBController_CorsairCmdrPro.h

@@ -9,6 +9,7 @@
 
 #pragma once
 #include "RGBController.h"
+#include "serial_port.h"
 #include "CorsairCmdrProController.h"
 
 class RGBController_CorsairCmdrPro : public RGBController

RGBController/RGBController_CorsairKeyboard.cpp

@@ -1,209 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_CorsairKeyboard.cpp        |
-|                                           |
-|  Generic RGB Interface for Corsair RGB    |
-|  keyboards                                |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/9/2020    |
-\*-----------------------------------------*/
-
-#include "RGBController_CorsairKeyboard.h"
-
-static const char* zone_names[] =
-{
-    "Keyboard",
-    "Media Keys"
-};
-
-static const unsigned int zone_sizes[] =
-{
-    104,
-    7
-};
-
-static const char* led_names[] =
-{
-    "Key: Escape",          //0
-    "Key: `",               //1
-    "Key: Tab",             //2
-    "Key: Caps Lock",       //3
-    "Key: Left Shift",      //4
-    "Key: Left Control",    //5
-    "Key: F12",             //6
-    "Key: =",               //7
-    "Key: Lock",            //8
-    "Key: Number Pad 7",    //9
-    "Key: F1",              //12
-    "Key: 1",               //13
-    "Key: Q",               //14
-    "Key: A",               //15
-    "Key: Left Windows",    //17
-    "Key: Print Screen",    //18
-    "Media Mute",           //20
-    "Key: Number Pad 8",    //21
-    "Key: F2",              //24
-    "Key: 2",               //25
-    "Key: W",               //26
-    "Key: S",               //27
-    "Key: Z",               //28
-    "Key: Left Alt",        //29
-    "Key: Scroll Lock",     //30
-    "Key: Backspace",       //31
-    "Media Stop",           //32
-    "Key: Number Pad 9",    //33
-    "Key: F3",              //36
-    "Key: 3",               //37
-    "Key: E",               //38
-    "Key: D",               //39
-    "Key: X",               //40
-    "Key: Pause/Break",     //42
-    "Key: Delete",          //43
-    "Media Previous",       //44
-    "Key: F4",              //48
-    "Key: 4",               //49
-    "Key: R",               //50
-    "Key: F",               //51
-    "Key: C",               //52
-    "Key: Space",           //53
-    "Key: Insert",          //54
-    "Key: End",             //55
-    "Media Play/Pause",     //56
-    "Key: Number Pad 4",    //57
-    "Key: F5",              //60
-    "Key: 5",               //61
-    "Key: T",               //62
-    "Key: G",               //63
-    "Key: V",               //64
-    "Key: Home",            //66
-    "Key: Page Down",       //67
-    "Media Next",           //68
-    "Key: Number Pad 5",    //69
-    "Key: F6",              //72
-    "Key: 6",               //73
-    "Key: Y",               //74
-    "Key: H",               //75
-    "Key: B",               //76
-    "Key: Page Up",         //78
-    "Key: Right Shift",     //79
-    "Key: Num Lock",        //80
-    "Key: Number Pad 6",    //81
-    "Key: F7",              //84
-    "Key: 7",               //85
-    "Key: U",               //86
-    "Key: J",               //87
-    "Key: N",               //88
-    "Key: Right Alt",       //89
-    "Key: ]",               //90
-    "Key: Right Control",   //91
-    "Key: Number Pad /",    //92
-    "Key: Number Pad 1",    //93
-    "Key: F8",              //96
-    "Key: 8",               //97
-    "Key: I",               //98
-    "Key: K",               //99
-    "Key: M",               //100
-    "Key: Right Windows",   //101
-    "Key: \\",              //102
-    "Key: Up Arrow",        //103
-    "Key: Number Pad *",    //104
-    "Key: Number Pad 2",    //105
-    "Key: F9",              //108
-    "Key: 9",               //109
-    "Key: O",               //110
-    "Key: L",               //111
-    "Key: ,",               //112
-    "Key: Context",         //113
-    "Key: Left Arrow",      //115
-    "Key: Number Pad -",    //116
-    "Key: Number Pad 3",    //117
-    "Key: F10",             //120
-    "Key: 0",               //121
-    "Key: P",               //122
-    "Key: ;",               //123
-    "Key: .",               //124
-    "Key: Enter",           //126
-    "Key: Down Arrow",      //127
-    "Key: Number Pad +",    //128
-    "Key: Number Pad 0",    //129
-    "Key: F11",             //132
-    "Key: -",               //133
-    "Key: [",               //134
-    "Key: '",               //135
-    "Key: /",               //136
-    "Key: Brightness",      //137
-    "Key: Right Arrow",     //139
-    "Key: Number Pad Enter",//140
-    "Key: Number Pad .",    //141
-    "Key: F12"
-};
-
-RGBController_CorsairKeyboard::RGBController_CorsairKeyboard(CorsairKeyboardController* corsair_ptr)
-{
-    corsair = corsair_ptr;
-
-    name = "Corsair RGB Keyboard";
-    type = DEVICE_TYPE_KEYBOARD;
-
-    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(111);
-
-    unsigned int led_idx = 0;
-    for(unsigned int zone_idx = 0; zone_idx < 2; zone_idx++)
-    {
-        zone new_zone;
-        new_zone.name.append(zone_names[zone_idx]);
-
-        std::vector<int> new_zone_map;
-
-        for(unsigned int led_count = 0; led_count < zone_sizes[zone_idx]; led_count++)
-        {
-            led new_led;
-            new_led.name.append(led_names[led_idx]);
-            leds.push_back(new_led);
-
-            new_zone_map.push_back(led_idx);
-
-            led_idx++;
-        }
-
-        new_zone.map.push_back(new_zone_map);
-
-        zones.push_back(new_zone);
-    }
-}
-
-RGBController_CorsairKeyboard::~RGBController_CorsairKeyboard()
-{
-
-}
-
-void RGBController_CorsairKeyboard::UpdateLEDs()
-{
-    corsair->SetLEDs(colors);
-}
-
-void RGBController_CorsairKeyboard::UpdateZoneLEDs(int zone)
-{
-    corsair->SetLEDs(colors);
-}
-
-void RGBController_CorsairKeyboard::UpdateSingleLED(int led)
-{
-    corsair->SetLEDs(colors);
-}
-
-void RGBController_CorsairKeyboard::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_CorsairKeyboard::UpdateMode()
-{
-
-}

RGBController/RGBController_CorsairKeyboard.h

@@ -1,29 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_CorsairKeyboard.h          |
-|                                           |
-|  Generic RGB Interface for Corsair RGB    |
-|  keyboards                                |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/9/2020    |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "CorsairKeyboardController.h"
-
-class RGBController_CorsairKeyboard : public RGBController
-{
-public:
-    RGBController_CorsairKeyboard(CorsairKeyboardController* corsair_ptr);
-    ~RGBController_CorsairKeyboard();
-
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        UpdateMode();
-
-private:
-    CorsairKeyboardController*   corsair;
-};

RGBController/RGBController_CorsairNodePro.cpp

@@ -19,145 +19,106 @@ RGBController_CorsairNodePro::RGBController_CorsairNodePro(CorsairNodeProControl
     type = DEVICE_TYPE_LEDSTRIP;
 
     mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0xFFFF;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name  = "Direct";
+    Direct.value = 0xFFFF;
+    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     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.color_mode = MODE_COLORS_NONE;
+    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;
     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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    ColorShift.colors_min = 2;
-    ColorShift.colors_max = 2;
+    ColorShift.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
     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_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);
+    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;
     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_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);
+    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;
     modes.push_back(ColorWave);
 
     mode Static;
-    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);
+    Static.name  = "Static";
+    Static.value = CORSAIR_CMDR_PRO_MODE_STATIC;
+    Static.flags = MODE_FLAG_HAS_COLOR;
     modes.push_back(Static);
 
     mode Temperature;
-    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);
+    Temperature.name  = "Temperature";
+    Temperature.value = CORSAIR_CMDR_PRO_MODE_TEMPERATURE;
+    Temperature.flags = MODE_FLAG_HAS_COLOR;
     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_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);
+    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;
     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_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);
+    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;
     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_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);
+    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;
     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_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);
+    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;
     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.color_mode = MODE_COLORS_NONE;
+    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;
     modes.push_back(Rainbow);
     
     /*-------------------------------------------------*\
@@ -279,7 +240,7 @@ void RGBController_CorsairNodePro::UpdateSingleLED(int led)
 
 void RGBController_CorsairNodePro::SetCustomMode()
 {
-    active_mode = 0;
+    SetMode(9);
 }
 
 void RGBController_CorsairNodePro::UpdateMode()
@@ -293,39 +254,23 @@ 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,
-                                      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]);
+                                      modes[active_mode].random,
+                                      RGBGetRValue(colors[0]),
+                                      RGBGetGValue(colors[0]),
+                                      RGBGetBValue(colors[0]),
+                                      RGBGetRValue(colors[1]),
+                                      RGBGetGValue(colors[1]),
+                                      RGBGetBValue(colors[1]));
         }
     }
-}
+}

RGBController/RGBController_CorsairNodePro.h

@@ -9,6 +9,7 @@
 
 #pragma once
 #include "RGBController.h"
+#include "serial_port.h"
 #include "CorsairNodeProController.h"
 
 class RGBController_CorsairNodePro : public RGBController

RGBController/RGBController_CorsairPro.cpp

@@ -49,129 +49,108 @@ 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_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);
+    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;
     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_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);
+    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;
     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.speed      = CORSAIR_PRO_SPEED_SLOW;
-    RainbowWave.direction  = MODE_DIRECTION_DOWN;
-    RainbowWave.color_mode = MODE_COLORS_NONE;
+    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;
     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_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);
+    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;
     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_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);
+    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;
     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_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);
+    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;
     modes.push_back(Rain);
 
     mode Marquee;
-    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);
+    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;
     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.speed      = CORSAIR_PRO_SPEED_SLOW;
-    Rainbow.color_mode = MODE_COLORS_NONE;
+    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;
     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_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);
+    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;
     modes.push_back(Sequential);
 
     mode Static;
-    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;
+    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;
     modes.push_back(Static);
 
     active_mode = 9;
@@ -206,14 +185,12 @@ RGBController_CorsairPro::RGBController_CorsairPro(CorsairProController* corsair
 
 void RGBController_CorsairPro::SetCustomMode()
 {
-    active_mode = 9;
+    SetMode(9);
 }
 
 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)
     {
@@ -237,28 +214,14 @@ 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,
-                       random,
-                       mode_colors[0],
-                       mode_colors[1],
-                       mode_colors[2],
-                       mode_colors[3],
-                       mode_colors[4],
-                       mode_colors[5]);
-}
+                       modes[active_mode].random,
+                       RGBGetRValue(colors[0]),
+                       RGBGetGValue(colors[0]),
+                       RGBGetBValue(colors[0]),
+                       RGBGetRValue(colors[1]),
+                       RGBGetGValue(colors[1]),
+                       RGBGetBValue(colors[1]));
+}

RGBController/RGBController_Crucial.cpp

@@ -1,160 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_Crucial.cpp                |
-|                                           |
-|  Generic RGB Interface for Crucial        |
-|  Ballistix RGB controller                 |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/19/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController_Crucial.h"
-
-void RGBController_Crucial::UpdateLEDs()
-{
-    if(modes[active_mode].value == 0xFFFF)
-    {
-        crucial->SetAllColorsDirect(&colors[0]);
-    }
-    else
-    {
-
-    }
-}
-
-void RGBController_Crucial::UpdateZoneLEDs(int zone)
-{
-    UpdateLEDs();
-}
-
-void RGBController_Crucial::UpdateSingleLED(int led)
-{
-    UpdateLEDs();
-}
-
-RGBController_Crucial::RGBController_Crucial(CrucialController * crucial_ptr)
-{
-    crucial = crucial_ptr;
-
-    location = crucial->GetDeviceLocation();
-    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      = 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.color_mode = MODE_COLORS_NONE;
-    modes.push_back(GradientShift);
-
-    mode Fill;
-    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.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Stack);
-
-    mode DoubleStack;
-    DoubleStack.name = "Double Stack";
-    DoubleStack.value = CRUCIAL_MODE_DOUBLE_STACK;
-    DoubleStack.flags = 0;
-    modes.push_back(DoubleStack);
-
-    mode Breathing;
-    Breathing.name = "Breathing";
-    Breathing.value = CRUCIAL_MODE_BREATHING;
-    Breathing.flags = 0;
-    modes.push_back(Breathing);
-
-    mode MotionPoint;
-    MotionPoint.name = "Motion Point";
-    MotionPoint.value = CRUCIAL_MODE_MOTION_POINT;
-    MotionPoint.flags = 0;
-    modes.push_back(MotionPoint);
-
-    mode InsideOut;
-    InsideOut.name = "Inside Out";
-    InsideOut.value = CRUCIAL_MODE_INSIDE_OUT;
-    InsideOut.flags = 0;
-    modes.push_back(InsideOut);
-
-    mode ColorStep;
-    ColorStep.name = "Color Step";
-    ColorStep.value = CRUCIAL_MODE_COLOR_STEP;
-    ColorStep.flags = 0;
-    modes.push_back(ColorStep);
-
-    mode WaterWave;
-    WaterWave.name = "Water Wave (Color Blending)";
-    WaterWave.value = CRUCIAL_MODE_WATER_WAVE;
-    WaterWave.flags = 0;
-    modes.push_back(WaterWave);
-
-    mode Flashing;
-    Flashing.name = "Flashing";
-    Flashing.value = CRUCIAL_MODE_FLASHING;
-    Flashing.flags = 0;
-    modes.push_back(Flashing);
-
-    mode Static;
-    Static.name = "Static";
-    Static.value = CRUCIAL_MODE_STATIC;
-    Static.flags = 0;
-    modes.push_back(Static);
-#endif
-
-    zone new_zone;
-    new_zone.name = "DRAM";
-    new_zone.type = ZONE_TYPE_LINEAR;
-    
-    std::vector<int> new_zone_map;
-
-    for(int led_idx = 0; led_idx < 8; led_idx++)
-    {
-        colors.push_back(0x00000000);
-
-        led new_led;
-        new_led.name = "DRAM LED";
-
-        leds.push_back(new_led);
-        new_zone_map.push_back(led_idx);
-    }
-
-    new_zone.map.push_back(new_zone_map);
-
-    zones.push_back(new_zone);
-}
-
-void RGBController_Crucial::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_Crucial::UpdateMode()
-{
-    crucial->SetMode(modes[active_mode].value);
-}

RGBController/RGBController_Crucial.h

@@ -1,28 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_Crucial.h                  |
-|                                           |
-|  Generic RGB Interface for Crucial        |
-|  Ballistix RGB controller                 |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/19/2020   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "CrucialController.h"
-
-class RGBController_Crucial : public RGBController
-{
-public:
-    RGBController_Crucial(CrucialController* crucial_ptr);
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        UpdateMode();
-
-private:
-    CrucialController*  crucial;
-};

RGBController/RGBController_Dummy.cpp

@@ -1,39 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_Dummy.cpp                  |
-|                                           |
-|  Generic RGB Interface Dummy Class        |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/25/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController_Dummy.h"
-
-RGBController_Dummy::RGBController_Dummy()
-{
-
-}
-
-void RGBController_Dummy::UpdateLEDs()
-{
-
-}
-
-void RGBController_Dummy::UpdateZoneLEDs(int zone)
-{
-
-}
-
-void RGBController_Dummy::UpdateSingleLED(int led)
-{
-
-}
-
-void RGBController_Dummy::SetCustomMode()
-{
-
-}
-
-void RGBController_Dummy::UpdateMode()
-{
-    
-}

RGBController/RGBController_Dummy.h

@@ -1,23 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_Dummy.h                    |
-|                                           |
-|  Generic RGB Interface Dummy Class        |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/25/2020   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-
-class RGBController_Dummy : public RGBController
-{
-public:
-    RGBController_Dummy();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        UpdateMode();
-};

RGBController/RGBController_E131.cpp

@@ -18,33 +18,22 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
     devices = device_list;
 
     unsigned int led_zone_idx = 0;
-
-    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);
+    mode led_mode;
+    led_mode.name = "Custom";
+    modes.push_back(led_mode);
 
     sockfd = e131_socket();
 
-    colors.resize(0);
-    
     for (std::size_t i = 0; i < devices.size(); i++)
     {
 		/*-----------------------------------------*\
 		| Add LEDs                                  |
         \*-----------------------------------------*/
-        colors.resize(colors.size() + devices[i].num_leds);
-
     	for (unsigned int led_idx = 0; led_idx < devices[i].num_leds; led_idx++)
     	{
-            char id_buf[16];
-            snprintf(id_buf, 16, "%d", led_idx);
-
+       		colors.push_back(0x00000000);
         	led new_led;
-        	new_led.name = devices[i].name + " LED ";
-            new_led.name.append(id_buf);
+        	new_led.name = devices[i].name + " LED";
         	leds.push_back(new_led);
 		}
 		
@@ -176,4 +165,4 @@ void RGBController_E131::SetCustomMode()
 void RGBController_E131::UpdateMode()
 {
 
-}
+}

RGBController/RGBController_Faustus.cpp

@@ -1,150 +0,0 @@
-#include "RGBController_Faustus.h"
-
-#include <dirent.h>
-#include <string.h>
-
-RGBController_Faustus::RGBController_Faustus(const std::string& dev_path)
-{
-    name = "Faustus";
-    description = "ASUS TUF Keyboard Backlight";
-    type = DEVICE_TYPE_KEYBOARD;
-
-    modes.resize(4);
-    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_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].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].color_mode = MODE_COLORS_NONE;
-    modes[3].speed      = FAUSTUS_SPEED_NORMAL;
-
-    colors.resize(1);
-    leds.resize(1);
-    leds[0].name = "Keyboard backlight LED";
-    zones.resize(1);
-    zones[0].type = ZONE_TYPE_SINGLE;
-    zones[0].name = "Keyboard backlight zone";
-    zones[0].map.push_back(std::vector<int>(1, 0));
-
-    // Prepare file streams
-    r_path = dev_path;
-    g_path = dev_path;
-    b_path = dev_path;
-    mode_path = dev_path;
-    flags_path = dev_path;
-    set_path = dev_path;
-
-    r_path.append("/kbbl_red");
-    g_path.append("/kbbl_green");
-    b_path.append("/kbbl_blue");
-    mode_path.append("/kbbl_mode");
-    flags_path.append("/kbbl_flags");
-    set_path.append("/kbbl_set");
-}
-
-void RGBController_Faustus::UpdateLEDs()
-{
-    int rv = uint8_t(RGBGetRValue(colors[0]));
-    int gv = uint8_t(RGBGetGValue(colors[0]));
-    int bv = uint8_t(RGBGetBValue(colors[0]));
-
-    std::ofstream str_r;
-    std::ofstream str_g;
-    std::ofstream str_b;
-    std::ofstream str_mode;
-    std::ofstream str_flags;
-    std::ofstream str_set;
-
-    str_r.open(r_path, std::ios::out | std::ios::trunc);
-    str_g.open(g_path, std::ios::out | std::ios::trunc);
-    str_b.open(b_path, std::ios::out | std::ios::trunc);
-    str_mode.open(mode_path, std::ios::out | std::ios::trunc);
-    str_flags.open(flags_path, std::ios::out | std::ios::trunc);
-    str_set.open(set_path, std::ios::out | std::ios::trunc);
-
-    str_r << std::hex;
-    str_g << std::hex;
-    str_b << std::hex;
-    str_mode << std::hex;
-    str_flags << std::hex;
-    str_set << std::hex;
-
-    str_r << rv;
-    str_g << gv;
-    str_b << bv;
-    str_mode << active_mode;
-    str_flags << 0x2a; // All of em
-    str_set << 2;
-
-    // Flush everything
-    str_r.close();
-    str_g.close();
-    str_b.close();
-    str_mode.close();
-    str_flags.close();
-    str_set.close();
-}
-
-void RGBController_Faustus::UpdateZoneLEDs(int zone)
-{
-    UpdateLEDs();
-}
-
-void RGBController_Faustus::UpdateSingleLED(int led)
-{
-    UpdateLEDs();
-}
-
-void RGBController_Faustus::SetCustomMode()
-{
-    SetMode(0);
-}
-
-void RGBController_Faustus::UpdateMode()
-{
-    UpdateLEDs();
-}
-
-void DetectFaustusControllers(std::vector<RGBController*> &rgb_controllers)
-{
-    const char* base_path = "/sys/devices/platform/faustus/kbbl";
-    DIR* dir = opendir(base_path);
-    if(!dir) return;
-    // Directory is present - we pretty much have a driver confirmation already, but double check for all files required just in case
-    struct dirent* dent = readdir(dir);
-    if(!dent) return;
-    int found = 0;
-    while(dent)
-    {
-        const char* fname = dent->d_name;
-        if(!strcmp(fname, "kbbl_red") || !strcmp(fname, "kbbl_green") || !strcmp(fname, "kbbl_blue") || !strcmp(fname, "kbbl_mode") || !strcmp(fname, "kbbl_flags") || !strcmp(fname, "kbbl_set"))
-        {
-            ++found;
-        }
-        dent = readdir(dir);
-    }
-    closedir(dir);
-    if(found != 6) return;
-    rgb_controllers.push_back(new RGBController_Faustus(base_path));
-}

RGBController/RGBController_Faustus.h

@@ -1,41 +0,0 @@
-#ifndef RGBCONTROLLER_FAUSTUS_H
-#define RGBCONTROLLER_FAUSTUS_H
-
-#include "RGBController.h"
-#include <fstream>
-
-enum
-{
-    FAUSTUS_MODE_STATIC      = 0,
-    FAUSTUS_MODE_BREATHING   = 1,
-    FAUSTUS_MODE_COLOR_CYCLE = 2,
-    FAUSTUS_MODE_STROBE      = 3
-};
-enum
-{
-    FAUSTUS_SPEED_SLOWEST = 0,
-    FAUSTUS_SPEED_NORMAL  = 1,
-    FAUSTUS_SPEED_FASTEST = 2,
-};
-
-class RGBController_Faustus : public RGBController
-{
-    private:
-        std::string r_path;
-        std::string g_path;
-        std::string b_path;
-        std::string mode_path;
-        std::string flags_path;
-        std::string set_path;
-
-    public:
-        RGBController_Faustus(const std::string& dev_path);
-        void        UpdateLEDs();
-        void        UpdateZoneLEDs(int zone);
-        void        UpdateSingleLED(int led);
-
-        void        SetCustomMode();
-        void        UpdateMode();
-};
-
-#endif // RGBCONTROLLER_FAUSTUS_H

RGBController/RGBController_Hue2.cpp

@@ -18,102 +18,76 @@ 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_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name  = "Direct";
+    Direct.value = HUE_2_MODE_FIXED;
+    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     modes.push_back(Direct);
 
     mode Fading;
-    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);
+    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;
     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.color_mode = MODE_COLORS_NONE;
+    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;
     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_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);
+    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;
     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_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);
+    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;
     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_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);
+    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;
     modes.push_back(Alternating);
 
     mode Pulsing;
-    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);
+    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;
     modes.push_back(Pulsing);
 
     mode Breathing;
-    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);
+    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;
     modes.push_back(Breathing);
 
     /*-------------------------------------------------*\
@@ -235,7 +209,7 @@ void RGBController_Hue2::UpdateSingleLED(int led)
 
 void RGBController_Hue2::SetCustomMode()
 {
-    active_mode = 0;
+    SetMode(0);
 }
 
 void RGBController_Hue2::UpdateMode()
@@ -264,22 +238,7 @@ void RGBController_Hue2::UpdateMode()
             }
 
             hue2->SetMode(modes[active_mode].value, modes[active_mode].speed, direction);
-
-            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);
-            }
+            hue2->SetChannelLEDs(channel, channel_colors);
         }
     }
-}
+}

RGBController/RGBController_Hue2.h

@@ -8,6 +8,7 @@
 
 #pragma once
 #include "RGBController.h"
+#include "serial_port.h"
 #include "Hue2Controller.h"
 
 class RGBController_Hue2 : public RGBController

RGBController/RGBController_HuePlus.cpp

@@ -20,143 +20,109 @@ 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_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name  = "Direct";
+    Direct.value = HUE_PLUS_MODE_FIXED;
+    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     modes.push_back(Direct);
 
-    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);
+// 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 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.color_mode = MODE_COLORS_NONE;
+    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;
     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_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);
+    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;
     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_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);
+    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;
     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_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);
+    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;
     modes.push_back(Alternating);
 
     mode Pulsing;
-    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);
+    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;
     modes.push_back(Pulsing);
 
     mode Breathing;
-    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);
+    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;
     modes.push_back(Breathing);
 
     mode Alert;
-    Alert.name       = "Alert";
-    Alert.value      = HUE_PLUS_MODE_ALERT;
-    Alert.flags      = 0;
-    Alert.color_mode = MODE_COLORS_NONE;
+    Alert.name  = "Alert";
+    Alert.value = HUE_PLUS_MODE_ALERT;
+    Alert.flags = 0;
     modes.push_back(Alert);
 
     mode Candlelight;
-    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);
+    Candlelight.name  = "Candlelight";
+    Candlelight.value = HUE_PLUS_MODE_CANDLELIGHT;
+    Candlelight.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     modes.push_back(Candlelight);
 
     mode Wings;
-    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);
+    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;
     modes.push_back(Wings);
 
-    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);
+// 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);
 
     /*-------------------------------------------------*\
     | Set size of colors array                          |
@@ -277,7 +243,7 @@ void RGBController_HuePlus::UpdateSingleLED(int led)
 
 void RGBController_HuePlus::SetCustomMode()
 {
-    active_mode = 0;
+    SetMode(0);
 }
 
 void RGBController_HuePlus::UpdateMode()
@@ -306,23 +272,7 @@ void RGBController_HuePlus::UpdateMode()
             }
 
             hueplus->SetMode(modes[active_mode].value, modes[active_mode].speed, direction);
-
-
-            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);
-            }
+            hueplus->SetChannelLEDs(channel, channel_colors);
         }
     }
-}
+}

RGBController/RGBController_HyperX.cpp

@@ -92,105 +92,83 @@ 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_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name  = "Direct";
+    Direct.value = HYPERX_MODE_DIRECT;
+    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     modes.push_back(Direct);
 
     mode Static;
-    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);
+    Static.name  = "Static";
+    Static.value = HYPERX_MODE_STATIC;
+    Static.flags = MODE_FLAG_HAS_COLOR;
     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.color_mode = MODE_COLORS_NONE;
+    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;
     modes.push_back(Rainbow);
 
     mode Comet;
-    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);
+    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;
     modes.push_back(Comet);
 
     mode Heartbeat;
-    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);
+    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;
     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.color_mode = MODE_COLORS_NONE;
+    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;
     modes.push_back(SpectrumCycle);
     
     mode Breathing;
-    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);
+    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;
     modes.push_back(Breathing);
 
     mode Bounce;
-    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);
+    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;
     modes.push_back(Bounce);
 
     mode Blink;
-    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);
+    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;
     modes.push_back(Blink);
 
     colors.resize(hyperx->GetLEDCount());
@@ -234,22 +212,11 @@ RGBController_HyperX::RGBController_HyperX(HyperXController* hyperx_ptr)
 
 void RGBController_HyperX::SetCustomMode()
 {
-    active_mode = 0;
+    SetMode(0);
 }
 
 void RGBController_HyperX::UpdateMode()
 {
-    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);
-    }
+    hyperx->SetMode(modes[active_mode].value, modes[active_mode].random, modes[active_mode].speed);
 }
 

RGBController/RGBController_HyperXKeyboard.cpp

@@ -1,271 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_HyperXKeyboard.cpp         |
-|                                           |
-|  Generic RGB Interface for HyperX RGB     |
-|  Keyboard                                 |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/2/2020    |
-\*-----------------------------------------*/
-
-#include "RGBController_HyperXKeyboard.h"
-
-static const char* zone_names[] =
-{
-    "Keyboard",
-    "RGB Strip",
-    "Media Keys"
-};
-
-static const unsigned int zone_sizes[] =
-{
-    104,
-    18,
-    4
-};
-
-static const char* led_names[] =
-{
-    "Key: Escape",
-    "Key: `",
-    "Key: Tab",
-    "Key: Caps Lock",
-    "Key: Left Shift",
-    "Key: Left Control",
-    "Key: F12",
-    "Key: =",
-    "Key: F9",
-    "Key: 9",
-    "Key: O",
-    "Key: L",
-    "Key: ,",
-    "Key: Context",
-    "Key: Left Arrow",
-    "Key: F1",
-    "Key: 1",
-    "Key: Q",
-    "Key: A",
-    "Key: Left Windows",
-    "Key: Print Screen",
-    "Key: F10",
-    "Key: 0",
-    "Key: P",
-    "Key: ;",
-    "Key: .",
-    "Key: Enter",
-    "Key: Down Arrow",
-    "Key: F2",
-    "Key: 2",
-    "Key: W",
-    "Key: S",
-    "Key: Z",
-    "Key: Left Alt",
-    "Key: Scroll Lock",
-    "Key: Backspace",
-    "Key: F11",
-    "Key: -",
-    "Key: [",
-    "Key: '",
-    "Key: /",
-    "Key: Right Arrow",
-    "Key: F3",
-    "Key: 3",
-    "Key: E",
-    "Key: D",
-    "Key: X",
-    "Key: Pause/Break",
-    "Key: Delete",
-    "Key: Number Pad 7",
-    "Key: Num Lock",
-    "Key: Number Pad 6",
-    "Key: F4",
-    "Key: 4",
-    "Key: R",
-    "Key: F",
-    "Key: C",
-    "Key: Space",
-    "Key: Insert",
-    "Key: End",
-    "Key: Number Pad 8",
-    "Key: Number Pad /",
-    "Key: Number Pad 1",
-    "Key: F5",
-    "Key: 5",
-    "Key: T",
-    "Key: G",
-    "Key: V",
-    "Key: Home",
-    "Key: Page Down",
-    "Key: Number Pad 9",
-    "Key: Number Pad *",
-    "Key: Number Pad 2",
-    "Key: F6",
-    "Key: 6",
-    "Key: Y",
-    "Key: H",
-    "Key: B",
-    "Key: Page Up",
-    "Key: Right Shift",
-    "Key: Number Pad -",
-    "Key: Number Pad 3",
-    "Key: F7",
-    "Key: 7",
-    "Key: U",
-    "Key: J",
-    "Key: N",
-    "Key: Right Alt",
-    "Key: ]",
-    "Key: Right Control",
-    "Key: Number Pad 4",
-    "Key: Number Pad +",
-    "Key: Number Pad 0",
-    "Key: F8",
-    "Key: 8",
-    "Key: I",
-    "Key: K",
-    "Key: M",
-    "Key: Right Windows",
-    "Key: \\",
-    "Key: Up Arrow",
-    "Key: Number Pad 5",
-    "Key: Number Pad Enter",
-    "Key: Number Pad .",
-    "RGB Strip 1",
-    "RGB Strip 2",
-    "RGB Strip 3",
-    "RGB Strip 4",
-    "RGB Strip 5",
-    "RGB Strip 6",
-    "RGB Strip 7",
-    "RGB Strip 8",
-    "RGB Strip 9",
-    "RGB Strip 10",
-    "RGB Strip 11",
-    "RGB Strip 12",
-    "RGB Strip 13",
-    "RGB Strip 14",
-    "RGB Strip 15",
-    "RGB Strip 16",
-    "RGB Strip 17",
-    "RGB Strip 18",
-    "Media Previous",
-    "Media Play/Pause",
-    "Media Next",
-    "Media Mute"
-};
-
-RGBController_HyperXKeyboard::RGBController_HyperXKeyboard(HyperXKeyboardController* hyperx_ptr)
-{
-    hyperx = hyperx_ptr;
-
-    name = "HyperX RGB Keyboard";
-    type = DEVICE_TYPE_KEYBOARD;
-
-    mode Direct;
-    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_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.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 | 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);
-
-    unsigned int led_idx = 0;
-    for(unsigned int zone_idx = 0; zone_idx < 3; zone_idx++)
-    {
-        zone new_zone;
-        new_zone.name.append(zone_names[zone_idx]);
-
-        std::vector<int> new_zone_map;
-
-        for(unsigned int led_count = 0; led_count < zone_sizes[zone_idx]; led_count++)
-        {
-            led new_led;
-            new_led.name.append(led_names[led_idx]);
-            leds.push_back(new_led);
-
-            new_zone_map.push_back(led_idx);
-
-            led_idx++;
-        }
-
-        new_zone.map.push_back(new_zone_map);
-
-        zones.push_back(new_zone);
-    }
-}
-
-RGBController_HyperXKeyboard::~RGBController_HyperXKeyboard()
-{
-
-}
-
-void RGBController_HyperXKeyboard::UpdateLEDs()
-{
-    if(active_mode == 0)
-    {
-        hyperx->SetLEDsDirect(colors);
-    }
-    else
-    {
-        hyperx->SetLEDs(colors);
-    }
-}
-
-void RGBController_HyperXKeyboard::UpdateZoneLEDs(int zone)
-{
-    UpdateLEDs();
-}
-
-void RGBController_HyperXKeyboard::UpdateSingleLED(int led)
-{
-    UpdateLEDs();
-}
-
-void RGBController_HyperXKeyboard::SetCustomMode()
-{
-    active_mode = 1;
-}
-
-void RGBController_HyperXKeyboard::UpdateMode()
-{
-    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_HyperXKeyboard.h

@@ -1,28 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_HyperXKeyboard.h           |
-|                                           |
-|  Generic RGB Interface for HyperX RGB     |
-|  Keyboard                                 |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/2/2020    |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "HyperXKeyboardController.h"
-
-class RGBController_HyperXKeyboard : public RGBController
-{
-public:
-    RGBController_HyperXKeyboard(HyperXKeyboardController* hyperx_ptr);
-    ~RGBController_HyperXKeyboard();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        UpdateMode();
-
-private:
-    HyperXKeyboardController*   hyperx;
-};

RGBController/RGBController_LEDStrip.cpp

@@ -18,24 +18,16 @@ RGBController_LEDStrip::RGBController_LEDStrip(LEDStripController* ledstrip_ptr)
 
     type = DEVICE_TYPE_LEDSTRIP;
 
-    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);
+    mode led_mode;
+    led_mode.name = "Custom";
+    modes.push_back(led_mode);
 
     colors.resize(strip->num_leds);
     
     for (int i = 0; i < strip->num_leds; i++)
     {
-        char id_buf[16];
-        snprintf(id_buf, 16, "%d", i);
-
         led new_led;
-        new_led.name = "LED ";
-        new_led.name.append(id_buf);
-        
+        new_led.name = "LED Strip";
         leds.push_back(new_led);
     }
 
@@ -73,4 +65,4 @@ void RGBController_LEDStrip::SetCustomMode()
 void RGBController_LEDStrip::UpdateMode()
 {
 
-}
+}

RGBController/RGBController_MSI3Zone.cpp

@@ -16,12 +16,9 @@ RGBController_MSI3Zone::RGBController_MSI3Zone(MSI3ZoneController* msi_ptr)
     name = "MSI 3-Zone Keyboard";
     type = DEVICE_TYPE_KEYBOARD;
 
-    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);
+    mode led_mode;
+    led_mode.name = "Custom";
+    modes.push_back(led_mode);
 
     led left_led;
     left_led.name = "Keyboard Left";
@@ -90,4 +87,4 @@ void RGBController_MSI3Zone::SetCustomMode()
 void RGBController_MSI3Zone::UpdateMode()
 {
 
-}
+}

RGBController/RGBController_MSIRGB.cpp

@@ -1,75 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_MSIRGB.cpp                 |
-|                                           |
-|  Generic RGB Interface for MSI-RGB        |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/14/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController_MSIRGB.h"
-
-RGBController_MSIRGB::RGBController_MSIRGB(MSIRGBController* msi_ptr)
-{
-    msi = msi_ptr;
-
-    name = "MSI Motherboard";
-    description = "MSI-RGB Device";
-
-    type = DEVICE_TYPE_MOTHERBOARD;
-    
-    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 msi_led;
-    msi_led.name = "MSI LED";
-    leds.push_back(msi_led);
-
-    zone msi_zone;
-    msi_zone.name = "MSI Zone";
-    msi_zone.type = ZONE_TYPE_SINGLE;
-    std::vector<int> msi_zone_map;
-    msi_zone_map.push_back(0);
-    msi_zone.map.push_back(msi_zone_map);
-    zones.push_back(msi_zone);
-
-    colors.push_back(0x00000000);
-}
-
-RGBController_MSIRGB::~RGBController_MSIRGB()
-{
-
-}
-
-void RGBController_MSIRGB::UpdateLEDs()
-{
-    RGBColor      color = colors[0];
-    unsigned char red   = RGBGetRValue(color);
-    unsigned char grn   = RGBGetGValue(color);
-    unsigned char blu   = RGBGetBValue(color);
-
-    msi->SetColor(red, grn, blu);
-}
-
-void RGBController_MSIRGB::UpdateZoneLEDs(int zone)
-{
-    UpdateLEDs();
-}
-
-void RGBController_MSIRGB::UpdateSingleLED(int led)
-{
-    UpdateLEDs();
-}
-
-void RGBController_MSIRGB::SetCustomMode()
-{
-
-}
-
-void RGBController_MSIRGB::UpdateMode()
-{
-
-}

RGBController/RGBController_MSIRGB.h

@@ -1,27 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_MSIRGB.h                   |
-|                                           |
-|  Generic RGB Interface for MSI-RGB        |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/14/2020   |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "MSIRGBController.h"
-
-class RGBController_MSIRGB : public RGBController
-{
-public:
-    RGBController_MSIRGB(MSIRGBController* msi_ptr);
-    ~RGBController_MSIRGB();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        UpdateMode();
-
-private:
-    MSIRGBController*       msi;
-};

RGBController/RGBController_OpenRazer.cpp

@@ -12,6 +12,7 @@
 #include <fstream>
 #include <unistd.h>
 
+
 void RGBController_OpenRazer::UpdateLEDs()
 {
     switch(matrix_type)
@@ -80,7 +81,7 @@ void RGBController_OpenRazer::UpdateLEDs()
                 }
             }
             break;
-#if 0
+        
         case RAZER_TYPE_NOMATRIX:
             {
                 unsigned int output_array_size = 3;
@@ -106,7 +107,6 @@ void RGBController_OpenRazer::UpdateLEDs()
                 scroll_led_effect.flush();
             }
             break;
-#endif
     }
 }
 
@@ -120,8 +120,59 @@ 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)
@@ -147,60 +198,27 @@ 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_index = -1;
+    device = -1;
 
     /*-----------------------------------------------------------------*\
     | Get the device name from the OpenRazer driver                     |
     \*-----------------------------------------------------------------*/
-    std::getline(device_type, name);
+    name = GetDeviceTypeString(dev_path);
 
     /*-----------------------------------------------------------------*\
     | Set the description to indicate this is an OpenRazer device       |
@@ -215,12 +233,12 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
     /*-----------------------------------------------------------------*\
     | Get the serial number from the dev path                           |
     \*-----------------------------------------------------------------*/
-    std::getline(device_serial, serial);
+    serial = GetSerialNumberString(dev_path);
 
     /*-----------------------------------------------------------------*\
     | Get the firmware version from the dev path                        |
     \*-----------------------------------------------------------------*/
-    std::getline(firmware_version, version);
+    version = GetFirmwareVersionString(dev_path);
 
     /*-----------------------------------------------------------------*\
     | Loop through all known devices to look for a name match           |
@@ -232,7 +250,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
             /*---------------------------------------------------------*\
             | Set device ID                                             |
             \*---------------------------------------------------------*/
-            device_index = i;
+            device = i;
 
             /*---------------------------------------------------------*\
             | Set device type                                           |
@@ -242,81 +260,19 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
             /*---------------------------------------------------------*\
             | Initialize modes                                          |
             \*---------------------------------------------------------*/
-            if(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);
-            }
+            mode razer_modes[RAZER_NUM_MODES];
 
-            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);
-            }
+            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";
 
-            if(matrix_effect_static)
+            for (int i = 0; i < RAZER_NUM_MODES; i++)
             {
-                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);
+                modes.push_back(razer_modes[i]);
             }
             
             /*---------------------------------------------------------*\
@@ -348,15 +304,11 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
 
                         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);
+                            new_led->name = device_list[i]->zones[zone_id]->name;
                             leds.push_back(*new_led);
 
                             new_zone_map.push_back(led_count);
@@ -375,99 +327,54 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
 
 void RGBController_OpenRazer::SetCustomMode()
 {
-    active_mode = RAZER_MODE_CUSTOM;
+    SetMode(RAZER_MODE_CUSTOM);
 }
 
 void RGBController_OpenRazer::UpdateMode()
 {
-    char update_value[6];
-
-    update_value[0] = 1;
+    char update_value = 1;
 
     switch(matrix_type)
     {
         case RAZER_TYPE_MATRIX_FRAME:
         case RAZER_TYPE_MATRIX_NOFRAME:
             {
-                switch(modes[active_mode].value)
+                switch(active_mode)
                 {
                     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:
-                        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.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)
@@ -489,6 +396,5 @@ void RGBController_OpenRazer::UpdateMode()
                         break;
                 }
             }
-#endif
     }
-}
+}

RGBController/RGBController_OpenRazer.h

@@ -10,10 +10,890 @@
 #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:
@@ -47,7 +927,7 @@ public:
     void        SetCustomMode();
     void        UpdateMode();
 
-    int device_index;
+    int device;
 
 private:
     void SetupMatrixDevice(std::string dev_path, unsigned int rows, unsigned int cols);
@@ -57,35 +937,19 @@ private:
     unsigned int matrix_rows;
     unsigned int matrix_cols;
 
-    void OpenFunctions(std::string dev_path);
-
-    std::ifstream device_type;
-    std::ifstream device_serial;
-    std::ifstream firmware_version;
-
+    //OpenRazer Sysfs Entries for Matrix Devices
     std::ofstream matrix_custom_frame;
-    std::ofstream matrix_brightness;
-
     std::ofstream matrix_effect_custom;
-    std::ofstream matrix_effect_none;
-    std::ofstream matrix_effect_static;
     std::ofstream matrix_effect_breath;
-    std::ofstream matrix_effect_spectrum;
+    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;
 
-    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;
-
+    //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_OpenRazerWindows.cpp

@@ -1,476 +0,0 @@
-/*-----------------------------------------*\
-|  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

@@ -1,112 +0,0 @@
-/*-----------------------------------------*\
-|  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_PER_LED_COLOR;
-    Direct.speed_min  = 0;
-    Direct.speed_max  = 0;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    Direct.speed      = 0;
+    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;
     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.color_mode = MODE_COLORS_NONE;
-    Dark.speed      = 0;
+    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;
     modes.push_back(Dark);
 
     mode Breathing;
-    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;
+    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;
     modes.push_back(Breathing);
 
     mode Viper;
-    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;
+    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;
     modes.push_back(Viper);
 
     mode Heartbeat;
-    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;
+    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;
     modes.push_back(Heartbeat);
 
     mode Marquee;
-    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;
+    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;
     modes.push_back(Marquee);
 
     mode Raindrop;
-    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;
+    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;
     modes.push_back(Raindrop);
 
     mode Aurora;
-    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;
+    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;
     modes.push_back(Aurora);
 
     colors.resize(viper->GetLEDCount());
@@ -186,7 +186,7 @@ RGBController_PatriotViper::RGBController_PatriotViper(PatriotViperController* v
 
 void RGBController_PatriotViper::SetCustomMode()
 {
-    active_mode = 0;
+    SetMode(0);
 }
 
 void RGBController_PatriotViper::UpdateMode()
@@ -199,4 +199,4 @@ void RGBController_PatriotViper::UpdateMode()
     {
         viper->SetMode(modes[active_mode].value, modes[active_mode].speed);
     }
-}
+}

RGBController/RGBController_Polychrome.cpp

@@ -18,7 +18,7 @@ void RGBController_Polychrome::UpdateLEDs()
         unsigned char grn = RGBGetGValue(colors[led]);
         unsigned char blu = RGBGetBValue(colors[led]);
 
-        polychrome->SetColor(red, grn, blu);
+        polychrome->SetLEDColor(led, red, grn, blu);
     }
 }
 
@@ -43,163 +43,15 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
 
     name = polychrome->GetDeviceName();
 
-    if(polychrome->IsAsrLed())
+    mode polychrome_modes[POLYCHROME_NUM_MODES];
+
+    polychrome_modes[0].name = "Static";
+    polychrome_modes[1].name = "Breathing";
+    polychrome_modes[2].name = "Flashing";
+
+    for (int i = 0; i < POLYCHROME_NUM_MODES; i++)
     {
-        mode Off;
-        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_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_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_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.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.color_mode = MODE_COLORS_NONE;
-        modes.push_back(Random);
-        
-        mode Music;
-        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.color_mode = MODE_COLORS_NONE;
-        modes.push_back(Wave);
-    }
-    else
-    {
-        mode Off;
-        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_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_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_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.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.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.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.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.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.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.color_mode = MODE_COLORS_NONE;
-        modes.push_back(Scan);
-
-        mode Neon;
-        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.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.color_mode = MODE_COLORS_NONE;
-        modes.push_back(Rainbow);
+        modes.push_back(polychrome_modes[i]);
     }
 
     colors.resize(polychrome->GetLEDCount());
@@ -232,10 +84,10 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
 
 void RGBController_Polychrome::SetCustomMode()
 {
-    active_mode = 1;
+    SetMode(0);
 }
 
 void RGBController_Polychrome::UpdateMode()
 {
-    polychrome->SetMode(modes[active_mode].value);
-}
+    polychrome->SetMode(active_mode);
+}

RGBController/RGBController_PoseidonZRGB.cpp

@@ -9,124 +9,6 @@
 
 #include "RGBController_PoseidonZRGB.h"
 
-static const char* zone_names[] =
-{
-    "Keyboard"
-};
-
-static const unsigned int zone_sizes[] =
-{
-    104
-};
-
-static const char* led_names[] =
-{
-    "Key: Escape",
-    "Key: `",
-    "Key: Tab",
-    "Key: Caps Lock",
-    "Key: Left Shift",
-    "Key: Left Control",
-    "Key: Left Arrow",
-    "Key: Insert",
-    "Key: F1",
-    "Key: 1",
-    "Key: Q",
-    "Key: A",
-    "Key: Windows",
-    "Key: Down Arrow",
-    "Key: Delete",
-    "Key: F2",
-    "Key: 2",
-    "Key: W",
-    "Key: S",
-    "Key: Left Alt",
-    "Key: Right Arrow",
-    "Key: Home",
-    "Key: F3",
-    "Key: 3",
-    "Key: E",
-    "Key: D",
-    "Key: Z",
-    "Key: Up Arrow",
-    "Key: End",
-    "Key: F4",
-    "Key: 4",
-    "Key: R",
-    "Key: F",
-    "Key: X",
-    "Key: Space",
-    "Key: Number Pad 4",
-    "Key: Page Up",
-    "Key: F5",
-    "Key: 5",
-    "Key: T",
-    "Key: G",
-    "Key: C",
-    "Key: Number Pad 1",
-    "Key: Page Down",
-    "Key: F6",
-    "Key: 6",
-    "Key: Y",
-    "Key: H",
-    "Key: V",
-    "Key: Number Pad 2",
-    "Key: Num Lock",
-    "Key: F7",
-    "Key: 7",
-    "Key: U",
-    "Key: J",
-    "Key: B",
-    "Key: Number Pad 0",
-    "Key: Number Pad 7",
-    "Key: F8",
-    "Key: 8",
-    "Key: I",
-    "Key: K",
-    "Key: N",
-    "Key: Number Pad 6",
-    "Key: Number Pad /",
-    "Key: F9",
-    "Key: 9",
-    "Key: O",
-    "Key: L",
-    "Key: M",
-    "Key: Right Alt",
-    "Key: Number Pad 3",
-    "Key: Number Pad 8",
-    "Key: F10",
-    "Key: 0",
-    "Key: P",
-    "Key: ;",
-    "Key: ,",
-    "Key: Fn",
-    "Key: Number Pad .",
-    "Key: Number Pad *",
-    "Key: F11",
-    "Key: -",
-    "Key: [",
-    "Key: '",
-    "Key: .",
-    "Key: Number Pad +",
-    "Key: Number Pad 9",
-    "Key: F12",
-    "Key: =",
-    "Key: ]",
-    "Key: /",
-    "Key: Context",
-    "Key: Number Pad -",
-    "Key: Print Screen",
-    "Key: \\",
-    "Key: Enter",
-    "Key: Right Control",
-    "Key: Number Pad Enter",
-    "Key: Number Pad 5",
-    "Key: Scroll Lock",
-    "Key: Right Shift",
-    "Key: Pause/Break",
-    "Key: Backspace"
-};
-
 RGBController_PoseidonZRGB::RGBController_PoseidonZRGB(PoseidonZRGBController* poseidon_ptr)
 {
     poseidon = poseidon_ptr;
@@ -134,69 +16,9 @@ RGBController_PoseidonZRGB::RGBController_PoseidonZRGB(PoseidonZRGBController* p
     name = "Thermaltake Poseidon Z RGB";
     type = DEVICE_TYPE_KEYBOARD;
 
-    mode Direct;
-    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_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.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.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Ripple);
-
-    mode Reactive;
-    Reactive.name       = "Reactive";
-    Reactive.value      = POSEIDONZ_MODE_REACTIVE;
-    Reactive.flags      = 0;
-    Reactive.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Reactive);
-
-    colors.resize(104);
-
-    unsigned int led_idx = 0;
-    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
+    for(int i = 0; i < 104; i++)
     {
-        zone new_zone;
-        new_zone.name.append(zone_names[zone_idx]);
-
-        std::vector<int> new_zone_map;
-
-        for(unsigned int led_count = 0; led_count < zone_sizes[zone_idx]; led_count++)
-        {
-            led new_led;
-            new_led.name.append(led_names[led_idx]);
-            leds.push_back(new_led);
-
-            new_zone_map.push_back(led_idx);
-
-            led_idx++;
-        }
-
-        new_zone.map.push_back(new_zone_map);
-
-        zones.push_back(new_zone);
+        colors.push_back(0x00000000);
     }
 }
 
@@ -207,32 +29,25 @@ RGBController_PoseidonZRGB::~RGBController_PoseidonZRGB()
 
 void RGBController_PoseidonZRGB::UpdateLEDs()
 {
-    if(active_mode == 0)
-    {
-        poseidon->SetLEDsDirect(colors);
-    }
-    else
-    {
-        poseidon->SetLEDs(colors);
-    }
+    poseidon->SetLEDs(colors);
 }
 
 void RGBController_PoseidonZRGB::UpdateZoneLEDs(int zone)
 {
-    UpdateLEDs();
+    poseidon->SetLEDs(colors);
 }
 
 void RGBController_PoseidonZRGB::UpdateSingleLED(int led)
 {
-    UpdateLEDs();
+    poseidon->SetLEDs(colors);
 }
 
 void RGBController_PoseidonZRGB::SetCustomMode()
 {
-    active_mode = 0;
+
 }
 
 void RGBController_PoseidonZRGB::UpdateMode()
 {
-    poseidon->SetMode(modes[active_mode].value, modes[active_mode].direction, modes[active_mode].speed);
-}
+
+}

RGBController/RGBController_RGBFusion.cpp

@@ -55,30 +55,27 @@ 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_PER_LED_COLOR;
-    Static.color_mode = MODE_COLORS_PER_LED;
+    Static.name  = "Static";
+    Static.value = RGB_FUSION_MODE_STATIC;
+    Static.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     modes.push_back(Static);
 
     mode Breathing;
-    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;
+    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;
     modes.push_back(Breathing);
 
     mode Flashing;
-    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;
+    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;
     modes.push_back(Flashing);
 
     colors.resize(rgb_fusion->GetLEDCount());
@@ -129,10 +126,10 @@ int RGBController_RGBFusion::GetDeviceMode()
 
 void RGBController_RGBFusion::SetCustomMode()
 {
-    active_mode = 0;
+    rgb_fusion->SetMode(RGB_FUSION_MODE_STATIC, 0);
 }
 
 void RGBController_RGBFusion::UpdateMode()
 {
     rgb_fusion->SetMode(modes[active_mode].value, modes[active_mode].speed);
-}
+}

RGBController/RGBController_RGBFusion2.cpp

@@ -1,289 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_RGBFusion2.cpp             |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  Gigabyte RGB Fusion 2.0 Driver           |
-|                                           |
-|  jackun 1/8/2020                          |
-\*-----------------------------------------*/
-
-#include "RGBController_RGBFusion2.h"
-#include <sstream>
-#include <array>
-
-enum
-{
-    ZONE_MB,
-    ZONE_STRIP1,
-    ZONE_STRIP2,
-};
-
-static const std::array<const char *, 3> led_zones
-{
-    "Motherboard",
-    "LED Strip 1", // WS2812(B) strips
-    "LED Strip 2",
-};
-
-static const KnownChannels known_channels
-{
-    {
-        "Generic",
-        {
-            {
-                { "Led 1", 0x20 },
-                { "Led 2", 0x21 },
-                { "Led 3", 0x22 },
-                { "Led 4", 0x23 },
-                { "Led 5", 0x24 },
-                { "Led 6", 0x25 },
-                { "Led 7", 0x26 },
-                { "Led 8", 0x27 },
-            },
-            // Zone 1
-            {
-                { "LED Strip 1, LED 0", HDR_D_LED1 },
-            },
-            // Zone 2
-            {
-                { "LED Strip 2, LED 0", HDR_D_LED2 },
-            }
-        }
-    },
-    {
-        "IT8297BX-GBX570",
-        {
-            // Zone 0
-            {
-                { "Back I/O",   HDR_BACK_IO },
-                { "CPU",        HDR_CPU },
-                { "PCIe",       HDR_PCIE },
-                { "LED C1/C2",  HDR_LED_C1C2 }, // 12VGRB headers seem to be connected
-            },
-            // Zone 1
-            {
-                { "LED Strip 1, LED 0", HDR_D_LED1 },
-            },
-            // Zone 2
-            {
-                { "LED Strip 2, LED 0", HDR_D_LED2 },
-            }
-        }
-    },
-};
-
-RGBController_RGBFusion2::RGBController_RGBFusion2(RGBFusion2Controller* controller_ptr)
-{
-    controller = controller_ptr;
-
-    name = "RGB Fusion 2 Controller";
-    type = DEVICE_TYPE_MOTHERBOARD;
-    description = controller->GetDeviceName();
-    version     = controller->GetFWVersion();
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerial();
-
-    auto it = known_channels.find(controller->GetDeviceName());
-    if (it == known_channels.end())
-    {
-        it = known_channels.find("Generic");
-    }
-
-    size_t mb_led_cnt = it->second[0].size();
-
-    mode Static;
-    Static.name       = "Static";
-    Static.value      = EFFECT_STATIC;
-    Static.flags      = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = EFFECT_PULSE;
-    Breathing.flags      = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Breathing.speed_min  = 0;
-    Breathing.speed_max  = 4;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    Breathing.speed      = 2;
-    modes.push_back(Breathing);
-
-    mode Blinking;
-    Blinking.name       = "Blinking";
-    Blinking.value      = EFFECT_BLINKING;
-    Blinking.flags      = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Blinking.speed_min  = 0;
-    Blinking.speed_max  = 4;
-    Blinking.color_mode = MODE_COLORS_PER_LED;
-    Blinking.speed      = 2;
-    modes.push_back(Blinking);
-
-    mode ColorCycle;
-    ColorCycle.name       = "Color Cycle";
-    ColorCycle.value      = EFFECT_COLORCYCLE;
-    ColorCycle.flags      = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    ColorCycle.speed_min  = 0;
-    ColorCycle.speed_max  = 4;
-    ColorCycle.color_mode = MODE_COLORS_NONE;
-    ColorCycle.speed      = 2;
-    modes.push_back(ColorCycle);
-
-    mode Flashing;
-    Flashing.name       = "Flashing";
-    Flashing.value      = 10;
-    Flashing.flags      = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Flashing.speed_min  = 0;
-    Flashing.speed_max  = 4;
-    Flashing.color_mode = MODE_COLORS_PER_LED;
-    Flashing.speed      = 2;
-    modes.push_back(Flashing);
-
-    per_strip_led_cnt = 64; // TODO needs GUI option
-    colors.resize(mb_led_cnt + per_strip_led_cnt * 2, 0x000021FF);
-    controller->SetLedCount(per_strip_led_cnt);
-    controller->DisableBuiltinEffect(0, 0x3);
-
-    unsigned int led_idx = 0;
-    std::stringstream ss;
-
-    for(size_t i = 0; i < led_zones.size(); i++)
-    {
-        std::vector<int> new_zone_map;
-        zone new_zone;
-        new_zone.name = led_zones[i];
-        new_zone.type = ZONE_TYPE_LINEAR; // TODO
-
-        unsigned int zone_led_cnt = mb_led_cnt;
-        if( i > 0 )
-        {
-            zone_led_cnt = per_strip_led_cnt;
-        }
-
-        for(unsigned int zone_led_idx = 0; zone_led_idx < zone_led_cnt; zone_led_idx++)
-        {
-            led new_led;
-
-            if( it != known_channels.end() && i < it->second.size() && zone_led_idx < it->second[i].size())
-            {
-                new_led.name = it->second[i][zone_led_idx].name;
-            }
-            else
-            {
-                ss.clear(); ss.str("");
-                ss << led_zones[i];
-                if (zone_led_cnt > 1)
-                {
-                    ss << ", LED " << zone_led_idx;
-                }
-                new_led.name = ss.str();
-            }
-
-            leds.push_back(new_led);
-            new_zone_map.push_back(led_idx);
-            led_idx++;
-        }
-
-        new_zone.map.push_back(new_zone_map);
-        zones.push_back(new_zone);
-    }
-}
-
-void RGBController_RGBFusion2::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_RGBFusion2::UpdateLEDs()
-{
-    for(size_t i = 0; i < led_zones.size(); i++)
-    {
-        UpdateZoneLEDs(i);
-    }
-}
-
-void RGBController_RGBFusion2::UpdateZoneLEDs(int zone)
-{
-    bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-
-    auto it = known_channels.find(controller->GetDeviceName());
-
-    if (it == known_channels.end())
-    {
-        it = known_channels.find("Generic");
-    }
-
-    if (it == known_channels.end() || zone >= (int)it->second.size())
-    {
-        return;
-    }
-
-    if(zone == ZONE_MB)
-    {
-        std::vector<int>& leds = zones[zone].map[0];
-
-        for(size_t i = 0; i < leds.size(); i++)
-        {
-            unsigned char red = RGBGetRValue(colors[leds[i]]);
-            unsigned char grn = RGBGetGValue(colors[leds[i]]);
-            unsigned char blu = RGBGetBValue(colors[leds[i]]);
-
-            controller->SetLEDEffect(it->second[zone][i].header, modes[active_mode].value, modes[active_mode].speed, random, red, grn, blu);
-        }
-        
-        controller->ApplyEffect();
-    }
-    else // assuming other two zones are LED strips
-    {
-        int led = zones[zone].map[0][0];
-        unsigned char red = RGBGetRValue(colors[led]);
-        unsigned char grn = RGBGetGValue(colors[led]);
-        unsigned char blu = RGBGetBValue(colors[led]);
-
-        int hdr = it->second[zone].size() ? it->second[zone].front().header : led;
-
-        // apply built-in effects to LED strips
-        controller->DisableBuiltinEffect(0, zone == 1 ? 0x01 : 0x02);
-        controller->SetLEDEffect(hdr, modes[active_mode].value, modes[active_mode].speed, random, red, grn, blu);
-        controller->ApplyEffect();
-    }
-}
-
-void RGBController_RGBFusion2::UpdateSingleLED(int led)
-{
-    bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-
-    if (led >= zones[ZONE_STRIP1].map[0].front() && led <= zones[ZONE_STRIP1].map[0].back())
-    {
-        controller->SetStripColors(HDR_D_LED1_RGB,
-                zones[ZONE_STRIP1].map[0].front(),
-                zones[ZONE_STRIP1].map[0].back(),
-                colors, led);
-    }
-    else if (led >= zones[ZONE_STRIP2].map[0].front() && led <= zones[ZONE_STRIP2].map[0].back())
-    {
-        controller->SetStripColors(HDR_D_LED2_RGB,
-               zones[ZONE_STRIP2].map[0].front(),
-               zones[ZONE_STRIP2].map[0].back(),
-               colors, led);
-    }
-    else
-    {
-        int header = led;
-        auto it = known_channels.find(controller->GetDeviceName());
-        if (it == known_channels.end() || it->second.size() == 0)
-            header = it->second[ZONE_MB][led].header;
-
-        unsigned char red = RGBGetRValue(colors[led]);
-        unsigned char grn = RGBGetGValue(colors[led]);
-        unsigned char blu = RGBGetBValue(colors[led]);
-
-        controller->SetLEDEffect(header, modes[active_mode].value, modes[active_mode].speed, random, red, grn, blu);
-        controller->ApplyEffect();
-    }
-}
-
-void RGBController_RGBFusion2::UpdateMode()
-{
-    // XXX Comment out to allow each zone or motherboard LED have different modes
-    UpdateLEDs();
-}

RGBController/RGBController_RGBFusion2.h

@@ -1,39 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_RGBFusion2.h               |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  Gigabyte RGB Fusion 2.0 Driver           |
-|                                           |
-|  jackun 1/8/2020                          |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "RGBFusion2Controller.h"
-#include <map>
-#include <vector>
-
-struct LedPort
-{
-    const char* name;
-    int header;
-};
-
-typedef std::vector< std::vector<LedPort> > ZoneLeds;
-typedef std::map< std::string, ZoneLeds > KnownChannels;
-
-class RGBController_RGBFusion2: public RGBController
-{
-public:
-    RGBController_RGBFusion2(RGBFusion2Controller* controller_ptr);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-    void        UpdateMode();
-
-private:
-    RGBFusion2Controller*       controller;
-    IT8297Report                report;
-    unsigned int                per_strip_led_cnt;
-};

RGBController/RGBController_RGBFusionGPU.cpp

@@ -1,125 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_RGBFusionGPU.cpp           |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  Gigabyte RGB Fusion GPU Driver           |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/23/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController_RGBFusionGPU.h"
-
-
-void RGBController_RGBFusionGPU::UpdateLEDs()
-{
-    RGBColor      color = colors[0];
-    unsigned char red   = RGBGetRValue(color);
-    unsigned char grn   = RGBGetGValue(color);
-    unsigned char blu   = RGBGetBValue(color);
-
-    rgb_fusion->SetColor(red, grn, blu);
-}
-
-void RGBController_RGBFusionGPU::UpdateZoneLEDs(int zone)
-{
-    UpdateLEDs();
-}
-
-void RGBController_RGBFusionGPU::UpdateSingleLED(int led)
-{
-    UpdateLEDs();
-}
-
-RGBController_RGBFusionGPU::RGBController_RGBFusionGPU(RGBFusionGPUController* rgb_fusion_ptr)
-{
-    rgb_fusion = rgb_fusion_ptr;
-
-    name = "Gigabyte GPU";
-    description = "RGB Fusion GPU";
-    location = rgb_fusion->GetDeviceLocation();
-
-    type = DEVICE_TYPE_GPU;
-
-    mode Static;
-    Static.name       = "Static";
-    Static.value      = RGB_FUSION_GPU_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_GPU_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.speed_min  = RGB_FUSION_GPU_SPEED_SLOWEST;
-    Breathing.speed_max  = RGB_FUSION_GPU_SPEED_FASTEST;
-    Breathing.speed      = RGB_FUSION_GPU_SPEED_NORMAL;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Breathing);
-
-    mode Flashing;
-    Flashing.name       = "Flashing";
-    Flashing.value      = RGB_FUSION_GPU_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    Flashing.speed_min  = RGB_FUSION_GPU_SPEED_SLOWEST;
-    Flashing.speed_max  = RGB_FUSION_GPU_SPEED_FASTEST;
-    Flashing.speed      = RGB_FUSION_GPU_SPEED_NORMAL;
-    Flashing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Flashing);
-
-    mode DualFlashing;
-    DualFlashing.name       = "Dual Flashing";
-    DualFlashing.value      = RGB_FUSION_GPU_MODE_DUAL_FLASHING;
-    DualFlashing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    DualFlashing.speed_min  = RGB_FUSION_GPU_SPEED_SLOWEST;
-    DualFlashing.speed_max  = RGB_FUSION_GPU_SPEED_FASTEST;
-    DualFlashing.speed      = RGB_FUSION_GPU_SPEED_NORMAL;
-    DualFlashing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(DualFlashing);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name       = "Spectrum Cycle";
-    SpectrumCycle.value      = RGB_FUSION_GPU_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED;
-    SpectrumCycle.speed_min  = RGB_FUSION_GPU_SPEED_SLOWEST;
-    SpectrumCycle.speed_max  = RGB_FUSION_GPU_SPEED_FASTEST;
-    SpectrumCycle.speed      = RGB_FUSION_GPU_SPEED_NORMAL;
-    SpectrumCycle.color_mode = MODE_COLORS_NONE;
-    modes.push_back(SpectrumCycle);
-
-    colors.resize(1);
-
-    zone* new_zone = new zone();
-    led*  new_led  = new led();
-
-    std::vector<int>* zone_row = new std::vector<int>();
-
-    // Set zone name to channel name
-    new_zone->name = "GPU Zone";
-    new_led->name  = "GPU LED";
-
-    zone_row->push_back(0);
-
-    // Aura devices can be either single or linear, never matrix
-    // That means only one row is needed
-    new_zone->map.push_back(*zone_row);
-
-    // Push new LED to LEDs vector
-    leds.push_back(*new_led);
-
-    // Push new zone to zones vector
-    zones.push_back(*new_zone);
-
-    // Initialize active mode
-    active_mode = 0;
-}
-
-void RGBController_RGBFusionGPU::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_RGBFusionGPU::UpdateMode()
-{
-    rgb_fusion->SetMode(modes[active_mode].value, modes[active_mode].speed);
-}

RGBController/RGBController_RGBFusionGPU.h

@@ -1,28 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_RGBFusionGPU.h             |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  Gigabyte RGB Fusion GPU Driver           |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/23/2020   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "RGBFusionGPUController.h"
-
-class RGBController_RGBFusionGPU : public RGBController
-{
-public:
-    RGBController_RGBFusionGPU(RGBFusionGPUController* rgb_fusion_ptr);
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        UpdateMode();
-
-private:
-    RGBFusionGPUController* rgb_fusion;
-};

RGBController/RGBController_RazerChromaSDK.cpp

@@ -0,0 +1,166 @@
+/*-----------------------------------------*\
+|  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

@@ -0,0 +1,248 @@
+/*-----------------------------------------*\
+|  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

@@ -1,248 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_ThermaltakeRiing.cpp       |
-|                                           |
-|  Generic RGB Interface for Thermaltake    |
-|  Riing controller                         |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/9/2020    |
-\*-----------------------------------------*/
-
-#include "RGBController_ThermaltakeRiing.h"
-
-
-RGBController_ThermaltakeRiing::RGBController_ThermaltakeRiing(ThermaltakeRiingController* riing_ptr)
-{
-    riing = riing_ptr;
-
-    name = "Thermaltake Riing";
-
-    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.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.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_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_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_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_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_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_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);
-
-    /*-------------------------------------------------*\
-    | Set size of colors array                          |
-    \*-------------------------------------------------*/
-    unsigned int led_count = 0;
-    for (unsigned int channel_idx = 0; channel_idx < 5; channel_idx++)
-    {
-        led_count += riing->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 < 5; channel_idx++)
-    {
-        if(riing->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 = "Riing 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 < riing->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 = "Riing 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);
-        }
-    }
-}
-
-void RGBController_ThermaltakeRiing::UpdateLEDs()
-{
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        unsigned int channel = zones_channel[zone_idx];
-
-        std::vector<RGBColor> channel_colors;
-
-        for(std::size_t color = 0; color < colors.size(); color++)
-        {
-            if(leds_channel[color] == channel)
-            {
-                channel_colors.push_back(colors[color]);
-            }
-        }
-
-        if(channel_colors.size() > 0)
-        {
-            riing->SetChannelLEDs(channel, channel_colors);
-        }
-    }
-}
-
-void RGBController_ThermaltakeRiing::UpdateZoneLEDs(int zone)
-{
-    unsigned int channel = zones_channel[zone];
-
-    std::vector<RGBColor> channel_colors;
-
-    for(std::size_t color = 0; color < colors.size(); color++)
-    {
-        if(leds_channel[color] == channel)
-        {
-            channel_colors.push_back(colors[color]);
-        }
-    }
-
-    if(channel_colors.size() > 0)
-    {
-        riing->SetChannelLEDs(channel, channel_colors);
-    }
-}
-
-void RGBController_ThermaltakeRiing::UpdateSingleLED(int led)
-{
-    unsigned int channel = leds_channel[led];
-
-    std::vector<RGBColor> channel_colors;
-
-    for(std::size_t color = 0; color < colors.size(); color++)
-    {
-        if(leds_channel[color] == channel)
-        {
-            channel_colors.push_back(colors[color]);
-        }
-    }
-
-    if(channel_colors.size() > 0)
-    {
-        riing->SetChannelLEDs(channel, channel_colors);
-    }
-}
-
-void RGBController_ThermaltakeRiing::SetCustomMode()
-{
-    active_mode = 6;
-}
-
-void RGBController_ThermaltakeRiing::UpdateMode()
-{
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        unsigned int channel = zones_channel[zone_idx];
-
-        std::vector<RGBColor> channel_colors;
-
-        for(std::size_t color = 0; color < colors.size(); color++)
-        {
-            if(leds_channel[color] == channel)
-            {
-                channel_colors.push_back(colors[color]);
-            }
-        }
-
-        if(channel_colors.size() > 0)
-        {
-            riing->SetMode(modes[active_mode].value, modes[active_mode].speed);
-            riing->SetChannelLEDs(channel, channel_colors);
-        }
-    }
-}

RGBController/RGBController_ThermaltakeRiing.h

@@ -1,29 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_ThermaltakeRiing.h         |
-|                                           |
-|  Generic RGB Interface for Thermaltake    |
-|  Riing controller                         |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/9/2020    |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "ThermaltakeRiingController.h"
-
-class RGBController_ThermaltakeRiing : public RGBController
-{
-public:
-    RGBController_ThermaltakeRiing(ThermaltakeRiingController* riing_ptr);
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        UpdateMode();
-
-private:
-    ThermaltakeRiingController* riing;
-    std::vector<unsigned int>   leds_channel;
-    std::vector<unsigned int>   zones_channel;
-};

RGBController/RazerChromaSDKDetect.cpp

@@ -0,0 +1,70 @@
+#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() */