Copy OpenRazer.dll to build directory on Windows

Controllers/AuraController/AuraControllerDetect.cpp

@@ -135,7 +135,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 +151,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

@@ -92,10 +92,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/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

@@ -99,10 +99,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/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

@@ -46,48 +46,12 @@ HyperXKeyboardController::~HyperXKeyboardController()
 
 }
 
-void HyperXKeyboardController::SetMode
-    (
-    unsigned char mode,
-    unsigned char direction,
-    unsigned char speed,
-    std::vector<RGBColor> colors
-    )
+void HyperXKeyboardController::SetMode(unsigned char mode, unsigned char direction, unsigned char speed)
 {
-    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,
@@ -95,19 +59,8 @@ void HyperXKeyboardController::SetMode
         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]
+        HYPERX_COLOR_MODE_SPECTRUM
         );
-
-    Sleep(100);
 }
 
 void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
@@ -137,7 +90,7 @@ void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
         red_color_data
         );
 
-    Sleep(5);
+    Sleep(2);
 
     SendDirect
         (
@@ -145,7 +98,7 @@ void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
         grn_color_data
         );
 
-    Sleep(5);
+    Sleep(2);
 
     SendDirect
         (
@@ -153,7 +106,7 @@ void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
         blu_color_data
         );
 
-    Sleep(5);
+    Sleep(2);
 
     SendDirectExtended
         (
@@ -189,8 +142,6 @@ void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
         red_color_data
         );
 
-    Sleep(5);
-
     SendColor
         (
         0x01,
@@ -198,8 +149,6 @@ void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
         grn_color_data
         );
 
-    Sleep(5);
-
     SendColor
         (
         0x01,
@@ -207,8 +156,6 @@ void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
         blu_color_data
         );
 
-    Sleep(5);
-    
     SendExtendedColor
         (
         0x01,
@@ -255,16 +202,7 @@ void HyperXKeyboardController::SendEffect
     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   color_mode
     )
 {
     unsigned char buf[264];
@@ -305,19 +243,6 @@ void HyperXKeyboardController::SendEffect
     buf[0x21]   = reactive_mode;
     buf[0x22]   = reactive_mode;
 
-    /*-----------------------------------------------------*\
-    | Set mode-specific colors                              |
-    \*-----------------------------------------------------*/
-    buf[0x29]   = red_single;
-    buf[0x41]   = grn_single;
-    buf[0x59]   = blu_single;
-    buf[0x2A]   = red_dual_1;
-    buf[0x42]   = grn_dual_1;
-    buf[0x5A]   = blu_dual_1;
-    buf[0x2B]   = red_dual_2;
-    buf[0x43]   = grn_dual_2;
-    buf[0x5B]   = blu_dual_2;
-
     buf[0x6B]   = 0x09;
     buf[0x6C]   = 0x09;
     buf[0x6D]   = 0x05;

Controllers/HyperXKeyboardController/HyperXKeyboardController.h

@@ -68,14 +68,7 @@ public:
     HyperXKeyboardController(hid_device* dev_handle);
     ~HyperXKeyboardController();
 
-    void SetMode
-        (
-        unsigned char mode,
-        unsigned char direction,
-        unsigned char speed,
-        std::vector<RGBColor> colors
-        );
-
+    void SetMode(unsigned char mode, unsigned char direction, unsigned char speed);
     void SetLEDsDirect(std::vector<RGBColor> colors);
     void SetLEDs(std::vector<RGBColor> colors);
 
@@ -97,16 +90,7 @@ private:
                 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   color_mode
                 );
 
     void    SendColor

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,20 @@ 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");
+        asr_led = false;
+        strcpy(device_name, "ASRock Polychrome 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");
+        asr_led = false;
+        strcpy(device_name, "ASRock Polychrome 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");
+        strcpy(device_name, "ASRock Polychrome FW 2.10");
         break;
 
     case FIRMWARE_VER_3_PT_00:

Controllers/PoseidonZRGBController/PoseidonZRGBController.cpp

@@ -104,9 +104,6 @@ void PoseidonZRGBController::SetLEDsDirect(std::vector<RGBColor> colors)
     | Send packets                                          |
     \*-----------------------------------------------------*/
     hid_send_feature_report(dev, red_grn_buf, 264);
-
-    Sleep(5);
-     
     hid_send_feature_report(dev, blu_buf, 264);
 }
 

Controllers/RGBFusion2Controller/RGBFusion2Controller.cpp

@@ -4,282 +4,118 @@
 |  Driver for Gigabyte Aorus RGB Fusion 2.0 |
 |  lighting controller                      |
 |                                           |
-|  jackun 1/8/2020                          |
+|  Adam Honse (CalcProgrammer1) 1/15/2020   |
 \*-----------------------------------------*/
 
 #include "RGBFusion2Controller.h"
-#include <algorithm>
-#include <array>
-#include <thread>
-#include <chrono>
+#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>
 
-static LEDCount LedCountToEnum(unsigned int c)
+RGBFusion2Controller::RGBFusion2Controller(hid_device* dev_handle)
 {
-    if (c <= 32)
-        return(LEDS_32);
-    if (c <= 64)
-        return(LEDS_64);
-    if (c <= 256)
-        return(LEDS_256);
-    if (c <= 512)
-        return(LEDS_512);
+    dev = dev_handle;
 
-    return(LEDS_1024);
-}
+    // Set Device name
+    strcpy(device_name, "Gigabyte Motherboard");
 
-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);
-    }
+    // Set LED count
+    led_count = 8;
 }
 
 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);
+    return(device_name);
 }
 
 std::string RGBFusion2Controller::GetDeviceLocation()
 {
-    return(loc);
+    return("");
 }
 
-std::string RGBFusion2Controller::GetSerial()
+unsigned int RGBFusion2Controller::GetLEDCount()
 {
-    return(chip_id);
+    return(led_count);
 }
 
-void RGBFusion2Controller::SetStripColors(unsigned int hdr, int start, int end, std::vector<RGBColor>& colors, int single_led)
+unsigned char RGBFusion2Controller::GetMode()
 {
-    PktRGB pkt;
-    pkt.Init(hdr, report_id);
+    return(0);
+}
 
-     // FIXME assuming that LED strips ports are 0x58/0x59 for all boards
-    uint32_t byteorder = hdr == HDR_D_LED1_RGB ? report.byteorder0 : report.byteorder1;
+void RGBFusion2Controller::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
+{
+}
 
-    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)
+void RGBFusion2Controller::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char usb_buf[] =
     {
-        leds_left = 1;
-        k = single_led - start;
-        sent_data = k * 3;
-        leds_in_pkt = 1;
-    }
+        0xCC, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x01,
+        0x5A, 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,
+    };
 
-    while(leds_left > 0)
+    usb_buf[0x01] = (0x20 |  led);
+    usb_buf[0x02] = (0x01 << led );
+
+    usb_buf[0x0E] = blue;
+    usb_buf[0x0F] = green;
+    usb_buf[0x10] = red;
+
+    hid_send_feature_report(dev, usb_buf, 64);
+    
+    SendApply();
+}
+
+void RGBFusion2Controller::SendApply()
+{
+    unsigned char usb_buf[] =
     {
-        leds_in_pkt = (std::min)(leds_in_pkt, leds_left);
-        leds_left -= leds_in_pkt;
+        0xCC, 0x28, 0xFF, 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,
+    };
 
-        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);
+    hid_send_feature_report(dev, usb_buf, 64);
 }
 
-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)
+void RGBFusion2Controller::SetMode(unsigned char mode)
 {
-    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()
+void RGBFusion2Controller::dump()
 {
-    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

@@ -4,187 +4,36 @@
 |  Definitions and types for Gigabyte Aorus |
 |  RGB Fusion 2.0 lighting controller       |
 |                                           |
-|  jackun 1/8/2020                          |
+|  Adam Honse (CalcProgrammer1) 1/15/2020   |
 \*-----------------------------------------*/
 
-#include "RGBController.h"
-#include <cstring>
+#include <string>
 #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(hid_device* dev_handle);
     ~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();
+    unsigned int    GetLEDCount();
+    unsigned char   GetMode();
+    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);
 
 private:
-    bool            EnableBeat(bool enable);
-    bool            SendPacket(uint8_t a, uint8_t b, uint8_t c = 0);
-    int             SendPacket(unsigned char* packet);
+    void            dump();
 
-    hid_device*             dev;
-    int                     mode;
+    char                    device_name[32];
     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;
+
+    void            SendApply();
+    
+    hid_device*             dev;
 };

Controllers/RGBFusion2Controller/RGBFusion2ControllerDetect.cpp

@@ -1,37 +1,36 @@
 #include "RGBFusion2Controller.h"
+#include "RGBController.h"
 #include "RGBController_RGBFusion2.h"
+#include <vector>
+#include <hidapi/hidapi.h>
 
-#define IT8297_VID 0x048D
-#define IT8297_PID 0x8297
+#define RGB_FUSION_2_VID 0x048D
+#define RGB_FUSION_2_PID 0x8297
 
 /******************************************************************************************\
 *                                                                                          *
 *   DetectRGBFusion2Controllers                                                            *
 *                                                                                          *
-*       Detect RGB Fusion 2 devices that use IT8297 RGB controller                         *
+*       Detect RGB Fusion 2.0 controllers on the USB interface.                            *
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectRGBFusion2Controllers(std::vector<RGBController*> &rgb_controllers)
+void DetectRGBFusion2Controllers(std::vector<RGBController*>& rgb_controllers)
 {
-    if (hid_init() < 0)
-        return;
+    hid_device* dev;
 
-    hid_device_info * device_list = hid_enumerate(IT8297_VID, IT8297_PID);
-    if (!device_list)
-        return;
+    //Look for RGB Fusion 2.0 Controller
+    hid_init();
 
-    hid_device_info * device = device_list;
-    while (device)
+    dev = hid_open(RGB_FUSION_2_VID, RGB_FUSION_2_PID, 0);
+
+    if( dev )
     {
-        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;
+        RGBFusion2Controller* controller = new RGBFusion2Controller(dev);
+
+        RGBController_RGBFusion2* rgb_controller = new RGBController_RGBFusion2(controller);
+
+        rgb_controllers.push_back(rgb_controller);
     }
 
-    hid_free_enumeration(device_list);
-}
+}   /* DetectRGBFusionControllers() */

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() */

OpenRGB.cpp

@@ -17,7 +17,6 @@
 #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"
 #else /* WIN32 */
@@ -88,33 +87,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 +170,6 @@ void DetectI2CBusses()
     // Detect Nuvoton Super IO SMBus adapters
     DetectNuvotonI2CBusses();
 
-    // Detect NVidia NvAPI I2C adapters
-    DetectNvAPII2CBusses();
-
 }   /* DetectI2CBusses() */
 
 #else /* WIN32 */
@@ -249,7 +218,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,7 +253,6 @@ 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);
@@ -285,14 +260,14 @@ void DetectHyperXControllers(std::vector<i2c_smbus_interface*> &busses, std::vec
 void DetectPatriotViperControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
 void DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
 void DetectRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
-void 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);
@@ -301,7 +276,6 @@ void DetectCorsairNodeProControllers(std::vector<RGBController*> &rgb_controller
 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 +284,19 @@ 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);
@@ -340,7 +310,6 @@ void DetectRGBControllers(void)
     DetectCorsairKeyboardControllers(rgb_controllers);
     DetectCorsairNodeProControllers(rgb_controllers);
     DetectThermaltakeRiingControllers(rgb_controllers);
-    DetectRGBFusion2Controllers(rgb_controllers);
     
     DetectE131Controllers(rgb_controllers);
 
@@ -348,6 +317,8 @@ void DetectRGBControllers(void)
     | Windows-only devices                  |
     \*-------------------------------------*/
 #ifdef WIN32
+ //   DetectRazerChromaSDKControllers(rgb_controllers);
+    DetectAorusGPUControllers(rgb_controllers);
     DetectOpenRazerControllers(rgb_controllers);
     /*-------------------------------------*\
     | Linux-only devices                    |

OpenRGB.pro

@@ -5,22 +5,6 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 TARGET = OpenRGB
 TEMPLATE = app
 
-VERSION         = 0.0
-win32:BUILDDATE = $$system(date /t)
-unix:BUILDDATE  = $$system(date -R)
-GIT_COMMIT_ID   = $$system(git --git-dir $$_PRO_FILE_PWD_/.git --work-tree $$_PRO_FILE_PWD_ rev-parse HEAD)
-GIT_COMMIT_DATE = $$system(git --git-dir $$_PRO_FILE_PWD_/.git --work-tree $$_PRO_FILE_PWD_ show -s --format=%ci HEAD)
-GIT_BRANCH      = $$system(git --git-dir $$_PRO_FILE_PWD_/.git --work-tree $$_PRO_FILE_PWD_ rev-parse --abbrev-ref HEAD)
-
-DEFINES +=                                                              \
-    VERSION_STRING=\\"\"\"$$VERSION\\"\"\"                              \
-    BUILDDATE_STRING=\\"\"\"$$BUILDDATE\\"\"\"                          \
-    GIT_COMMIT_ID=\\"\"\"$$GIT_COMMIT_ID\\"\"\"                         \
-    GIT_COMMIT_DATE=\\"\"\"$$GIT_COMMIT_DATE\\"\"\"                     \
-    GIT_BRANCH=\\"\"\"$$GIT_BRANCH\\"\"\"
-
-RC_ICONS = qt/OpenRGB.ico
-
 INCLUDEPATH +=                                                          \
     dependencies/libe131/src/                                           \
     i2c_smbus/                                                          \
@@ -30,7 +14,6 @@ INCLUDEPATH +=                                                          \
     super_io/                                                           \
     Controllers/AMDWraithPrismController/                               \
     Controllers/AuraController/                                         \
-    Controllers/AuraGPUController/                                      \
     Controllers/CorsairController/                                      \
     Controllers/CorsairCmdrProController/                               \
     Controllers/CorsairKeyboardController/                              \
@@ -43,13 +26,11 @@ INCLUDEPATH +=                                                          \
     Controllers/HyperXKeyboardController/                               \
     Controllers/LEDStripController/                                     \
     Controllers/MSI3ZoneController/                                     \
-    Controllers/MSIRGBController/                                       \
     Controllers/PatriotViperController/                                 \
     Controllers/PolychromeController/                                   \
     Controllers/PoseidonZRGBController/                                 \
     Controllers/RGBFusionController/                                    \
     Controllers/RGBFusion2Controller/                                   \
-    Controllers/RGBFusionGPUController/                                 \
     Controllers/ThermaltakeRiingController/                             \
     RGBController/                                                      \
     qt/
@@ -57,7 +38,6 @@ INCLUDEPATH +=                                                          \
 SOURCES +=                                                              \
     dependencies/libe131/src/e131.c                                     \
     main.cpp                                                            \
-    cli.cpp                                                             \
     OpenRGB.cpp                                                         \
     qt/OpenRGBDeviceInfoPage.cpp                                        \
     qt/OpenRGBDevicePage.cpp                                            \
@@ -66,8 +46,6 @@ SOURCES +=                                                              \
     i2c_tools/i2c_tools.cpp                                             \
     net_port/net_port.cpp                                               \
     qt/OpenRGBDialog2.cpp                                               \
-    qt/OpenRGBProfileSaveDialog.cpp \
-    qt/OpenRGBSoftwareInfoPage.cpp \
     qt/OpenRGBSystemInfoPage.cpp                                        \
     qt/hsv.cpp                                                          \
     serial_port/serial_port.cpp                                         \
@@ -76,8 +54,6 @@ SOURCES +=                                                              \
     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   \
@@ -102,8 +78,6 @@ SOURCES +=                                                              \
     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           \
@@ -114,22 +88,18 @@ SOURCES +=                                                              \
     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                              \
@@ -137,13 +107,11 @@ SOURCES +=                                                              \
     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                    \
 
 HEADERS +=                                                              \
@@ -154,15 +122,12 @@ HEADERS +=                                                              \
     i2c_tools/i2c_tools.h                                               \
     net_port/net_port.h                                                 \
     qt/OpenRGBDialog2.h                                                 \
-    qt/OpenRGBProfileSaveDialog.h \
-    qt/OpenRGBSoftwareInfoPage.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   \
@@ -175,24 +140,20 @@ HEADERS +=                                                              \
     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                               \
@@ -200,13 +161,11 @@ HEADERS +=                                                              \
     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                      \
 
 RESOURCES += \
@@ -217,8 +176,6 @@ FORMS += \
     qt/OpenRGBDevicePage.ui \
     qt/OpenRGBDialog.ui \
     qt/OpenRGBDialog2.ui \
-    qt/OpenRGBProfileSaveDialog.ui \
-    qt/OpenRGBSoftwareInfoPage.ui \
     qt/OpenRGBSystemInfoPage.ui
 
 #-----------------------------------------------
@@ -226,47 +183,40 @@ 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                                         \
-    dependencies/hidapi/hid_win.c                                       \
     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/AorusGPUDetect.cpp                                    \
     RGBController/OpenRazerWindowsDetect.cpp                            \
+    RGBController/RGBController_AorusGPU.cpp                            \
     RGBController/RGBController_OpenRazerWindows.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_AorusGPU.h                              \
     RGBController/RGBController_OpenRazerWindows.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      \
-}
-
-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      \
-}
+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
@@ -279,15 +229,8 @@ win32:DEFINES +=                                                        \
     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) {
+win32
+{
     copydata.commands = $(COPY_FILE) \"$$shell_path($$PWD\\dependencies\\openrazer-win32\\OpenRazer.dll)\" \"$$shell_path($$OUT_PWD)\"
     first.depends = $(first) copydata
     export(first.depends)
@@ -299,7 +242,6 @@ win32:contains(QMAKE_TARGET.arch, x86) {
 # Linux specific project configuration
 #-----------------------------------------------
 unix:INCLUDEPATH +=                                                     \
-    dependencies/hidapi                                                 \
 
 unix:HEADERS +=                                                         \
     i2c_smbus/i2c_smbus_linux.h                                         \
@@ -307,10 +249,19 @@ unix:HEADERS +=                                                         \
 
 unix:LIBS +=                                                            \
     -lusb-1.0                                                           \
-    -lstdc++fs                                                          \
+
+packagesExist(hidapi-libusb){
+    unix:LIBS += -lhidapi-libusb
+} else {
+    packagesExist(hidapi) {
+        unix:LIBS += -lhidapi
+    } else {
+        unix:LIBS += -lhidapi-libusb
+    }
+}
+
 
 unix:SOURCES +=                                                         \
-    dependencies/hidapi/hid_win.c                                       \
     i2c_smbus/i2c_smbus_linux.cpp                                       \
     serial_port/find_usb_serial_port_linux.cpp                          \
     RGBController/OpenRazerDetect.cpp                                   \

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/RGBController.cpp

@@ -1,660 +1,4 @@
 #include "RGBController.h"
-#include <cstring>
-
-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)
 {
@@ -711,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;
@@ -180,37 +180,35 @@ void RGBController_AMDWraithPrism::SetCustomMode()
 
 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);
 
@@ -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++)
@@ -94,4 +91,4 @@ void RGBController_Corsair::SetCustomMode()
 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;
+    active_mode = 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_CorsairKeyboard.cpp

@@ -145,10 +145,9 @@ RGBController_CorsairKeyboard::RGBController_CorsairKeyboard(CorsairKeyboardCont
     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;
+    Direct.name  = "Direct";
+    Direct.value = 0;
+    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
     modes.push_back(Direct);
 
     colors.resize(111);

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;
+    active_mode = 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_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;
@@ -212,8 +191,6 @@ void RGBController_CorsairPro::SetCustomMode()
 void RGBController_CorsairPro::UpdateMode()
 {
     unsigned int corsair_direction;
-    bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-    unsigned char mode_colors[6];
 
     switch(modes[active_mode].direction)
     {
@@ -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

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

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,13 +18,9 @@ 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();
 
@@ -176,4 +172,4 @@ void RGBController_E131::SetCustomMode()
 void RGBController_E131::UpdateMode()
 {
 
-}
+}

RGBController/RGBController_Faustus.cpp

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

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);
 
     /*-------------------------------------------------*\
@@ -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_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                          |
@@ -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());
@@ -239,17 +217,6 @@ void RGBController_HyperX::SetCustomMode()
 
 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

@@ -9,41 +9,6 @@
 
 #include "RGBController_HyperXKeyboard.h"
 
-//Include thread libraries for Windows or Linux
-#ifdef WIN32
-#include <process.h>
-#else
-#include "pthread.h"
-#include "unistd.h"
-#endif
-
-//Thread functions have different types in Windows and Linux
-#ifdef WIN32
-#define THREAD static void
-#define THREADRETURN
-#else
-#define THREAD static void*
-#define THREADRETURN return(NULL);
-#endif
-
-#ifdef WIN32
-#include <Windows.h>
-#else
-#include <unistd.h>
-
-static void Sleep(unsigned int milliseconds)
-{
-    usleep(1000 * milliseconds);
-}
-#endif
-
-THREAD keepalive_thread(void *param)
-{
-    RGBController_HyperXKeyboard* controller = static_cast<RGBController_HyperXKeyboard*>(param);
-    controller->KeepaliveThread();
-    THREADRETURN
-}
-
 static const char* zone_names[] =
 {
     "Keyboard",
@@ -196,41 +161,38 @@ RGBController_HyperXKeyboard::RGBController_HyperXKeyboard(HyperXKeyboardControl
     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;
+    Direct.name   = "Direct";
+    Direct.value  = HYPERX_MODE_STATIC;
+    Direct.flags  = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Direct.random = false;
     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;
+    Static.name   = "Static";
+    Static.value  = HYPERX_MODE_STATIC;
+    Static.flags  = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Static.random = false;
     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;
+    Wave.name      = "Wave";
+    Wave.value     = HYPERX_MODE_WAVE;
+    Wave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Wave.speed_min = 0x00;
+    Wave.speed_max = 0x09;
+    Wave.random    = false;
+    Wave.speed     = 0x09;
+    Wave.direction = MODE_DIRECTION_LEFT;
     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);
+    Breathing.name = "Breathing";
+    Breathing.value = HYPERX_MODE_BREATHING;
+    Breathing.flags = MODE_FLAG_HAS_SPEED;
+    Breathing.speed_min = 0x00;
+    Breathing.speed_max = 0x09;
+    Breathing.random = false;
+    Breathing.speed = 0x09;
     modes.push_back(Breathing);
 
     colors.resize(126);
@@ -258,19 +220,6 @@ RGBController_HyperXKeyboard::RGBController_HyperXKeyboard(HyperXKeyboardControl
 
         zones.push_back(new_zone);
     }
-
-    /*-----------------------------------------------------*\
-    | The Corsair Lighting Node Pro requires a packet within|
-    | 20 seconds of sending the lighting change in order    |
-    | to not revert back into rainbow mode.  Start a thread |
-    | to continuously send a keepalive packet every 5s      |
-    \*-----------------------------------------------------*/
-#ifdef WIN32
-    _beginthread(keepalive_thread, 0, this);
-#else
-    pthread_t thread;
-    pthread_create(&thread, NULL, &keepalive_thread, this);
-#endif
 }
 
 RGBController_HyperXKeyboard::~RGBController_HyperXKeyboard()
@@ -307,25 +256,5 @@ void RGBController_HyperXKeyboard::SetCustomMode()
 
 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);
-    }
+    hyperx->SetMode(modes[active_mode].value, modes[active_mode].direction, modes[active_mode].speed);
 }
-
-void RGBController_HyperXKeyboard::KeepaliveThread()
-{
-    while(1)
-    {
-        if(active_mode == 0)
-        {
-            hyperx->SetLEDsDirect(colors);
-        }
-        Sleep(200);
-    }
-}

RGBController/RGBController_HyperXKeyboard.h

@@ -23,8 +23,6 @@ public:
     void        SetCustomMode();
     void        UpdateMode();
 
-    void        KeepaliveThread();
-    
 private:
     HyperXKeyboardController*   hyperx;
 };

RGBController/RGBController_LEDStrip.cpp

@@ -18,12 +18,9 @@ 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);
     
@@ -73,4 +70,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

@@ -245,77 +245,65 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
             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;
+                Custom.name  = "Custom";
+                Custom.value = RAZER_MODE_CUSTOM;
+                Custom.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
                 modes.push_back(Custom);
             }
 
             if(matrix_effect_none)
             {
                 mode Off;
-                Off.name       = "Off";
-                Off.value      = RAZER_MODE_OFF;
-                Off.flags      = 0;
-                Off.color_mode = MODE_COLORS_NONE;
+                Off.name  = "Off";
+                Off.value = RAZER_MODE_OFF;
+                Off.flags = 0;
                 modes.push_back(Off);
             }
 
             if(matrix_effect_static)
             {
                 mode Static;
-                Static.name       = "Static";
-                Static.value      = RAZER_MODE_STATIC;
-                Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-                Static.colors_min = 1;
-                Static.colors_max = 1;
-                Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
-                Static.colors.resize(1);
+                Static.name = "Static";
+                Static.value = RAZER_MODE_STATIC;
+                Static.flags = MODE_FLAG_HAS_COLOR;
                 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);
+                Breathing.name   = "Breathing";
+                Breathing.value  = RAZER_MODE_BREATHING;
+                Breathing.flags  = MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+                Breathing.random = false;
                 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;
+                SpectrumCycle.name  = "Spectrum Cycle";
+                SpectrumCycle.value = RAZER_MODE_SPECTRUM_CYCLE;
+                SpectrumCycle.flags = 0;
                 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;
+                Wave.name      = "Wave";
+                Wave.value     = RAZER_MODE_WAVE;
+                Wave.flags     = MODE_FLAG_HAS_DIRECTION_LR;
+                Wave.direction = MODE_DIRECTION_RIGHT;
                 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;
+                Reactive.name  = "Reactive";
+                Reactive.value = RAZER_MODE_REACTIVE;
+                Reactive.flags = 0;
                 modes.push_back(Reactive);
             }
             
@@ -348,15 +336,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);
@@ -380,88 +364,57 @@ void RGBController_OpenRazer::SetCustomMode()
 
 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.write(&update_value, 1);
                         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;
-                        }
+                        matrix_effect_breath.write(&update_value, 1);
+                        matrix_effect_breath.flush();
                         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';
+                                update_value = '2';
                                 break;
-
+                            
                             default:
-                                update_value[0] = '1';
+                                update_value = '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;
                 }
@@ -491,4 +444,4 @@ void RGBController_OpenRazer::UpdateMode()
             }
 #endif
     }
-}
+}

RGBController/RGBController_OpenRazerWindows.cpp

@@ -235,77 +235,65 @@ RGBController_OpenRazer::RGBController_OpenRazer(device * razer_device, device_f
             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;
+                Custom.name  = "Custom";
+                Custom.value = RAZER_MODE_CUSTOM;
+                Custom.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
                 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;
+                Off.name  = "Off";
+                Off.value = RAZER_MODE_OFF;
+                Off.flags = 0;
                 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);
+                Static.name = "Static";
+                Static.value = RAZER_MODE_STATIC;
+                Static.flags = MODE_FLAG_HAS_COLOR;
                 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);
+                Breathing.name   = "Breathing";
+                Breathing.value  = RAZER_MODE_BREATHING;
+                Breathing.flags  = MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+                Breathing.random = false;
                 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;
+                SpectrumCycle.name  = "Spectrum Cycle";
+                SpectrumCycle.value = RAZER_MODE_SPECTRUM_CYCLE;
+                SpectrumCycle.flags = 0;
                 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;
+                Wave.name      = "Wave";
+                Wave.value     = RAZER_MODE_WAVE;
+                Wave.flags     = MODE_FLAG_HAS_DIRECTION_LR;
+                Wave.direction = MODE_DIRECTION_RIGHT;
                 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;
+                Reactive.name  = "Reactive";
+                Reactive.value = RAZER_MODE_REACTIVE;
+                Reactive.flags = 0;
                 modes.push_back(Reactive);
             }
 
@@ -371,9 +359,7 @@ void RGBController_OpenRazer::SetCustomMode()
 
 void RGBController_OpenRazer::UpdateMode()
 {
-    char update_value[6];
-
-    update_value[0] = 1;
+    char update_value = 1;
 
     switch(matrix_type)
     {
@@ -383,68 +369,41 @@ void RGBController_OpenRazer::UpdateMode()
                 switch(modes[active_mode].value)
                 {
                     case RAZER_MODE_CUSTOM:
-                        razer_functions->matrix_effect_custom->store(razer_device, NULL, update_value, 1);
+                        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);
+                        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);
+                        razer_functions->matrix_effect_static->store(razer_device, NULL, &update_value, 1);
                         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;
-                        }
+                        razer_functions->matrix_effect_breath->store(razer_device, NULL, &update_value, 1);
                         break;
 
                     case RAZER_MODE_SPECTRUM_CYCLE:
-                        razer_functions->matrix_effect_spectrum->store(razer_device, NULL, update_value, 1);
+                        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';
+                                update_value = '2';
                                 break;
                             
                             default:
-                                update_value[0] = '1';
+                                update_value = '1';
                                 break;
                         }
-                        razer_functions->matrix_effect_wave->store(razer_device, NULL, update_value, 1);
+                        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);
+                        razer_functions->matrix_effect_reactive->store(razer_device, NULL, &update_value, 1);
                         break;
                 }
             }

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());
@@ -199,4 +199,4 @@ void RGBController_PatriotViper::UpdateMode()
     {
         viper->SetMode(modes[active_mode].value, modes[active_mode].speed);
     }
-}
+}

RGBController/RGBController_Polychrome.cpp

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

RGBController/RGBController_PoseidonZRGB.cpp

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

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());

RGBController/RGBController_RGBFusion2.cpp

@@ -4,187 +4,83 @@
 |  Generic RGB Interface for OpenRGB        |
 |  Gigabyte RGB Fusion 2.0 Driver           |
 |                                           |
-|  jackun 1/8/2020                          |
+|  Adam Honse (CalcProgrammer1) 1/15/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
+void RGBController_RGBFusion2::UpdateLEDs()
 {
+    for (std::size_t led = 0; led < colors.size(); led++)
     {
-        "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 },
-            }
-        }
-    },
-};
+        RGBColor      color = colors[led];
+        unsigned char red   = RGBGetRValue(color);
+        unsigned char grn   = RGBGetGValue(color);
+        unsigned char blu   = RGBGetBValue(color);
 
-RGBController_RGBFusion2::RGBController_RGBFusion2(RGBFusion2Controller* controller_ptr)
+        rgb_fusion->SetLEDColor(led, red, grn, blu);
+    }
+}
+
+void RGBController_RGBFusion2::UpdateZoneLEDs(int zone)
 {
-    controller = controller_ptr;
+    RGBColor      color = colors[zone];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
+
+    rgb_fusion->SetLEDColor(zone, red, grn, blu);
+}
+
+void RGBController_RGBFusion2::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(led);
+}
+
+RGBController_RGBFusion2::RGBController_RGBFusion2(RGBFusion2Controller* rgb_fusion_ptr)
+{
+    rgb_fusion = rgb_fusion_ptr;
+
+    name = rgb_fusion->GetDeviceName();
+    description = "RGB Fusion 2.0";
+    location = rgb_fusion->GetDeviceLocation();
 
-    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())
+    mode rgb_fusion_modes[1];
+
+    rgb_fusion_modes[0].name = "Static";
+
+    for (int i = 0; i < 1; i++)
     {
-        it = known_channels.find("Generic");
+        modes.push_back(rgb_fusion_modes[i]);
     }
 
-    size_t mb_led_cnt = it->second[0].size();
+    colors.resize(rgb_fusion->GetLEDCount());
 
-    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++)
+    // Search through all LEDs and create zones for each channel type
+    for (unsigned int i = 0; i < rgb_fusion->GetLEDCount(); i++)
     {
-        std::vector<int> new_zone_map;
-        zone new_zone;
-        new_zone.name = led_zones[i];
-        new_zone.type = ZONE_TYPE_LINEAR; // TODO
+        zone* new_zone = new zone();
+        led*  new_led  = new led();
 
-        unsigned int zone_led_cnt = mb_led_cnt;
-        if( i > 0 )
-        {
-            zone_led_cnt = per_strip_led_cnt;
-        }
+        std::vector<int>* zone_row = new std::vector<int>();
 
-        for(unsigned int zone_led_idx = 0; zone_led_idx < zone_led_cnt; zone_led_idx++)
-        {
-            led new_led;
+        // Set zone name to channel name
+        new_zone->name = "Zone";
+        new_led->name  = "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();
-            }
+        zone_row->push_back(i);
 
-            leds.push_back(new_led);
-            new_zone_map.push_back(led_idx);
-            led_idx++;
-        }
+        // Aura devices can be either single or linear, never matrix
+        // That means only one row is needed
+        new_zone->map.push_back(*zone_row);
 
-        new_zone.map.push_back(new_zone_map);
-        zones.push_back(new_zone);
+        // Push new LED to LEDs vector
+        leds.push_back(*new_led);
+
+        // Push new zone to zones vector
+        zones.push_back(*new_zone);
     }
 }
 
@@ -193,97 +89,7 @@ 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();
-}
+    rgb_fusion->SetMode(modes[active_mode].value);
+}

RGBController/RGBController_RGBFusion2.h

@@ -4,36 +4,25 @@
 |  Generic RGB Interface for OpenRGB        |
 |  Gigabyte RGB Fusion 2.0 Driver           |
 |                                           |
-|  jackun 1/8/2020                          |
+|  Adam Honse (CalcProgrammer1) 1/15/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
+class RGBController_RGBFusion2 : public RGBController
 {
 public:
-    RGBController_RGBFusion2(RGBFusion2Controller* controller_ptr);
-    void        SetCustomMode();
+    RGBController_RGBFusion2(RGBFusion2Controller* rgb_fusion_ptr);
     void        UpdateLEDs();
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
     void        UpdateMode();
 
 private:
-    RGBFusion2Controller*       controller;
-    IT8297Report                report;
-    unsigned int                per_strip_led_cnt;
+    RGBFusion2Controller* rgb_fusion;
 };

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

@@ -19,86 +19,75 @@ RGBController_ThermaltakeRiing::RGBController_ThermaltakeRiing(ThermaltakeRiingC
     type = DEVICE_TYPE_COOLER;
 
     mode Flow;
-    Flow.name       = "Flow";
-    Flow.value      = THERMALTAKE_MODE_FLOW;
-    Flow.flags      = MODE_FLAG_HAS_SPEED;
-    Flow.speed_min  = THERMALTAKE_SPEED_SLOW;
-    Flow.speed_max  = THERMALTAKE_SPEED_EXTREME;
-    Flow.speed      = THERMALTAKE_SPEED_NORMAL;
-    Flow.color_mode = MODE_COLORS_NONE;
+    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;
     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;
+    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;
     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;
+    Ripple.name      = "Ripple";
+    Ripple.value     = THERMALTAKE_MODE_RIPPLE;
+    Ripple.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR;
+    Ripple.speed_min = THERMALTAKE_SPEED_SLOW;
+    Ripple.speed_max = THERMALTAKE_SPEED_EXTREME;
+    Ripple.speed     = THERMALTAKE_SPEED_NORMAL;
     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;
+    Blink.name      = "Blink";
+    Blink.value     = THERMALTAKE_MODE_BLINK;
+    Blink.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Blink.speed_min = THERMALTAKE_SPEED_SLOW;
+    Blink.speed_max = THERMALTAKE_SPEED_EXTREME;
+    Blink.speed     = THERMALTAKE_SPEED_NORMAL;
     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;
+    Pulse.name      = "Pulse";
+    Pulse.value     = THERMALTAKE_MODE_PULSE;
+    Pulse.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Pulse.speed_min = THERMALTAKE_SPEED_SLOW;
+    Pulse.speed_max = THERMALTAKE_SPEED_EXTREME;
+    Pulse.speed     = THERMALTAKE_SPEED_NORMAL;
     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;
+    Wave.name      = "Wave";
+    Wave.value     = THERMALTAKE_MODE_WAVE;
+    Wave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Wave.speed_min = THERMALTAKE_SPEED_SLOW;
+    Wave.speed_max = THERMALTAKE_SPEED_EXTREME;
+    Wave.speed     = THERMALTAKE_SPEED_NORMAL;
     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;
+    Direct.name      = "Direct";
+    Direct.value     = THERMALTAKE_MODE_PER_LED;
+    Direct.flags     = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Direct.speed_min = 0;
+    Direct.speed_max = 0;
+    Direct.speed     = 0;
     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);
+    Static.name      = "Static";
+    Static.value     = THERMALTAKE_MODE_FULL;
+    Static.flags     = MODE_FLAG_HAS_COLOR;
+    Static.speed_min = 0;
+    Static.speed_max = 0;
+    Static.speed     = 0;
     modes.push_back(Static);
 
     /*-------------------------------------------------*\

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() */

cli.cpp

@@ -1,368 +0,0 @@
-#include <vector>
-#include <cstring>
-#include <string>
-#include <tuple>
-#include <iostream>
-#include "OpenRGB.h"
-#include "RGBController.h"
-#include "i2c_smbus.h"
-
-extern std::vector<i2c_smbus_interface*> busses;
-extern std::vector<RGBController*> rgb_controllers;
-
-struct DeviceOptions
-{
-    int device;
-    std::vector<std::tuple<unsigned char, unsigned char, unsigned char>> colors;
-    std::string mode;
-    bool hasOption;
-};
-
-struct Options
-{
-    std::vector<DeviceOptions> devices;
-
-    // if hasDevice is false, devices above is empty and allDeviceOptions
-    // shall be applied to all available devices
-    bool hasDevice;
-    DeviceOptions allDeviceOptions;
-};
-
-void PrintHelp()
-{
-    std::string help_text;
-    help_text += "OpenRGB ";
-    help_text += VERSION_STRING;
-    help_text += ", for controlling RGB lighting.\n";
-    help_text += "Usage: OpenRGB (--device [--mode] [--color])...\n";
-    help_text += "\nOptions:\n";
-    help_text += "--gui\t\t\t\t\t Show GUI, also appears when not passing any parameters\n";
-    help_text += "-l,  --list-devices\t\t\t Lists every compatible device with their number\n";
-    help_text += "-d,  --device [0-9]\t\t\t Selects device to apply colors and/or effect to, or applies to all devices if omitted\n";
-    help_text += "\t\t\t\t\t Can be specified multiple times with different modes and colors\n";
-    help_text += "-c,  --color \"FFFFFF,00AAFF...\"\t\t Sets colors on each device directly if no effect is specified, and sets the effect color if an effect is specified\n";
-    help_text += "\t\t\t\t\t If there are more LEDs than colors given, the last color will be applied to the remaining LEDs\n";
-    help_text += "-m,  --mode [breathing | static | ...]   Sets the mode to be applied, check --list-devices to see which modes are supported on your device\n";
-    help_text += "-v,  --version\t\t\t\t Display version and software build information\n";
-
-    std::cout << help_text << std::endl;
-}
-
-void PrintVersion()
-{
-    std::string version_text;
-    version_text += "OpenRGB ";
-    version_text += VERSION_STRING;
-    version_text += ", for controlling RGB lighting.\n";
-    version_text += "  Version:\t\t ";
-    version_text += VERSION_STRING;
-    version_text += "\n  Build Date\t\t ";
-    version_text += BUILDDATE_STRING;
-    version_text += "\n  Git Commit ID\t\t ";
-    version_text += GIT_COMMIT_ID;
-    version_text += "\n  Git Commit Date\t ";
-    version_text += GIT_COMMIT_DATE;
-    version_text += "\n  Git Branch\t\t ";
-    version_text += GIT_BRANCH;
-    version_text += "\n";
-
-    std::cout << version_text << std::endl;
-}
-
-bool ParseColors(std::string colors_string, DeviceOptions *options)
-{
-    while (colors_string.length() >= 6)
-    {
-        int rgb_end = colors_string.find_first_of(',');
-        std::string color = colors_string.substr(0, rgb_end);
-        if (color.length() != 6)
-            break;
-
-        try
-        {
-            unsigned char r = std::stoi(color.substr(0, 2), nullptr, 16);
-            unsigned char g = std::stoi(color.substr(2, 2), nullptr, 16);
-            unsigned char b = std::stoi(color.substr(4, 2), nullptr, 16);
-            options->colors.push_back(std::make_tuple(r, g, b));
-        }
-        catch (...)
-        {
-            break;
-        }
-
-        // If there are no more colors
-        if (rgb_end == std::string::npos)
-            break;
-        // Remove the current color and the next color's leading comma
-        colors_string = colors_string.substr(color.length() + 1);
-    }
-
-    return options->colors.size() > 0;
-}
-
-int ParseMode(DeviceOptions& options)
-{
-    auto availableModes = rgb_controllers[options.device]->modes;
-    for (int i = 0; i < availableModes.size(); i++)
-    {
-        if (availableModes[i].name == options.mode)
-        {
-            return i;
-        }
-    }
-
-    std::cout << "Error: Mode '" + options.mode + "' not available for device '" +
-        rgb_controllers[options.device]->name + "'" << std::endl;
-    return false;
-}
-
-DeviceOptions* GetDeviceOptionsForDevID(Options *opts, int device)
-{
-    if (device == -1)
-    {
-        return &opts->allDeviceOptions;
-    }
-
-    for (int i = 0; i < opts->devices.size(); i++)
-    {
-        if (opts->devices[i].device == device)
-        {
-            return &opts->devices[i];
-        }
-    }
-
-    // should never happen
-    std::cout << "Internal error: Tried setting an option on a device that wasn't specified" << std::endl;
-    abort();
-}
-
-std::string QuoteIfNecessary(std::string str)
-{
-    if (str.find(' ') == std::string::npos)
-    {
-        return str;
-    }
-    else
-    {
-        return "'" + str + "'";
-    }
-}
-
-bool ProcessOptions(int argc, char *argv[], Options *res)
-{
-    int arg_index = 1;
-    int currentDev = -1;
-
-    while (arg_index < argc)
-    {
-        std::string option = argv[arg_index];
-
-        // Handle options that take no arguments
-        if (option == "--list-devices" || option == "-l")
-        {
-            for (int i = 0; i < rgb_controllers.size(); i++)
-            {
-                RGBController *c = rgb_controllers[i];
-                std::cout << i << ": " << c->name << std::endl;
-
-                std::cout << "  Type: " << device_type_to_str(c->type) << std::endl;
-
-                if (!c->serial.empty())
-                {
-                    std::cout << "  Serial:      " << c->serial << std::endl;
-                }
-
-                if (!c->description.empty())
-                {
-                    std::cout << "  Description: " << c->description << std::endl;
-                }
-
-                if (!c->modes.empty())
-                {
-                    std::cout << "  Modes:";
-                    int curMode = c->GetMode();
-                    for (int i = 0; i < c->modes.size(); i++)
-                    {
-                        std::string modeStr = QuoteIfNecessary(c->modes[i].name);
-                        if (curMode == i) {
-                            modeStr = "[" + modeStr + "]";
-                        }
-                        std::cout << " " << modeStr;
-                    }
-                    std::cout << std::endl;
-                }
-
-                if (!c->zones.empty())
-                {
-                    std::cout << "  Zones:";
-                    for (int i = 0; i < c->zones.size(); i++)
-                    {
-                        std::cout << " " << QuoteIfNecessary(c->zones[i].name);
-                    }
-                    std::cout << std::endl;
-                }
-
-                if (!c->leds.empty())
-                {
-                    std::cout << "  LEDs:";
-                    for (int i = 0; i < c->leds.size(); i++)
-                    {
-                        std::cout << " " << QuoteIfNecessary(c->leds[i].name);
-                    }
-                    std::cout << std::endl;
-                }
-
-                std::cout << std::endl;
-            }
-            exit(0);
-        }
-        else if (arg_index + 1 < argc) // Handle options that take an argument
-        {
-            std::string argument = argv[arg_index + 1];
-
-            if (option == "--device" || option == "-d")
-            {
-                try
-                {
-                    currentDev = std::stoi(argument);
-
-                    if (rgb_controllers.size() <= currentDev || currentDev < 0)
-                    {
-                        throw;
-                    }
-
-                    DeviceOptions newDev;
-                    newDev.device = currentDev;
-
-                    if (!res->hasDevice)
-                    {
-                        res->hasDevice = true;
-                    }
-
-                    res->devices.push_back(newDev);
-                }
-                catch (...)
-                {
-                    std::cout << "Error: Invalid device ID: " + argument << std::endl;
-                    return false;
-                }
-            }
-            else if (option == "--color" || option == "-c")
-            {
-                DeviceOptions* currentDevOpts = GetDeviceOptionsForDevID(res, currentDev);
-                if (ParseColors(argument, currentDevOpts))
-                {
-                    currentDevOpts->hasOption = true;
-                }
-                else
-                {
-                    std::cout << "Error: Invalid argument to " + option + ": " + argument << std::endl;
-                    return false;
-                }
-            }
-            else if (option == "--mode" || option == "-m")
-            {
-                DeviceOptions* currentDevOpts = GetDeviceOptionsForDevID(res, currentDev);
-                currentDevOpts->mode = argument;
-                currentDevOpts->hasOption = true;
-            }
-            else
-            {
-                std::cout << "Error: Invalid option: " + option << std::endl;
-                return false;
-            }
-
-            arg_index++;
-        }
-        else
-        {
-            return false;
-        }
-        arg_index++;
-    }
-
-    if (res->hasDevice)
-    {
-        for (int i = 0; i < res->devices.size(); i++)
-        {
-            if (!res->devices[i].hasOption)
-            {
-                std::cout << "Error: Device " + std::to_string(i) + " specified, but neither mode nor color given" << std::endl;
-                return false;
-            }
-        }
-    }
-    else
-    {
-        return res->allDeviceOptions.hasOption;
-    }
-
-    return true;
-}
-
-void ApplyOptions(DeviceOptions& options)
-{
-    RGBController *device = rgb_controllers[options.device];
-
-    // Set mode first, in case it's 'direct' (which affects SetLED below)
-    int mode = ParseMode(options);
-    device->SetMode(mode);
-
-    if (options.colors.size() != 0)
-    {
-        int last_set_color;
-        for (int i = 0; i < device->leds.size(); i++)
-        {
-            if (i < options.colors.size())
-            {
-                last_set_color = i;
-            }
-
-            device->SetLED(i, ToRGBColor(std::get<0>(options.colors[last_set_color]),
-                                         std::get<1>(options.colors[last_set_color]),
-                                         std::get<2>(options.colors[last_set_color])));
-        }
-    }
-}
-
-int cli_main(int argc, char *argv[])
-{
-    if (argc == 2 && (!strcmp(argv[1], "--help") || !strcmp(argv[1], "-h")))
-    {
-        PrintHelp();
-        return 0;
-    }
-
-    if (argc == 2 && (!strcmp(argv[1], "--version") || !strcmp(argv[1], "-v")))
-    {
-        PrintVersion();
-        return 0;
-    }
-
-    DetectRGBControllers();
-
-    Options options;
-    if (!ProcessOptions(argc, argv, &options))
-    {
-        PrintHelp();
-        return -1;
-    }
-
-    if (options.hasDevice)
-    {
-        for (int i = 0; i < options.devices.size(); i++)
-        {
-            ApplyOptions(options.devices[i]);
-        }
-    }
-    else
-    {
-        for (int i = 0; i < rgb_controllers.size(); i++)
-        {
-            options.allDeviceOptions.device = i;
-            ApplyOptions(options.allDeviceOptions);
-        }
-    }
-
-    return 0;
-}

dependencies/NVFC/nvapi.cpp

@@ -1,560 +0,0 @@
-#define _WIN32_LEAN_AND_MEAN
-#include <windows.h>
-
-#include "nvapi.h"
-
-// Constructors for NvAPI structures that just zero the memory and set the right version
-NV_DELTA_ENTRY::NV_DELTA_ENTRY()
-{
-	memset(this, 0, sizeof *this);
-}
-
-NV_GPU_PSTATES20_V2::NV_GPU_PSTATES20_V2()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_GPU_PSTATES20_V2, 2);
-}
-
-NV_CLOCK_FREQUENCIES_V2::NV_CLOCK_FREQUENCIES_V2()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_CLOCK_FREQUENCIES_V2, 2);
-}
-
-NV_GPU_PERFORMANCE_TABLE_V1::NV_GPU_PERFORMANCE_TABLE_V1()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_GPU_PERFORMANCE_TABLE_V1, 1);
-}
-
-NV_DYNAMIC_PSTATES_V1::NV_DYNAMIC_PSTATES_V1()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_DYNAMIC_PSTATES_V1, 1);
-}
-
-NV_GPU_POWER_POLICIES_INFO_V1::NV_GPU_POWER_POLICIES_INFO_V1()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_GPU_POWER_POLICIES_INFO_V1, 1);
-}
-
-NV_GPU_POWER_POLICIES_STATUS_V1::NV_GPU_POWER_POLICIES_STATUS_V1()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_GPU_POWER_POLICIES_STATUS_V1, 1);
-}
-
-NV_GPU_VOLTAGE_DOMAINS_STATUS_V1::NV_GPU_VOLTAGE_DOMAINS_STATUS_V1()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_GPU_VOLTAGE_DOMAINS_STATUS_V1, 1);
-}
-
-NV_GPU_THERMAL_SETTINGS_V2::NV_GPU_THERMAL_SETTINGS_V2()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_GPU_THERMAL_SETTINGS_V2, 2);
-}
-
-NV_GPU_THERMAL_POLICIES_INFO_V2::NV_GPU_THERMAL_POLICIES_INFO_V2()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_GPU_THERMAL_POLICIES_INFO_V2, 2);
-}
-
-NV_GPU_THERMAL_POLICIES_STATUS_V2::NV_GPU_THERMAL_POLICIES_STATUS_V2()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_GPU_THERMAL_POLICIES_STATUS_V2, 2);
-}
-
-NV_GPU_COOLER_SETTINGS_V2::NV_GPU_COOLER_SETTINGS_V2()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_GPU_COOLER_SETTINGS_V2, 2);
-}
-
-NV_GPU_COOLER_LEVELS_V1::NV_GPU_COOLER_LEVELS_V1()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_GPU_COOLER_LEVELS_V1, 1);
-}
-
-NV_MEMORY_INFO_V2::NV_MEMORY_INFO_V2()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_MEMORY_INFO_V2, 2);
-}
-
-NV_DISPLAY_DRIVER_VERSION_V1::NV_DISPLAY_DRIVER_VERSION_V1()
-{
-	memset(this, 0, sizeof *this);
-	version = NV_STRUCT_VERSION(NV_DISPLAY_DRIVER_VERSION_V1, 1);
-}
-
-NV_I2C_INFO_V3::NV_I2C_INFO_V3()
-{
-	memset(this, 0, sizeof * this);
-	version = NV_STRUCT_VERSION(NV_I2C_INFO_V3, 3);
-}
-
-// Interface: 0150E828
-static NV_STATUS (*pNvAPI_Initialize)();
-
-// Interface: D22BDD7E
-static NV_STATUS (*pNvAPI_Unload)();
-
-// Interface: 9ABDD40D
-static NV_STATUS (*pNvAPI_EnumDisplayHandle)(
-	NV_S32 this_enum,
-	NV_DISPLAY_HANDLE *display_handle);
-
-// Interface: E5AC921F
-static NV_STATUS (*pNvAPI_EnumPhysicalGPUs)(
-	NV_PHYSICAL_GPU_HANDLE *physical_gpu_handles,
-	NV_S32 *gpu_count);
-
-// Interface: F951A4D1
-static NV_STATUS (*pNvAPI_GetDisplayDriverVersion)(
-	NV_DISPLAY_HANDLE display_handle,
-	NV_DISPLAY_DRIVER_VERSION_V1 *display_driver_version);
-
-// Interface: 01053FA5
-static NV_STATUS (*pNvAPI_GetInterfaceVersionString)(
-	NV_SHORT_STRING version);
-
-// Interface: 34EF9506
-static NV_STATUS (*pNvAPI_GetPhysicalGPUsFromDisplay)(
-	NV_DISPLAY_HANDLE display_handle,
-	NV_PHYSICAL_GPU_HANDLE *gpu_handles,
-	NV_U32 *gpu_count);
-
-// Interface: 774AA982
-static NV_STATUS (*pNvAPI_GetMemoryInfo)(
-	NV_DISPLAY_HANDLE display_handle,
-	NV_MEMORY_INFO_V2 *memory_info);
-
-// Interface: 0CEEE8E9F
-static NV_STATUS (*pNvAPI_GPU_GetFullName)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_SHORT_STRING name);
-
-// Interface: 6FF81213
-static NV_STATUS (*pNvAPI_GPU_GetPStates20)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_PSTATES20_V2 *pstates);
-
-// Interface: 0F4DAE6B
-static NV_STATUS (*pNvAPI_GPU_SetPStates20)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_PSTATES20_V2 *pstates);
-
-// Interface: DCB616C3
-static NV_STATUS (*pNvAPI_GPU_GetAllClockFrequencies)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_CLOCK_FREQUENCIES_V2 *frequencies);
-
-// Interface: 60DED2ED
-static NV_STATUS (*pNvAPI_GPU_GetDynamicPStates)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_DYNAMIC_PSTATES_V1 *dynamic_pstates);
-
-// Interface: 34206D86
-static NV_STATUS (*pNvAPI_GPU_GetPowerPoliciesInfo)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_POWER_POLICIES_INFO_V1 *policies_info);
-
-// Interface: 70916171
-static NV_STATUS (*pNvAPI_GPU_GetPowerPoliciesStatus)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_POWER_POLICIES_STATUS_V1 *policies_status);
-
-// Interface: 0C16C7E2C
-static NV_STATUS (*pNvAPI_GPU_GetVoltageDomainStatus)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_VOLTAGE_DOMAINS_STATUS_V1 *voltage_domains_status);
-
-// Interface: 0E3640A56
-static NV_STATUS (*pNvAPI_GPU_GetThermalSettings)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_THERMAL_TARGET sensor_index,
-	NV_GPU_THERMAL_SETTINGS_V2 *thermal_settings);
-
-// Interface: 014B83A5F
-static NV_STATUS (*pNvAPI_GPU_GetSerialNumber)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_SHORT_STRING serial_number);
-
-// Interface: 0AD95F5ED
-static NV_STATUS (*pNvAPI_GPU_SetPowerPoliciesStatus)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_POWER_POLICIES_STATUS_V1* policies_status);
-
-// Interface: 00D258BB5
-static NV_STATUS (*pNvAPI_GPU_GetThermalPoliciesInfo)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_THERMAL_POLICIES_INFO_V2* thermal_info);
-
-// Interface: 0E9C425A1
-static NV_STATUS (*pNvAPI_GPU_GetThermalPoliciesStatus)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_THERMAL_POLICIES_STATUS_V2* thermal_status);
-
-// Interface: 034C0B13D
-static NV_STATUS (*pNvAPI_GPU_SetThermalPoliciesStatus)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_THERMAL_POLICIES_STATUS_V2* thermal_status);
-
-// Interface: DA141340
-static NV_STATUS (*pNvAPI_GPU_GetCoolerSettings)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_S32 cooler_index,
-	NV_GPU_COOLER_SETTINGS_V2 *cooler_settings);
-
-// Interface: 891FA0AE
-static NV_STATUS (*pNvAPI_GPU_SetCoolerLevels)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_S32 cooler_index,
-	NV_GPU_COOLER_LEVELS_V1 *cooler_levels);
-
-// Interface: 2DDFB66E
-static NV_STATUS (*pNvAPI_GPU_GetPCIIdentifiers)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_U32 *device_id,
-	NV_U32 *sub_system_id,
-	NV_U32 *revision_id,
-	NV_U32 *ext_device_id);
-
-// Interface: 283AC65A
-static NV_STATUS (*pNvAPI_I2CWriteEx)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_I2C_INFO_V3* i2c_info,
-	NV_U32 *unknown);
-
-// Interface: 4D7B0709
-static NV_STATUS(*pNvAPI_I2CReadEx)(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_I2C_INFO_V3* i2c_info,
-	NV_U32 *unknown);
-
-static bool QueryInterfaceOpaque(FARPROC query_interface, NV_U32 id, void **result)
-{
-	void *address = ((void *(*)(NV_U32))query_interface)(id);
-	if (address) {
-		*result = address;
-		return true;
-	}
-	return false;
-}
-
-template<typename F>
-static void QueryInterfaceCast(FARPROC query_interface, NV_U32 id, const char *function_name, F &function_pointer)
-{
-	const bool result = QueryInterfaceOpaque(query_interface, id, (void **)&function_pointer);
-    ////Log::write("%s querying interface '0x%08x' '%s'", result ? "success" : "failure", id, function_name);
-}
-
-#define QueryInterface(query_interface, id, function) \
-	QueryInterfaceCast((query_interface), (id), #function, p ## function)
-
-static void QueryInterfaces(FARPROC query_interface)
-{
-    //Log::write("querying interfaces with '0x%p'", query_interface);
-
-	QueryInterface(query_interface, 0x0150E828, NvAPI_Initialize);
-	QueryInterface(query_interface, 0xD22BDD7E, NvAPI_Unload);
-	QueryInterface(query_interface, 0x9ABDD40D, NvAPI_EnumDisplayHandle);
-	QueryInterface(query_interface, 0xE5AC921F, NvAPI_EnumPhysicalGPUs);
-	QueryInterface(query_interface, 0xF951A4D1, NvAPI_GetDisplayDriverVersion);
-	QueryInterface(query_interface, 0x01053FA5, NvAPI_GetInterfaceVersionString);
-	QueryInterface(query_interface, 0x34EF9506, NvAPI_GetPhysicalGPUsFromDisplay);
-	QueryInterface(query_interface, 0x774AA982, NvAPI_GetMemoryInfo);
-
-	QueryInterface(query_interface, 0x0CEEE8E9F, NvAPI_GPU_GetFullName);
-	QueryInterface(query_interface, 0x6FF81213, NvAPI_GPU_GetPStates20);
-	QueryInterface(query_interface, 0x0F4DAE6B, NvAPI_GPU_SetPStates20);
-	QueryInterface(query_interface, 0xDCB616C3, NvAPI_GPU_GetAllClockFrequencies); 
-	QueryInterface(query_interface, 0x60DED2ED, NvAPI_GPU_GetDynamicPStates); 
-	QueryInterface(query_interface, 0x34206D86, NvAPI_GPU_GetPowerPoliciesInfo);
-	QueryInterface(query_interface, 0x70916171, NvAPI_GPU_GetPowerPoliciesStatus);
-	QueryInterface(query_interface, 0x0C16C7E2C, NvAPI_GPU_GetVoltageDomainStatus);
-	QueryInterface(query_interface, 0x0E3640A56, NvAPI_GPU_GetThermalSettings);
-	QueryInterface(query_interface, 0x014B83A5F, NvAPI_GPU_GetSerialNumber);
-	QueryInterface(query_interface, 0x0AD95F5ED, NvAPI_GPU_SetPowerPoliciesStatus);
-	QueryInterface(query_interface, 0x00D258BB5, NvAPI_GPU_GetThermalPoliciesInfo);
-	QueryInterface(query_interface, 0x0E9C425A1, NvAPI_GPU_GetThermalPoliciesStatus);
-	QueryInterface(query_interface, 0x034C0B13D, NvAPI_GPU_SetThermalPoliciesStatus);
-	QueryInterface(query_interface, 0xDA141340, NvAPI_GPU_GetCoolerSettings);
-	QueryInterface(query_interface, 0x891FA0AE, NvAPI_GPU_SetCoolerLevels); 
-	QueryInterface(query_interface, 0x2DDFB66E, NvAPI_GPU_GetPCIIdentifiers);
-
-	QueryInterface(query_interface, 0x283AC65A, NvAPI_I2CWriteEx);
-	QueryInterface(query_interface, 0x4D7B0709, NvAPI_I2CReadEx);
-}
-
-NV_STATUS NvAPI_Initialize()
-{
-	if (!pNvAPI_Initialize) {
-		const char *name = sizeof(void*) == 4 ? "nvapi.dll" : "nvapi64.dll";
-		HMODULE nvapi = LoadLibraryA(name);
-		if (!nvapi) {
-            //Log::write("failed to load '%s'", name);
-			return -1;
-		}
-
-        //Log::write("loaded '%s' '0x%p'", name, nvapi);
-
-		FARPROC query_interface = GetProcAddress(nvapi, "nvapi_QueryInterface");
-		if (!query_interface) {
-            //Log::write("failed to find 'nvapi_QueryInterface'");
-			return -1;
-		}
-
-		QueryInterfaces(query_interface);
-	}
-
-	return pNvAPI_Initialize
-		? (*pNvAPI_Initialize)()
-		: -1;
-}
-
-NV_STATUS NvAPI_Unload()
-{
-	return pNvAPI_Unload
-		? (*pNvAPI_Unload)()
-		: -1;
-}
-
-NV_STATUS NvAPI_EnumDisplayHandle(
-	NV_S32 this_enum,
-	NV_DISPLAY_HANDLE *display_handle)
-{
-	return pNvAPI_EnumDisplayHandle
-		? (*pNvAPI_EnumDisplayHandle)(this_enum, display_handle)
-		: -1;
-}
-
-NV_STATUS NvAPI_EnumPhysicalGPUs(
-	NV_PHYSICAL_GPU_HANDLE *physical_gpu_handles,
-	NV_S32 *gpu_count)
-{
-	return pNvAPI_EnumPhysicalGPUs
-		? (*pNvAPI_EnumPhysicalGPUs)(physical_gpu_handles, gpu_count)
-		: -1;
-}
-
-NV_STATUS NvAPI_GetDisplayDriverVersion(
-	NV_DISPLAY_HANDLE display_handle,
-	NV_DISPLAY_DRIVER_VERSION_V1 *display_driver_version)
-{
-	return pNvAPI_GetDisplayDriverVersion
-		? (*pNvAPI_GetDisplayDriverVersion)(display_handle, display_driver_version)
-		: -1;
-}
-
-NV_STATUS NvAPI_GetInterfaceVersionString(
-	NV_SHORT_STRING version)
-{
-	return pNvAPI_GetInterfaceVersionString
-		? (*pNvAPI_GetInterfaceVersionString)(version)
-		: -1;
-}
-
-NV_STATUS NvAPI_GetPhysicalGPUsFromDisplay(
-	NV_DISPLAY_HANDLE display_handle,
-	NV_PHYSICAL_GPU_HANDLE *gpu_handles,
-	NV_U32 *gpu_count)
-{
-	return pNvAPI_GetPhysicalGPUsFromDisplay
-		? (*pNvAPI_GetPhysicalGPUsFromDisplay)(display_handle, gpu_handles, gpu_count)
-		: -1;
-}
-
-NV_STATUS NvAPI_GetMemoryInfo(
-	NV_DISPLAY_HANDLE display_handle,
-	NV_MEMORY_INFO_V2 *memory_info)
-{
-	return pNvAPI_GetMemoryInfo
-		? (*pNvAPI_GetMemoryInfo)(display_handle, memory_info)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_GetFullName(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_SHORT_STRING name)
-{
-	return pNvAPI_GPU_GetFullName
-		? (*pNvAPI_GPU_GetFullName)(physical_gpu_handle, name)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_GetPStates20(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_PSTATES20_V2 *pstates)
-{
-	return pNvAPI_GPU_GetPStates20
-		? (*pNvAPI_GPU_GetPStates20)(physical_gpu_handle, pstates)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_SetPStates20(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_PSTATES20_V2 *pstates)
-{
-	return pNvAPI_GPU_SetPStates20
-		? (*pNvAPI_GPU_GetPStates20)(physical_gpu_handle, pstates)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_GetAllClockFrequencies(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_CLOCK_FREQUENCIES_V2 *frequencies)
-{
-	return pNvAPI_GPU_GetAllClockFrequencies
-		? (*pNvAPI_GPU_GetAllClockFrequencies)(physical_gpu_handle, frequencies)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_GetDynamicPStates(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_DYNAMIC_PSTATES_V1 *dynamic_pstates)
-{
-	return pNvAPI_GPU_GetDynamicPStates
-		? (*pNvAPI_GPU_GetDynamicPStates)(physical_gpu_handle, dynamic_pstates)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_GetPowerPoliciesInfo(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_POWER_POLICIES_INFO_V1 *policies_info)
-{
-	return pNvAPI_GPU_GetPowerPoliciesInfo
-		? (*pNvAPI_GPU_GetPowerPoliciesInfo)(physical_gpu_handle, policies_info)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_GetPowerPoliciesStatus(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_POWER_POLICIES_STATUS_V1 *policies_status)
-{
-	return pNvAPI_GPU_GetPowerPoliciesStatus
-		? (*NvAPI_GPU_GetPowerPoliciesStatus)(physical_gpu_handle, policies_status)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_GetVoltageDomainStatus(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_VOLTAGE_DOMAINS_STATUS_V1 *voltage_domains_status)
-{
-	return pNvAPI_GPU_GetVoltageDomainStatus
-		? (*pNvAPI_GPU_GetVoltageDomainStatus)(physical_gpu_handle, voltage_domains_status)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_GetThermalSettings(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_THERMAL_TARGET sensor_index,
-	NV_GPU_THERMAL_SETTINGS_V2 *thermal_settings)
-{
-	return pNvAPI_GPU_GetThermalSettings
-		? (*pNvAPI_GPU_GetThermalSettings)(physical_gpu_handle, sensor_index, thermal_settings)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_GetSerialNumber(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_SHORT_STRING serial_number)
-{
-	return pNvAPI_GPU_GetSerialNumber
-		? (*pNvAPI_GPU_GetSerialNumber)(physical_gpu_handle, serial_number)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_SetPowerPoliciesStatus(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_POWER_POLICIES_STATUS_V1* policies_status)
-{
-	return pNvAPI_GPU_SetPowerPoliciesStatus
-		? (*pNvAPI_GPU_SetPowerPoliciesStatus)(physical_gpu_handle, policies_status)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_GetThermalPoliciesInfo(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_THERMAL_POLICIES_INFO_V2* thermal_info)
-{
-	return pNvAPI_GPU_GetThermalPoliciesInfo
-		? (*pNvAPI_GPU_GetThermalPoliciesInfo)(physical_gpu_handle, thermal_info)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_GetThermalPoliciesStatus(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_THERMAL_POLICIES_STATUS_V2* thermal_status)
-{
-	return pNvAPI_GPU_GetThermalPoliciesStatus
-		? (*pNvAPI_GPU_GetThermalPoliciesStatus)(physical_gpu_handle, thermal_status)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_SetThermalPoliciesStatus(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_THERMAL_POLICIES_STATUS_V2* thermal_status)
-{
-	return pNvAPI_GPU_SetThermalPoliciesStatus
-		? (*pNvAPI_GPU_SetThermalPoliciesStatus)(physical_gpu_handle, thermal_status)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_GetCoolerSettings(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_S32 cooler_index,
-	NV_GPU_COOLER_SETTINGS_V2 *cooler_settings)
-{
-	return pNvAPI_GPU_GetCoolerSettings
-		? (*pNvAPI_GPU_GetCoolerSettings)(physical_gpu_handle, cooler_index, cooler_settings)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_SetCoolerLevels(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_S32 cooler_index,
-	NV_GPU_COOLER_LEVELS_V1 *cooler_levels)
-{
-	return pNvAPI_GPU_SetCoolerLevels
-		? (*pNvAPI_GPU_SetCoolerLevels)(physical_gpu_handle, cooler_index, cooler_levels)
-		: -1;
-}
-
-NV_STATUS NvAPI_GPU_GetPCIIdentifiers(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_U32 *device_id,
-	NV_U32 *sub_system_id,
-	NV_U32 *revision_id,
-	NV_U32 *ext_device_id)
-{
-	return pNvAPI_GPU_GetPCIIdentifiers
-		? (*pNvAPI_GPU_GetPCIIdentifiers)(physical_gpu_handle, device_id, sub_system_id, revision_id, ext_device_id)
-		: -1;
-}
-
-NV_STATUS NvAPI_I2CWriteEx(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_I2C_INFO_V3* i2c_info,
-	NV_U32 *unknown)
-{
-	return pNvAPI_I2CWriteEx
-		? (*pNvAPI_I2CWriteEx)(physical_gpu_handle, i2c_info, unknown)
-		: -1;
-}
-
-NV_STATUS NvAPI_I2CReadEx(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_I2C_INFO_V3* i2c_info,
-	NV_U32 *unknown)
-{
-	return pNvAPI_I2CReadEx
-		? (*pNvAPI_I2CReadEx)(physical_gpu_handle, i2c_info, unknown)
-		: -1;
-}

dependencies/NVFC/nvapi.h

@@ -1,465 +0,0 @@
-#ifndef NVAPI_H
-#define NVAPI_H
-
-#include <stdint.h>
-
-typedef int32_t NV_S32;
-typedef uint32_t NV_U32;
-typedef uint8_t NV_U8;
-
-typedef NV_S32* NV_HANDLE;
-typedef NV_HANDLE NV_PHYSICAL_GPU_HANDLE;
-typedef NV_HANDLE NV_VIRTUAL_GPU_HANDLE;
-typedef NV_HANDLE NV_UNATTACHED_DISPLAY_HANDLE;
-typedef NV_HANDLE NV_DISPLAY_HANDLE;
-
-typedef char NV_SHORT_STRING[64];
-
-typedef NV_S32 NV_STATUS;
-
-#define NV_STRUCT_VERSION(STRUCT, VERSION) \
-	(((VERSION) << 16) | sizeof(STRUCT))
-
-enum class NV_CLOCK_SYSTEM : NV_S32 {
-	GPU,
-	MEMORY,
-	SHADER
-};
-
-enum class NV_DYNAMIC_PSTATES_SYSTEM : NV_S32 {
-	GPU,
-	FB,
-	VID,
-	BUS
-};
-
-struct NV_DELTA_ENTRY {
-	NV_DELTA_ENTRY();
-	NV_S32 value;
-	NV_S32 value_min;
-	NV_S32 value_max;
-};
-
-struct NV_GPU_PSTATES20_V2 {
-	NV_GPU_PSTATES20_V2();
-	NV_U32 version;
-	NV_U32 flags;
-	NV_U32 state_count;
-	NV_U32 clock_count;
-	NV_U32 voltage_count;
-	struct {
-		NV_U32 state_num;
-		NV_U32 flags;
-		struct {
-			NV_U32 domain;
-			NV_U32 type;                     // NOTE(dweiler): 0 = single frequency, 1 = dynamic frequencu
-			NV_U32 flags;                    // NOTE(dweiler): flags don't appear to be enforced by NVAPI
-			NV_DELTA_ENTRY frequency_delta;  // NOTE(dweiler): only valid when type == 1
-			NV_U32 min_or_single_frequency;  // NOTE(dweiler): only valid when type == 0
-			NV_U32 max_frequency;            // NOTE(dweiler): only valid when type == 1
-			NV_U32 voltage_domain;           // NOTE(dweiler): only valid when type == 1
-			NV_U32 min_voltage;              // NOTE(dweiler): only valid when type == 1
-			NV_U32 max_voltage;              // NOTE(dweiler): only valid when type == 1
-		} clocks[8];
-		struct {
-			NV_U32 domain;
-			NV_U32 flags;                    // NOTE(dweiler): base voltage can only be changed if bit 0 is set
-			NV_U32 voltage;
-			NV_DELTA_ENTRY voltage_delta;
-		} base_voltages[4];                  // NOTE(dweiler): base voltage (resting voltage wheen given a pstate) for all available voltage domains
-	} states[16];
-	struct {
-		NV_U32 voltage_count;
-		struct {
-			NV_U32 domain;
-			NV_U32 flags;
-			NV_U32 voltage;
-			NV_DELTA_ENTRY voltage_delta;
-		} voltages[4];
-	} over_voltage;
-};
-
-enum class NV_CLOCK_FREQUENCY_TYPE : NV_S32 {
-	CURRENT,
-	BASE,
-	BOOST,
-	LAST
-};
-
-struct NV_CLOCK_FREQUENCIES_V2 {
-	NV_CLOCK_FREQUENCIES_V2();
-	NV_U32 version;
-	NV_U32 clock_type;
-	struct {
-		NV_U32 present;
-		NV_U32 frequency;
-	} entries[32];
-};
-
-struct NV_GPU_PERFORMANCE_TABLE_V1 {
-	NV_GPU_PERFORMANCE_TABLE_V1();
-	NV_U32 version;
-	NV_U32 plevel_count;
-	NV_U32 : 32;                  // NOTE(dweiler): unknown value
-	NV_U32 domain_entries;
-	NV_U32 : 32;                  // NOTE(dweiler): unknown value
-	NV_U32 pstate_level;
-	NV_U32 : 32;                  // NOTE(dweiler): unknown value
-	struct {
-		struct {
-			NV_U32 domain;
-			NV_U32 : 32;          // NOTE(dweiler): unknown value
-			NV_U32 clock;
-			NV_U32 default_clock;
-			NV_U32 min_clock;
-			NV_U32 max_clock;
-			NV_U32 : 32;          // NOTE(dweiler): unknown value
-		} domains[32];
-		NV_U32 : 32;              // NOTE(dweiler): unknown value
-		NV_U32 setting_flags;
-	} entries[10];
-	NV_U32 unknown[450];          // NOTE(dweiler): the following block of memory is completely unknown
-};
-
-struct NV_DYNAMIC_PSTATES_V1 {
-	NV_DYNAMIC_PSTATES_V1();
-	NV_U32 version;
-	NV_U32 flags;
-	struct {
-		NV_U32 present;
-		NV_U32 value;
-	} pstates[8];
-};
-
-struct NV_GPU_POWER_POLICIES_INFO_V1 {
-	NV_GPU_POWER_POLICIES_INFO_V1();
-	NV_U32 version;
-	NV_U32 flags;
-	struct {
-		NV_U32 pstate;
-		NV_U32 : 32;              // NOTE(dweiler): unknown value
-		NV_U32 : 32;              // NOTE(dweiler): unknown value
-		NV_U32 min_power;
-		NV_U32 : 32;              // NOTE(dweiler): unknown value
-		NV_U32 : 32;              // NOTE(dweiler): unknown value
-		NV_U32 default_power;
-		NV_U32 : 32;              // NOTE(dweiler): unknown value
-		NV_U32 : 32;              // NOTE(dweiler): unknown value
-		NV_U32 max_power;
-		NV_U32 : 32;              // NOTE(dweiler): unknown value
-	} entries[4];
-};
-
-struct NV_GPU_POWER_POLICIES_STATUS_V1 {
-	NV_GPU_POWER_POLICIES_STATUS_V1();
-	NV_U32 version;
-	NV_U32 count;
-	struct {
-		NV_U32 pstate;            // NOTE(dweiler): assumed?
-		NV_U32 : 32;              // NOTE(dweiler): unknown value
-		NV_U32 power; 
-		NV_U32 : 32;              // NOTE(dweiler): unknown value
-	} entries[4];
-};
-
-struct NV_GPU_VOLTAGE_DOMAINS_STATUS_V1 {
-	NV_GPU_VOLTAGE_DOMAINS_STATUS_V1();
-	NV_U32 version;
-	NV_U32 flags;
-	NV_U32 count;
-	struct {
-		NV_U32 voltage_domain;
-		NV_U32 current_voltage;
-	} entries[16];
-};
-
-enum class NV_THERMAL_CONTROLLER : NV_S32 {
-	NONE,
-	GPU_INTERNAL,
-	ADM103,
-	MAX6649,
-	MAX1617,
-	LM99,
-	LM89,
-	LM64,
-	ADT7473,
-	SBMAX6649,
-	VBIOSEVT,
-	OS,
-	UNKNOWN = -1
-};
-
-enum class NV_THERMAL_TARGET : NV_S32 {
-	NONE         = 0,
-	GPU          = 1,
-	MEMORY       = 2,
-	POWER_SUPPLY = 4,
-	BOARD        = 8,
-	ALL          = 15,
-	UNKNOWN      = -1
-};
-
-enum class NV_I2C_SPEED : NV_U32 {
-	NVAPI_I2C_SPEED_DEFAULT,
-	NVAPI_I2C_SPEED_3KHZ,
-	NVAPI_I2C_SPEED_10KHZ,
-	NVAPI_I2C_SPEED_33KHZ,
-	NVAPI_I2C_SPEED_100KHZ,
-	NVAPI_I2C_SPEED_200KHZ,
-	NVAPI_I2C_SPEED_400KHZ
-};
-
-struct NV_GPU_THERMAL_SETTINGS_V2 {
-	NV_GPU_THERMAL_SETTINGS_V2();
-	NV_U32 version;
-	NV_U32 count;
-	struct {
-		NV_THERMAL_CONTROLLER controller;
-		NV_S32 default_min;
-		NV_S32 default_max;
-		NV_S32 current_temperature;
-		NV_THERMAL_TARGET target;
-	} sensor[3];
-};
-
-struct NV_GPU_THERMAL_POLICIES_INFO_V2 {
-	NV_GPU_THERMAL_POLICIES_INFO_V2();
-	NV_U32 version;
-	NV_U32 flags;
-	struct {
-		NV_U32 controller;    // NOTE(dweiler): can't be NV_THERMAL_CONTROLLER since this needs to be unsigned
-		NV_U32 : 32;          // NOTE(dweiler): unknown value
-		NV_S32 min;           // NOTE(dweiler): stored as multiples of 256
-		NV_S32 default_;      // NOTE(dweiler): stored as multiples of 256
-		NV_S32 max;           // NOTE(dweiler): stored as multiples of 256
-		NV_U32 default_flags; // NOTE(dweiler): bit zero of the flags indicates the thermal priority
-	} entries[4];
-};
-
-struct NV_GPU_THERMAL_POLICIES_STATUS_V2 {
-	NV_GPU_THERMAL_POLICIES_STATUS_V2();
-	NV_U32 version;
-	NV_U32 count;
-	struct {
-		NV_U32 controller;
-		NV_U32 value;         // NOTE(dweiler): stored as multiples of 256
-		NV_U32 flags;         // NOTE(dweiler): bit zero of the flags indicates the thermal priority
-	} entries[4];
-};
-
-struct NV_GPU_COOLER_SETTINGS_V2 {
-	NV_GPU_COOLER_SETTINGS_V2();
-	NV_U32 version;
-	NV_U32 count;
-	struct {
-		NV_S32 type;
-		NV_S32 controller;
-		NV_S32 default_min;
-		NV_S32 default_max;
-		NV_S32 current_min;
-		NV_S32 current_max;
-		NV_S32 current_level;
-		NV_S32 default_policy;
-		NV_S32 current_policy;
-		NV_S32 target;
-		NV_S32 control_type;
-		NV_S32 active;
-	} coolers[20];
-};
-
-struct NV_GPU_COOLER_LEVELS_V1 {
-	NV_GPU_COOLER_LEVELS_V1();
-	NV_U32 version;
-	struct {
-		NV_S32 level;
-		NV_S32 policy; // NOTE(dweiler): 0x20 is default policy, 0x01 is user supplied policy
-		               // TODO(dweiler): figure out what other policy values are valid
-	} levels[20];
-};
-
-struct NV_MEMORY_INFO_V2 {
-	NV_MEMORY_INFO_V2();
-	NV_U32 version;
-	NV_U32 values[5];
-};
-
-struct NV_DISPLAY_DRIVER_VERSION_V1 {
-	NV_DISPLAY_DRIVER_VERSION_V1();
-	NV_U32 version;
-	NV_U32 driver_version;        // NOTE(dweiler): major = (driver_version / 100), minor = (driver_version % 100)
-	NV_U32 : 32;                  // NOTE(dweiler): unknown vaue
-	NV_SHORT_STRING build_branch;
-	NV_SHORT_STRING adapter;
-};
-
-struct NV_I2C_INFO_V3 {
-	NV_I2C_INFO_V3();
-	NV_U32 version;
-	NV_U32 display_mask;
-	NV_U8 is_ddc_port;
-	NV_U8 i2c_dev_address;
-	NV_U8* i2c_reg_address;
-	NV_U32 reg_addr_size;
-	NV_U8* data;
-	NV_U32 size;
-	NV_U32 i2c_speed;
-	NV_I2C_SPEED i2c_speed_khz;
-	NV_U8 port_id;
-	NV_U32 is_port_id_set;
-};
-
-// Interface: 0150E828
-NV_STATUS NvAPI_Initialize();
-
-// Interface: D22BDD7E
-NV_STATUS NvAPI_Unload();
-
-// Interface: 9ABDD40D
-NV_STATUS NvAPI_EnumDisplayHandle(
-	NV_S32 this_enum,
-	NV_DISPLAY_HANDLE *display_handle);
-
-// Interface: E5AC921F
-NV_STATUS NvAPI_EnumPhysicalGPUs(
-	NV_PHYSICAL_GPU_HANDLE *physical_gpu_handles,
-	NV_S32 *gpu_count);
-
-// Interface: F951A4D1
-NV_STATUS NvAPI_GetDisplayDriverVersion(
-	NV_DISPLAY_HANDLE display_handle,
-	NV_DISPLAY_DRIVER_VERSION_V1 *display_driver_version);
-
-// Interface: 01053FA5
-NV_STATUS NvAPI_GetInterfaceVersionString(
-	NV_SHORT_STRING version);
-
-// Interface: 34EF9506
-NV_STATUS NvAPI_GetPhysicalGPUsFromDisplay(
-	NV_DISPLAY_HANDLE display_handle,
-	NV_PHYSICAL_GPU_HANDLE *gpu_handles,
-	NV_U32 *gpu_count);
-
-// Interface: 774AA982
-NV_STATUS NvAPI_GetMemoryInfo(
-	NV_DISPLAY_HANDLE display_handle,
-	NV_MEMORY_INFO_V2 *memory_info);
-
-// Interface: 0CEEE8E9F
-NV_STATUS NvAPI_GPU_GetFullName(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_SHORT_STRING name);
-
-// Interface: 6FF81213
-NV_STATUS NvAPI_GPU_GetPStates20(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_PSTATES20_V2 *pstates);
-
-// Interface: 0F4DAE6B
-NV_STATUS NvAPI_GPU_SetPStates20(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_PSTATES20_V2 *pstates);
-
-// Get frequencies of all clocks of the GPU
-//
-// The actual frequencies (current, base, boost) returned is based on the value
-// set in frequencies->clock_type before calling this function. The value values
-// are part of the NV_CLOCK_FREQUENCY_TYPE enumeration.
-//
-// Interface: DCB616C3
-NV_STATUS NvAPI_GPU_GetAllClockFrequencies(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_CLOCK_FREQUENCIES_V2 *frequencies);
-
-// Interface: 60DED2ED
-NV_STATUS NvAPI_GPU_GetDynamicPStates(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_DYNAMIC_PSTATES_V1 *dynamic_pstates);
-
-// Interface: 34206D86
-NV_STATUS NvAPI_GPU_GetPowerPoliciesInfo(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_POWER_POLICIES_INFO_V1 *policies_info);
-
-// Interface: 70916171
-NV_STATUS NvAPI_GPU_GetPowerPoliciesStatus(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_POWER_POLICIES_STATUS_V1 *policies_status);
-
-// Interface: 0C16C7E2C
-NV_STATUS NvAPI_GPU_GetVoltageDomainStatus(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_VOLTAGE_DOMAINS_STATUS_V1 *voltage_domains_status);
-
-// Get the thermal settings of the GPU
-//
-// The value of [sensor_index] must be one of the values of NV_THERMAL_TARGET,
-// either a single sensor, or the special value NV_THERMAL_TARGET::ALL for all
-// sensors present on the GPU
-//
-// Interface: 0E3640A56
-NV_STATUS NvAPI_GPU_GetThermalSettings(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_THERMAL_TARGET sensor_index,
-	NV_GPU_THERMAL_SETTINGS_V2 *thermal_settings);
-
-// Get the serial number of the GPU
-//
-// The NV_SHORT_STRING will be filled out accordingly
-//
-// Interface: 014B83A5F
-NV_STATUS NvAPI_GPU_GetSerialNumber(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_SHORT_STRING serial_number);
-
-// Interface: 0AD95F5ED
-NV_STATUS NvAPI_GPU_SetPowerPoliciesStatus(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_POWER_POLICIES_STATUS_V1* policies_status);
-
-// Interface: 00D258BB5
-NV_STATUS NvAPI_GPU_GetThermalPoliciesInfo(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_THERMAL_POLICIES_INFO_V2* thermal_info);
-
-// Interface: 0E9C425A1
-NV_STATUS NvAPI_GPU_GetThermalPoliciesStatus(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_THERMAL_POLICIES_STATUS_V2* thermal_status);
-
-// Interface: 034C0B13D
-NV_STATUS NvAPI_GPU_SetThermalPoliciesStatus(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_GPU_THERMAL_POLICIES_STATUS_V2* thermal_status);
-
-// Interface: DA141340
-NV_STATUS NvAPI_GPU_GetCoolerSettings(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_S32 cooler_index,
-	NV_GPU_COOLER_SETTINGS_V2 *cooler_settings);
-
-// Interface: 891FA0AE
-NV_STATUS NvAPI_GPU_SetCoolerLevels(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_S32 cooler_index,
-	NV_GPU_COOLER_LEVELS_V1 *cooler_levels);
-
-// Interface: 2DDFB66E
-NV_STATUS NvAPI_GPU_GetPCIIdentifiers(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_U32 *device_id,
-	NV_U32 *sub_system_id,
-	NV_U32 *revision_id,
-	NV_U32 *ext_device_id);
-
-// Interface: 283AC65A
-NV_STATUS NvAPI_I2CWriteEx(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_I2C_INFO_V3 *i2c_info,
-	NV_U32 *unknown);
-
-// Interface: 4D7B0709
-NV_STATUS NvAPI_I2CReadEx(
-	NV_PHYSICAL_GPU_HANDLE physical_gpu_handle,
-	NV_I2C_INFO_V3* i2c_info,
-	NV_U32 *unknown);
-#endif

dependencies/hidapi/hidapi/hidapi.h

@@ -30,7 +30,7 @@
 #include <wchar.h>
 
 #ifdef _WIN32
-      #define HID_API_EXPORT
+      #define HID_API_EXPORT __declspec(dllexport)
       #define HID_API_CALL
 #else
       #define HID_API_EXPORT /**< API export macro */
@@ -69,9 +69,13 @@ extern "C" {
 			    (Windows/Mac only).*/
 			unsigned short usage;
 			/** The USB interface which this logical device
-			    represents. Valid on both Linux implementations
-			    in all cases, and valid on the Windows implementation
-			    only if the device contains more than one interface. */
+			    represents.
+
+				* Valid on both Linux implementations in all cases.
+				* Valid on the Windows implementation only if the device
+				  contains more than one interface.
+				* Valid on the Mac implementation if and only if the device
+				  is a USB HID device. */
 			int interface_number;
 
 			/** Pointer to the next device */
@@ -125,7 +129,7 @@ extern "C" {
 
 		    @returns
 		    	This function returns a pointer to a linked list of type
-		    	struct #hid_device, containing information about the HID devices
+		    	struct #hid_device_info, containing information about the HID devices
 		    	attached to the system, or NULL in the case of failure. Free
 		    	this linked list by calling hid_free_enumeration().
 		*/
@@ -191,7 +195,7 @@ extern "C" {
 			the Control Endpoint (Endpoint 0).
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param data The data to send, including the report number as
 				the first byte.
 			@param length The length in bytes of the data to send.
@@ -200,7 +204,7 @@ extern "C" {
 				This function returns the actual number of bytes written and
 				-1 on error.
 		*/
-		int  HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned char *data, size_t length);
+		int  HID_API_EXPORT HID_API_CALL hid_write(hid_device *dev, const unsigned char *data, size_t length);
 
 		/** @brief Read an Input report from a HID device with timeout.
 
@@ -209,7 +213,7 @@ extern "C" {
 			contain the Report number if the device uses numbered reports.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param data A buffer to put the read data into.
 			@param length The number of bytes to read. For devices with
 				multiple reports, make sure to read an extra byte for
@@ -230,7 +234,7 @@ extern "C" {
 			contain the Report number if the device uses numbered reports.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param data A buffer to put the read data into.
 			@param length The number of bytes to read. For devices with
 				multiple reports, make sure to read an extra byte for
@@ -241,7 +245,7 @@ extern "C" {
 				-1 on error. If no packet was available to be read and
 				the handle is in non-blocking mode, this function returns 0.
 		*/
-		int  HID_API_EXPORT HID_API_CALL hid_read(hid_device *device, unsigned char *data, size_t length);
+		int  HID_API_EXPORT HID_API_CALL hid_read(hid_device *dev, unsigned char *data, size_t length);
 
 		/** @brief Set the device handle to be non-blocking.
 
@@ -253,7 +257,7 @@ extern "C" {
 			Nonblocking can be turned on and off at any time.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param nonblock enable or not the nonblocking reads
 			 - 1 to enable nonblocking
 			 - 0 to disable nonblocking.
@@ -261,7 +265,7 @@ extern "C" {
 			@returns
 				This function returns 0 on success and -1 on error.
 		*/
-		int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *device, int nonblock);
+		int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *dev, int nonblock);
 
 		/** @brief Send a Feature report to the device.
 
@@ -279,7 +283,7 @@ extern "C" {
 			in would be 17.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param data The data to send, including the report number as
 				the first byte.
 			@param length The length in bytes of the data to send, including
@@ -289,7 +293,7 @@ extern "C" {
 				This function returns the actual number of bytes written and
 				-1 on error.
 		*/
-		int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *device, const unsigned char *data, size_t length);
+		int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length);
 
 		/** @brief Get a feature report from a HID device.
 
@@ -300,7 +304,7 @@ extern "C" {
 			start in data[1].
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param data A buffer to put the read data into, including
 				the Report ID. Set the first byte of @p data[] to the
 				Report ID of the report to be read, or set it to zero
@@ -314,55 +318,55 @@ extern "C" {
 				one for the report ID (which is still in the first
 				byte), or -1 on error.
 		*/
-		int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *device, unsigned char *data, size_t length);
+		int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length);
 
 		/** @brief Close a HID device.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 		*/
-		void HID_API_EXPORT HID_API_CALL hid_close(hid_device *device);
+		void HID_API_EXPORT HID_API_CALL hid_close(hid_device *dev);
 
 		/** @brief Get The Manufacturer String from a HID device.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param string A wide string buffer to put the data into.
 			@param maxlen The length of the buffer in multiples of wchar_t.
 
 			@returns
 				This function returns 0 on success and -1 on error.
 		*/
-		int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *device, wchar_t *string, size_t maxlen);
+		int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen);
 
 		/** @brief Get The Product String from a HID device.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param string A wide string buffer to put the data into.
 			@param maxlen The length of the buffer in multiples of wchar_t.
 
 			@returns
 				This function returns 0 on success and -1 on error.
 		*/
-		int HID_API_EXPORT_CALL hid_get_product_string(hid_device *device, wchar_t *string, size_t maxlen);
+		int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen);
 
 		/** @brief Get The Serial Number String from a HID device.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param string A wide string buffer to put the data into.
 			@param maxlen The length of the buffer in multiples of wchar_t.
 
 			@returns
 				This function returns 0 on success and -1 on error.
 		*/
-		int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *device, wchar_t *string, size_t maxlen);
+		int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen);
 
 		/** @brief Get a string from a HID device, based on its string index.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param string_index The index of the string to get.
 			@param string A wide string buffer to put the data into.
 			@param maxlen The length of the buffer in multiples of wchar_t.
@@ -370,18 +374,18 @@ extern "C" {
 			@returns
 				This function returns 0 on success and -1 on error.
 		*/
-		int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *device, int string_index, wchar_t *string, size_t maxlen);
+		int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen);
 
 		/** @brief Get a string describing the last error which occurred.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 
 			@returns
 				This function returns a string containing the last error
 				which occurred or NULL if none has occurred.
 		*/
-		HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *device);
+		HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *dev);
 
 #ifdef __cplusplus
 }

dependencies/inpout32_1501/x64/inpout32.h

@@ -1,32 +0,0 @@
-#pragma once
-
-//Functions exported from DLL.
-//For easy inclusion is user projects.
-//Original InpOut32 function support
-void	_stdcall Out32(short PortAddress, short data);
-short	_stdcall Inp32(short PortAddress);
-
-//My extra functions for making life easy
-BOOL	_stdcall IsInpOutDriverOpen();  //Returns TRUE if the InpOut driver was opened successfully
-BOOL	_stdcall IsXP64Bit();			//Returns TRUE if the OS is 64bit (x64) Windows.
-
-//DLLPortIO function support
-UCHAR   _stdcall DlPortReadPortUchar (USHORT port);
-void    _stdcall DlPortWritePortUchar(USHORT port, UCHAR Value);
-
-USHORT  _stdcall DlPortReadPortUshort (USHORT port);
-void    _stdcall DlPortWritePortUshort(USHORT port, USHORT Value);
-
-ULONG	_stdcall DlPortReadPortUlong(ULONG port);
-void	_stdcall DlPortWritePortUlong(ULONG port, ULONG Value);
-
-//WinIO function support (Untested and probably does NOT work - esp. on x64!)
-PBYTE	_stdcall MapPhysToLin(PBYTE pbPhysAddr, DWORD dwPhysSize, HANDLE *pPhysicalMemoryHandle);
-BOOL	_stdcall UnmapPhysicalMemory(HANDLE PhysicalMemoryHandle, PBYTE pbLinAddr);
-BOOL	_stdcall GetPhysLong(PBYTE pbPhysAddr, PDWORD pdwPhysVal);
-BOOL	_stdcall SetPhysLong(PBYTE pbPhysAddr, DWORD dwPhysVal);
-
-
-
-
-

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

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

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

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

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

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

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

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

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

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

i2c_smbus/i2c_smbus_i801.cpp

@@ -12,6 +12,8 @@
 #include <Windows.h>
 #include "inpout32.h"
 
+#pragma comment(lib, "inpout32.lib")
+
 /* Return negative errno on error. */
 s32 i2c_smbus_i801::i801_access(u16 addr, char read_write, u8 command, int size, i2c_smbus_data *data)
 {
@@ -478,4 +480,4 @@ int i2c_smbus_i801::i801_wait_intr()
 s32 i2c_smbus_i801::i2c_smbus_xfer(u8 addr, char read_write, u8 command, int size, i2c_smbus_data* data)
 {
     return i801_access(addr, read_write, command, size, data);
-}
+}

i2c_smbus/i2c_smbus_nct6775.cpp

@@ -10,6 +10,8 @@
 #include <Windows.h>
 #include "inpout32.h"
 
+#pragma comment(lib, "inpout32.lib")
+
 s32 i2c_smbus_nct6775::nct6775_access(u16 addr, char read_write, u8 command, int size, i2c_smbus_data *data)
 {
     int i, len, status, cnt;
@@ -155,4 +157,4 @@ s32 i2c_smbus_nct6775::nct6775_access(u16 addr, char read_write, u8 command, int
 s32 i2c_smbus_nct6775::i2c_smbus_xfer(u8 addr, char read_write, u8 command, int size, i2c_smbus_data* data)
 {
     return nct6775_access(addr, read_write, command, size, data);
-}
+}

i2c_smbus/i2c_smbus_nvapi.cpp

@@ -1,102 +0,0 @@
-/*-----------------------------------------*\
-|  i2c_smbus_nvapi.cpp                      |
-|                                           |
-|  NVidia NvAPI I2C driver for Windows      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/21/2020   |
-\*-----------------------------------------*/
-
-#include "i2c_smbus_nvapi.h"
-
-i2c_smbus_nvapi::i2c_smbus_nvapi(NV_PHYSICAL_GPU_HANDLE handle)
-{
-    this->handle = handle;
-}
-
-s32 i2c_smbus_nvapi::i2c_smbus_xfer(u8 addr, char read_write, u8 command, int size, i2c_smbus_data* data)
-{
-    NV_STATUS ret;
-    unsigned int unknown = 0;
-    NV_I2C_INFO_V3 i2c_data;
-    uint8_t data_buf[8];
-    uint8_t chip_addr;
-	
-    // Set up chip register address to command, one byte in length
-    chip_addr = command;
-    i2c_data.i2c_reg_address = &chip_addr;
-    i2c_data.reg_addr_size = 1;
-
-    // Set up data buffer, zero bytes in length
-	i2c_data.data = data_buf;
-	i2c_data.size = 0;
-
-    // Always use GPU port 1 - this is where RGB controllers are attached
-	i2c_data.is_ddc_port = 0;
-    i2c_data.port_id = 1;
-	i2c_data.is_port_id_set = 1;
-
-    // Use default speed
-	i2c_data.i2c_speed = 0xFFFF;
-	i2c_data.i2c_speed_khz = NV_I2C_SPEED::NVAPI_I2C_SPEED_DEFAULT;
-
-    // Load device address
-    i2c_data.i2c_dev_address = (addr << 1) | read_write;
-
-	switch (size)
-	{
-	case I2C_SMBUS_QUICK:
-        // This is not supported by the driver it seems
-        i2c_data.reg_addr_size = 0;
-        i2c_data.size = 0;
-        break;
-
-    case I2C_SMBUS_BYTE:
-        // One byte of data with no register address
-        i2c_data.reg_addr_size = 0;
-        data_buf[0] = command;
-        i2c_data.size = 1;
-        break;
-
-    case I2C_SMBUS_BYTE_DATA:
-        // One byte of data with one byte of register address
-        data_buf[0] = data->byte;
-        i2c_data.size = 1;
-        break;
-
-    case I2C_SMBUS_WORD_DATA:
-        // One word of data with one byte of register address
-        data_buf[0] = (data->word & 0x00ff);
-        data_buf[1] = (data->word & 0xff00) >> 8;
-        i2c_data.size = 2;
-        break;
-
-    // Not supported
-    case I2C_SMBUS_BLOCK_DATA:
-        return -1;
-        break;
-
-	default:
-        return -1;
-    }
-
-    // Perform read or write
-    if(read_write == I2C_SMBUS_WRITE)
-    {
-        ret = NvAPI_I2CWriteEx(handle, &i2c_data, &unknown);
-    }
-    else
-    {
-        ret = NvAPI_I2CReadEx(handle, &i2c_data, &unknown);
-
-        if(i2c_data.size == 1)
-        {
-            data->byte = i2c_data.data[0];
-        }
-        else
-        {
-            data->word = (i2c_data.data[0] | (i2c_data.data[1] << 8));
-        }
-    }
-    
-    return(ret);
-}

i2c_smbus/i2c_smbus_nvapi.h

@@ -1,24 +0,0 @@
-/*-----------------------------------------*\
-|  i2c_smbus_nvapi.h                        |
-|                                           |
-|  Definitions and types for NVidia NvAPI   |
-|  I2C driver                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/21/2020   |
-\*-----------------------------------------*/
-
-#include "i2c_smbus.h"
-#include "nvapi.h"
-
-#pragma once
-
-class i2c_smbus_nvapi : public i2c_smbus_interface
-{
-public:
-    i2c_smbus_nvapi(NV_PHYSICAL_GPU_HANDLE handle);
-
-private:
-    s32 i2c_smbus_xfer(u8 addr, char read_write, u8 command, int size, i2c_smbus_data* data);
-
-    NV_PHYSICAL_GPU_HANDLE handle;
-};

i2c_smbus/i2c_smbus_piix4.cpp

@@ -12,6 +12,8 @@
 #include <Windows.h>
 #include "inpout32.h"
 
+#pragma comment(lib, "inpout32.lib")
+
 //Logic adapted from piix4_transaction() in i2c-piix4.c
 int i2c_smbus_piix4::piix4_transaction()
 {
@@ -167,4 +169,4 @@ s32 i2c_smbus_piix4::piix4_access(u16 addr, char read_write, u8 command, int siz
 s32 i2c_smbus_piix4::i2c_smbus_xfer(u8 addr, char read_write, u8 command, int size, i2c_smbus_data* data)
 {
     return piix4_access(addr, read_write, command, size, data);
-}
+}

main.cpp

@@ -19,9 +19,6 @@
 extern std::vector<i2c_smbus_interface*> busses;
 extern std::vector<RGBController*> rgb_controllers;
 
-// See cli.cpp
-extern int cli_main(int argc, char *argv[]);
-
 /******************************************************************************************\
 *                                                                                          *
 *   main                                                                                   *
@@ -32,11 +29,6 @@ extern int cli_main(int argc, char *argv[]);
 
 int main(int argc, char* argv[])
 {
-    if (argc > 1 && strcmp(argv[1], "--gui"))
-    {
-        return cli_main(argc, argv);
-    }
-
     DetectRGBControllers();
 
     QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);

qt/OpenRGBDeviceInfoPage.cpp

@@ -8,7 +8,38 @@ OpenRGBDeviceInfoPage::OpenRGBDeviceInfoPage(RGBController *dev, QWidget *parent
 {
     ui->setupUi(this);
 
-    ui->TypeValue->setText(device_type_to_str(dev->type).c_str());
+    switch(dev->type)
+    {
+    case DEVICE_TYPE_MOTHERBOARD:
+        ui->TypeValue->setText("Motherboard");
+        break;
+    case DEVICE_TYPE_DRAM:
+        ui->TypeValue->setText("DRAM");
+        break;
+    case DEVICE_TYPE_GPU:
+        ui->TypeValue->setText("GPU");
+        break;
+    case DEVICE_TYPE_COOLER:
+        ui->TypeValue->setText("Cooler");
+        break;
+    case DEVICE_TYPE_LEDSTRIP:
+        ui->TypeValue->setText("LED Strip");
+        break;
+    case DEVICE_TYPE_KEYBOARD:
+        ui->TypeValue->setText("Keyboard");
+        break;
+    case DEVICE_TYPE_MOUSE:
+        ui->TypeValue->setText("Mouse");
+        break;
+    case DEVICE_TYPE_MOUSEMAT:
+        ui->TypeValue->setText("Mousemat");
+        break;
+    case DEVICE_TYPE_HEADSET:
+        ui->TypeValue->setText("Headset");
+        break;
+    default:
+        ui->TypeValue->setText("Unknown");
+    }
 
     ui->NameValue->setText(QString::fromStdString(dev->name));
     ui->DescriptionValue->setText(QString::fromStdString(dev->description));

qt/OpenRGBDevicePage.cpp

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

qt/OpenRGBDevicePage.h

@@ -20,7 +20,6 @@ public:
 
     void SetDevice(unsigned char red, unsigned char green, unsigned char blue);
     void SetCustomMode();
-    void UpdateDevice();
     void UpdateMode();
     void UpdateModeUi();
 
@@ -52,10 +51,6 @@ private slots:
 
     void on_DirectionBox_currentIndexChanged(int index);
 
-    void on_PerLEDCheck_clicked();
-
-    void on_ModeSpecificCheck_clicked();
-
 private:
     Ui::OpenRGBDevicePageUi *ui;
     RGBController *device;

qt/OpenRGBDevicePage.ui

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

qt/OpenRGBDialog2.cpp

@@ -1,18 +1,9 @@
-#include <fstream>
 #include "OpenRGBDialog2.h"
 #include "OpenRGBDevicePage.h"
 #include "OpenRGBDeviceInfoPage.h"
-#include "OpenRGBSoftwareInfoPage.h"
 #include "OpenRGBSystemInfoPage.h"
-#include "OpenRGBProfileSaveDialog.h"
-#include "RGBController_Dummy.h"
 #include <QLabel>
 #include <QTabBar>
-#define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING
-#include <experimental/filesystem>
-#include <iostream>
-
-namespace fs = std::experimental::filesystem;
 
 using namespace Ui;
 
@@ -23,44 +14,6 @@ OpenRGBDialog2::OpenRGBDialog2(std::vector<i2c_smbus_interface *>& bus, std::vec
     QIcon logo(":OpenRGB.png");
     setWindowIcon(logo);
 
-    /*---------------------------------------------------------*\
-    | Load profiles by looking for .orp files in current dir    |
-    \*---------------------------------------------------------*/
-    for(const auto & entry : fs::directory_iterator("."))
-    {
-        std::string filename = entry.path().filename().string();
-
-        if(filename.find(".orp") != std::string::npos)
-        {
-            /*---------------------------------------------------------*\
-            | Open input file in binary mode                            |
-            \*---------------------------------------------------------*/
-            std::ifstream profile_file(filename, std::ios::in | std::ios::binary);
-
-            /*---------------------------------------------------------*\
-            | Read and verify file header                               |
-            \*---------------------------------------------------------*/
-            char            header_string[16];
-            unsigned int    header_version;
-
-            profile_file.read(header_string, 16);
-            profile_file.read((char *)&header_version, sizeof(unsigned int));
-
-            if(strcmp(header_string, "OPENRGB_PROFILE") == 0)
-            {
-                if(header_version == 1)
-                {
-                    /*---------------------------------------------------------*\
-                    | Add this profile to the list                              |
-                    \*---------------------------------------------------------*/
-                    ui->comboBox->addItem(filename.c_str());
-                }
-            }
-
-            profile_file.close();
-        }
-    }
-
     /*-----------------------------------------------------*\
     | Set up tray icon menu                                 |
     \*-----------------------------------------------------*/
@@ -72,18 +25,6 @@ OpenRGBDialog2::OpenRGBDialog2(std::vector<i2c_smbus_interface *>& bus, std::vec
     connect(actionShowHide, SIGNAL(triggered()), this, SLOT(on_ShowHide()));
     trayIconMenu->addAction(actionShowHide);
 
-    QMenu* profileMenu = new QMenu("Profiles", this);
-
-    for(int profile_index = 0; profile_index < ui->comboBox->count(); profile_index++)
-    {
-        QAction* actionProfileSelected = new QAction(ui->comboBox->itemText(profile_index), this);
-        actionProfileSelected->setObjectName(ui->comboBox->itemText(profile_index));
-        connect(actionProfileSelected, SIGNAL(triggered()), this, SLOT(on_ProfileSelected()));
-        profileMenu->addAction(actionProfileSelected);
-    }
-
-    trayIconMenu->addMenu(profileMenu);
-
     QMenu* quickColorsMenu = new QMenu("Quick Colors", this);
 
     QAction* actionQuickRed = new QAction("Red", this);
@@ -259,25 +200,6 @@ OpenRGBDialog2::OpenRGBDialog2(std::vector<i2c_smbus_interface *>& bus, std::vec
     SystemTabLabel->setGeometry(0, 0, 200, 20);
 
     InformationTabBar->setTabButton(control.size(), QTabBar::LeftSide, SystemTabLabel);
-
-    OpenRGBSoftwareInfoPage *SoftInfoPage = new OpenRGBSoftwareInfoPage();
-    ui->InformationTabBar->addTab(SoftInfoPage, "");
-
-    /*-----------------------------------------------------*\
-    | Use Qt's HTML capabilities to display both icon and   |
-    | text in the tab label.  Choose icon based on device   |
-    | type and append device name string.                   |
-    \*-----------------------------------------------------*/
-    QString SoftwareLabelString = "<html><table><tr><td width='30'><img src='";
-    SoftwareLabelString += ":/keyboard.svg";
-    SoftwareLabelString += "' height='15' width='15'></td><td>Software</td></tr></table></html>";
-
-    QLabel *SoftwareTabLabel = new QLabel();
-    SoftwareTabLabel->setText(SoftwareLabelString);
-    SoftwareTabLabel->setIndent(20);
-    SoftwareTabLabel->setGeometry(0, 0, 200, 20);
-
-    InformationTabBar->setTabButton(control.size() + 1, QTabBar::LeftSide, SoftwareTabLabel);
 }
 
 OpenRGBDialog2::~OpenRGBDialog2()
@@ -354,309 +276,4 @@ void OpenRGBDialog2::on_ShowHide()
     {
         hide();
     }
-}
-
-void Ui::OpenRGBDialog2::on_ProfileSelected()
-{
-    std::vector<RGBController*> temp_controllers;
-    unsigned int controller_size;
-    unsigned int controller_offset = 0;
-
-    std::string filename = QObject::sender()->objectName().toStdString();
-
-    /*---------------------------------------------------------*\
-    | Open input file in binary mode                            |
-    \*---------------------------------------------------------*/
-    std::ifstream controller_file(filename, std::ios::in | std::ios::binary);
-
-    /*---------------------------------------------------------*\
-    | Read and verify file header                               |
-    \*---------------------------------------------------------*/
-    char            header_string[16];
-    unsigned int    header_version;
-
-    controller_file.read(header_string, 16);
-    controller_file.read((char *)&header_version, sizeof(unsigned int));
-
-    controller_offset += 16 + sizeof(unsigned int);
-    controller_file.seekg(controller_offset);
-
-    if(strcmp(header_string, "OPENRGB_PROFILE") == 0)
-    {
-        if(header_version == 1)
-        {
-            /*---------------------------------------------------------*\
-            | Read controller data from file until EOF                  |
-            \*---------------------------------------------------------*/
-            while(!(controller_file.peek() == EOF))
-            {
-                controller_file.read((char *)&controller_size, sizeof(controller_size));
-
-                unsigned char *controller_data = new unsigned char[controller_size];
-
-                controller_file.seekg(controller_offset);
-
-                controller_file.read((char *)controller_data, controller_size);
-
-                RGBController_Dummy *temp_controller = new RGBController_Dummy();
-
-                temp_controller->ReadDeviceDescription(controller_data);
-
-                temp_controllers.push_back(temp_controller);
-
-                delete[] controller_data;
-
-                controller_offset += controller_size;
-                controller_file.seekg(controller_offset);
-            }
-
-            for(int controller_index = 0; controller_index < controllers.size(); controller_index++)
-            {
-                RGBController *temp_controller = temp_controllers[controller_index];
-                RGBController *controller_ptr = controllers[controller_index];
-
-                /*---------------------------------------------------------*\
-                | Test if saved controller data matches this controller     |
-                \*---------------------------------------------------------*/
-                if((temp_controller->type        == controller_ptr->type       )
-                 &&(temp_controller->name        == controller_ptr->name       )
-                 &&(temp_controller->description == controller_ptr->description)
-                 &&(temp_controller->version     == controller_ptr->version    )
-                 &&(temp_controller->serial      == controller_ptr->serial     )
-                 &&(temp_controller->location    == controller_ptr->location   ))
-                {
-                    /*---------------------------------------------------------*\
-                    | Update all modes                                          |
-                    \*---------------------------------------------------------*/
-                    if(temp_controller->modes.size() == controller_ptr->modes.size())
-                    {
-                        for(int mode_index = 0; mode_index < temp_controller->modes.size(); mode_index++)
-                        {
-                            if((temp_controller->modes[mode_index].name       == controller_ptr->modes[mode_index].name      )
-                             &&(temp_controller->modes[mode_index].value      == controller_ptr->modes[mode_index].value     )
-                             &&(temp_controller->modes[mode_index].flags      == controller_ptr->modes[mode_index].flags     )
-                             &&(temp_controller->modes[mode_index].speed_min  == controller_ptr->modes[mode_index].speed_min )
-                             &&(temp_controller->modes[mode_index].speed_max  == controller_ptr->modes[mode_index].speed_max )
-                             &&(temp_controller->modes[mode_index].colors_min == controller_ptr->modes[mode_index].colors_min)
-                             &&(temp_controller->modes[mode_index].colors_max == controller_ptr->modes[mode_index].colors_max))
-                            {
-                                controller_ptr->modes[mode_index].speed      = temp_controller->modes[mode_index].speed;
-                                controller_ptr->modes[mode_index].direction  = temp_controller->modes[mode_index].direction;
-                                controller_ptr->modes[mode_index].color_mode = temp_controller->modes[mode_index].color_mode;
-
-                                controller_ptr->modes[mode_index].colors.resize(temp_controller->modes[mode_index].colors.size());
-
-                                for(int mode_color_index = 0; mode_color_index < temp_controller->modes[mode_index].colors.size(); mode_color_index++)
-                                {
-                                    controller_ptr->modes[mode_index].colors[mode_color_index] = temp_controller->modes[mode_index].colors[mode_color_index];
-                                }
-                            }
-
-                        }
-
-                        controller_ptr->active_mode = temp_controller->active_mode;
-                    }
-
-                    /*---------------------------------------------------------*\
-                    | Update all colors                                         |
-                    \*---------------------------------------------------------*/
-                    if(temp_controller->colors.size() == controller_ptr->colors.size())
-                    {
-                        for(int color_index = 0; color_index < temp_controller->colors.size(); color_index++)
-                        {
-                            controller_ptr->colors[color_index] = temp_controller->colors[color_index];
-                        }
-                    }
-                }
-            }
-        }
-
-        for(int device = 0; device < ui->DevicesTabBar->count(); device++)
-        {
-            qobject_cast<OpenRGBDevicePage *>(ui->DevicesTabBar->widget(device))->UpdateDevice();
-        }
-    }
-}
-
-void Ui::OpenRGBDialog2::on_ButtonSaveProfile_clicked()
-{
-    OpenRGBProfileSaveDialog dialog;
-
-    /*---------------------------------------------------------*\
-    | Open Profile Name Dialog                                  |
-    \*---------------------------------------------------------*/
-    std::string profile_name = dialog.show();
-
-    /*---------------------------------------------------------*\
-    | If a name was entered, save the profile file              |
-    \*---------------------------------------------------------*/
-    if(profile_name != "")
-    {
-        /*---------------------------------------------------------*\
-        | Extension .orp - OpenRgb Profile                          |
-        \*---------------------------------------------------------*/
-        std::string filename = profile_name + ".orp";
-
-        /*---------------------------------------------------------*\
-        | Open an output file in binary mode                        |
-        \*---------------------------------------------------------*/
-        std::ofstream controller_file(filename, std::ios::out | std::ios::binary);
-
-        /*---------------------------------------------------------*\
-        | Write header                                              |
-        | 16 bytes - "OPENRGB_PROFILE"                              |
-        | 4 bytes - Version, unsigned int                           |
-        \*---------------------------------------------------------*/
-        unsigned int profile_version = 1;
-        controller_file.write("OPENRGB_PROFILE", 16);
-        controller_file.write((char *)&profile_version, sizeof(unsigned int));
-
-        /*---------------------------------------------------------*\
-        | Write controller data for each controller                 |
-        \*---------------------------------------------------------*/
-        for(int controller_index = 0; controller_index < controllers.size(); controller_index++)
-        {
-            unsigned char *controller_data = controllers[controller_index]->GetDeviceDescription();
-            unsigned int controller_size;
-
-            memcpy(&controller_size, controller_data, sizeof(controller_size));
-
-            controller_file.write((const char *)controller_data, controller_size);
-        }
-
-        /*---------------------------------------------------------*\
-        | Close the file when done                                  |
-        \*---------------------------------------------------------*/
-        controller_file.close();
-
-        /*---------------------------------------------------------*\
-        | Add the new file to the profile list                      |
-        \*---------------------------------------------------------*/
-        ui->comboBox->addItem(filename.c_str());
-    }
-}
-
-void Ui::OpenRGBDialog2::on_ButtonLoadProfile_clicked()
-{
-    std::vector<RGBController*> temp_controllers;
-    unsigned int controller_size;
-    unsigned int controller_offset = 0;
-
-    /*---------------------------------------------------------*\
-    | Get the profile filename from the profiles list           |
-    \*---------------------------------------------------------*/
-    std::string filename = ui->comboBox->currentText().toStdString();
-
-    /*---------------------------------------------------------*\
-    | Open input file in binary mode                            |
-    \*---------------------------------------------------------*/
-    std::ifstream controller_file(filename, std::ios::in | std::ios::binary);
-
-    /*---------------------------------------------------------*\
-    | Read and verify file header                               |
-    \*---------------------------------------------------------*/
-    char            header_string[16];
-    unsigned int    header_version;
-
-    controller_file.read(header_string, 16);
-    controller_file.read((char *)&header_version, sizeof(unsigned int));
-
-    controller_offset += 16 + sizeof(unsigned int);
-    controller_file.seekg(controller_offset);
-
-    if(strcmp(header_string, "OPENRGB_PROFILE") == 0)
-    {
-        if(header_version == 1)
-        {
-            /*---------------------------------------------------------*\
-            | Read controller data from file until EOF                  |
-            \*---------------------------------------------------------*/
-            while(!(controller_file.peek() == EOF))
-            {
-                controller_file.read((char *)&controller_size, sizeof(controller_size));
-
-                unsigned char *controller_data = new unsigned char[controller_size];
-
-                controller_file.seekg(controller_offset);
-
-                controller_file.read((char *)controller_data, controller_size);
-
-                RGBController_Dummy *temp_controller = new RGBController_Dummy();
-
-                temp_controller->ReadDeviceDescription(controller_data);
-
-                temp_controllers.push_back(temp_controller);
-
-                delete[] controller_data;
-
-                controller_offset += controller_size;
-                controller_file.seekg(controller_offset);
-            }
-
-            for(int controller_index = 0; controller_index < controllers.size(); controller_index++)
-            {
-                RGBController *temp_controller = temp_controllers[controller_index];
-                RGBController *controller_ptr = controllers[controller_index];
-
-                /*---------------------------------------------------------*\
-                | Test if saved controller data matches this controller     |
-                \*---------------------------------------------------------*/
-                if((temp_controller->type        == controller_ptr->type       )
-                 &&(temp_controller->name        == controller_ptr->name       )
-                 &&(temp_controller->description == controller_ptr->description)
-                 &&(temp_controller->version     == controller_ptr->version    )
-                 &&(temp_controller->serial      == controller_ptr->serial     )
-                 &&(temp_controller->location    == controller_ptr->location   ))
-                {
-                    /*---------------------------------------------------------*\
-                    | Update all modes                                          |
-                    \*---------------------------------------------------------*/
-                    if(temp_controller->modes.size() == controller_ptr->modes.size())
-                    {
-                        for(int mode_index = 0; mode_index < temp_controller->modes.size(); mode_index++)
-                        {
-                            if((temp_controller->modes[mode_index].name       == controller_ptr->modes[mode_index].name      )
-                             &&(temp_controller->modes[mode_index].value      == controller_ptr->modes[mode_index].value     )
-                             &&(temp_controller->modes[mode_index].flags      == controller_ptr->modes[mode_index].flags     )
-                             &&(temp_controller->modes[mode_index].speed_min  == controller_ptr->modes[mode_index].speed_min )
-                             &&(temp_controller->modes[mode_index].speed_max  == controller_ptr->modes[mode_index].speed_max )
-                             &&(temp_controller->modes[mode_index].colors_min == controller_ptr->modes[mode_index].colors_min)
-                             &&(temp_controller->modes[mode_index].colors_max == controller_ptr->modes[mode_index].colors_max))
-                            {
-                                controller_ptr->modes[mode_index].speed      = temp_controller->modes[mode_index].speed;
-                                controller_ptr->modes[mode_index].direction  = temp_controller->modes[mode_index].direction;
-                                controller_ptr->modes[mode_index].color_mode = temp_controller->modes[mode_index].color_mode;
-
-                                controller_ptr->modes[mode_index].colors.resize(temp_controller->modes[mode_index].colors.size());
-
-                                for(int mode_color_index = 0; mode_color_index < temp_controller->modes[mode_index].colors.size(); mode_color_index++)
-                                {
-                                    controller_ptr->modes[mode_index].colors[mode_color_index] = temp_controller->modes[mode_index].colors[mode_color_index];
-                                }
-                            }
-
-                        }
-
-                        controller_ptr->active_mode = temp_controller->active_mode;
-                    }
-
-                    /*---------------------------------------------------------*\
-                    | Update all colors                                         |
-                    \*---------------------------------------------------------*/
-                    if(temp_controller->colors.size() == controller_ptr->colors.size())
-                    {
-                        for(int color_index = 0; color_index < temp_controller->colors.size(); color_index++)
-                        {
-                            controller_ptr->colors[color_index] = temp_controller->colors[color_index];
-                        }
-                    }
-                }
-            }
-        }
-
-        for(int device = 0; device < ui->DevicesTabBar->count(); device++)
-        {
-            qobject_cast<OpenRGBDevicePage *>(ui->DevicesTabBar->widget(device))->UpdateDevice();
-        }
-    }
-}
+}

qt/OpenRGBDialog2.h

@@ -48,9 +48,6 @@ private slots:
     void on_QuickWhite();
     void on_SetAllDevices(unsigned char red, unsigned char green, unsigned char blue);
     void on_ShowHide();
-    void on_ProfileSelected();
-    void on_ButtonSaveProfile_clicked();
-    void on_ButtonLoadProfile_clicked();
 };
 
 #endif // OPENRGBDIALOG2_H

qt/OpenRGBDialog2.ui

@@ -15,24 +15,7 @@
   </property>
   <widget class="QWidget" name="centralWidget">
    <layout class="QGridLayout" name="gridLayout">
-    <item row="3" column="1">
-     <widget class="QPushButton" name="ButtonLoadProfile">
-      <property name="text">
-       <string>Load Profile</string>
-      </property>
-     </widget>
-    </item>
-    <item row="3" column="0">
-     <widget class="QPushButton" name="ButtonSaveProfile">
-      <property name="text">
-       <string>Save Profile</string>
-      </property>
-     </widget>
-    </item>
-    <item row="3" column="2">
-     <widget class="QComboBox" name="comboBox"/>
-    </item>
-    <item row="2" column="0" colspan="3">
+    <item row="0" column="0">
      <widget class="QTabWidget" name="MainTabBar">
       <property name="tabShape">
        <enum>QTabWidget::Rounded</enum>
@@ -51,7 +34,7 @@
         <string>Devices</string>
        </attribute>
        <layout class="QGridLayout" name="gridLayout_3">
-        <item row="1" column="0">
+        <item row="0" column="0">
          <widget class="QTabWidget" name="DevicesTabBar">
           <property name="tabPosition">
            <enum>QTabWidget::West</enum>