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

Update mode color description to add mode-specific colors.

Browse source
This commit is contained in:
Adam Honse 2020-02-15 23:37:24 -06:00
parent 7b35cf72f7
commit bba88eb1f2
34 changed files with 1876 additions and 1113 deletions
Download patch file Download diff file Expand all files Collapse all files

11
Controllers/CorsairCmdrProController/CorsairCmdrProController.cpp
View file

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

5
Controllers/CorsairCmdrProController/CorsairCmdrProController.h
View file

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

11
Controllers/CorsairNodeProController/CorsairNodeProController.cpp
View file

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

5
Controllers/CorsairNodeProController/CorsairNodeProController.h
View file

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

106
Controllers/HuePlusController/HuePlusController.cpp
View file

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

1
Controllers/HuePlusController/HuePlusController.h
View file

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

30
RGBController/RGBController.h
View file

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

116
RGBController/RGBController_AMDWraithPrism.cpp
View file

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

125
RGBController/RGBController_Aura.cpp
View file

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

23
RGBController/RGBController_Corsair.cpp
View file

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

197
RGBController/RGBController_CorsairCmdrPro.cpp
View file

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

7
RGBController/RGBController_CorsairKeyboard.cpp
View file

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

197
RGBController/RGBController_CorsairNodePro.cpp
View file

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

203
RGBController/RGBController_CorsairPro.cpp
View file

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

55
RGBController/RGBController_Crucial.cpp
View file

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

12
RGBController/RGBController_E131.cpp
View file

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

50
RGBController/RGBController_Faustus.cpp
View file

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

143
RGBController/RGBController_Hue2.cpp
View file

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

200
RGBController/RGBController_HuePlus.cpp
View file

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

141
RGBController/RGBController_HyperX.cpp
View file

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

46
RGBController/RGBController_HyperXKeyboard.cpp
View file

@ -161,38 +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_COLOR | MODE_FLAG_PER_LED_COLOR;
Direct.random = false;
Direct.name = "Direct";
Direct.value = HYPERX_MODE_STATIC;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Static;
Static.name = "Static";
Static.value = HYPERX_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Static.random = false;
Static.name = "Static";
Static.value = HYPERX_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Wave;
Wave.name = "Wave";
Wave.value = HYPERX_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Wave.speed_min = 0x00;
Wave.speed_max = 0x09;
Wave.random = false;
Wave.speed = 0x09;
Wave.direction = MODE_DIRECTION_LEFT;
Wave.name = "Wave";
Wave.value = HYPERX_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Wave.speed_min = 0x00;
Wave.speed_max = 0x09;
Wave.color_mode = MODE_COLORS_NONE;
Wave.speed = 0x09;
Wave.direction = MODE_DIRECTION_LEFT;
modes.push_back(Wave);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = HYPERX_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED;
Breathing.speed_min = 0x00;
Breathing.speed_max = 0x09;
Breathing.random = false;
Breathing.speed = 0x09;
Breathing.name = "Breathing";
Breathing.value = HYPERX_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED;
Breathing.speed_min = 0x00;
Breathing.speed_max = 0x09;
Breathing.color_mode = MODE_COLORS_NONE;
Breathing.speed = 0x09;
modes.push_back(Breathing);
colors.resize(126);

11
RGBController/RGBController_LEDStrip.cpp
View file

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

11
RGBController/RGBController_MSI3Zone.cpp
View file

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

121
RGBController/RGBController_OpenRazer.cpp
View file

@ -245,65 +245,77 @@ 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_COLOR | MODE_FLAG_PER_LED_COLOR;
Custom.name = "Custom";
Custom.value = RAZER_MODE_CUSTOM;
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Custom.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Custom);
}
if(matrix_effect_none)
{
mode Off;
Off.name = "Off";
Off.value = RAZER_MODE_OFF;
Off.flags = 0;
Off.name = "Off";
Off.value = RAZER_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
}
if(matrix_effect_static)
{
mode Static;
Static.name = "Static";
Static.value = RAZER_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_COLOR;
Static.name = "Static";
Static.value = RAZER_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
modes.push_back(Static);
}
if(matrix_effect_breath)
{
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = RAZER_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
Breathing.random = false;
Breathing.name = "Breathing";
Breathing.value = RAZER_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Breathing.colors_min = 1;
Breathing.colors_max = 2;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize(1);
modes.push_back(Breathing);
}
if(matrix_effect_spectrum)
{
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = RAZER_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = 0;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = RAZER_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = 0;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
}
if(matrix_effect_wave)
{
mode Wave;
Wave.name = "Wave";
Wave.value = RAZER_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_DIRECTION_LR;
Wave.direction = MODE_DIRECTION_RIGHT;
Wave.name = "Wave";
Wave.value = RAZER_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_DIRECTION_LR;
Wave.direction = MODE_DIRECTION_RIGHT;
Wave.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave);
}
if(matrix_effect_reactive)
{
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = RAZER_MODE_REACTIVE;
Reactive.flags = 0;
Reactive.name = "Reactive";
Reactive.value = RAZER_MODE_REACTIVE;
Reactive.flags = 0;
Reactive.color_mode = MODE_COLORS_NONE;
modes.push_back(Reactive);
}
@ -364,57 +376,88 @@ void RGBController_OpenRazer::SetCustomMode()
void RGBController_OpenRazer::UpdateMode()
{
char update_value = 1;
char update_value[6];
update_value[0] = 1;
switch(matrix_type)
{
case RAZER_TYPE_MATRIX_FRAME:
case RAZER_TYPE_MATRIX_NOFRAME:
{
switch(active_mode)
switch(modes[active_mode].value)
{
case RAZER_MODE_CUSTOM:
matrix_effect_custom.write(&update_value, 1);
matrix_effect_custom.write(update_value, 1);
matrix_effect_custom.flush();
break;
case RAZER_MODE_OFF:
matrix_effect_none.write(&update_value, 1);
matrix_effect_none.write(update_value, 1);
matrix_effect_none.flush();
break;
case RAZER_MODE_STATIC:
matrix_effect_static.write(&update_value, 1);
update_value[0] = RGBGetRValue(modes[RAZER_MODE_STATIC].colors[0]);
update_value[1] = RGBGetGValue(modes[RAZER_MODE_STATIC].colors[0]);
update_value[2] = RGBGetBValue(modes[RAZER_MODE_STATIC].colors[0]);
matrix_effect_static.write(update_value, 3);
matrix_effect_static.flush();
break;
case RAZER_MODE_BREATHING:
matrix_effect_breath.write(&update_value, 1);
matrix_effect_breath.flush();
switch(modes[RAZER_MODE_BREATHING].color_mode)
{
case MODE_COLORS_MODE_SPECIFIC:
update_value[0] = RGBGetRValue(modes[RAZER_MODE_BREATHING].colors[0]);
update_value[1] = RGBGetGValue(modes[RAZER_MODE_BREATHING].colors[0]);
update_value[2] = RGBGetBValue(modes[RAZER_MODE_BREATHING].colors[0]);
if(modes[RAZER_MODE_BREATHING].colors.size() == 2)
{
update_value[3] = RGBGetRValue(modes[RAZER_MODE_BREATHING].colors[1]);
update_value[4] = RGBGetGValue(modes[RAZER_MODE_BREATHING].colors[1]);
update_value[5] = RGBGetBValue(modes[RAZER_MODE_BREATHING].colors[1]);
matrix_effect_breath.write(update_value, 6);
matrix_effect_breath.flush();
}
else
{
matrix_effect_breath.write(update_value, 3);
matrix_effect_breath.flush();
}
break;
case MODE_COLORS_RANDOM:
matrix_effect_breath.write(update_value, 1);
matrix_effect_breath.flush();
break;
}
break;
case RAZER_MODE_SPECTRUM_CYCLE:
matrix_effect_spectrum.write(&update_value, 1);
matrix_effect_spectrum.write(update_value, 1);
matrix_effect_spectrum.flush();
break;
case RAZER_MODE_WAVE:
switch(modes[active_mode].direction)
{
case MODE_DIRECTION_LEFT:
update_value = '2';
update_value[0] = '2';
break;
default:
update_value = '1';
update_value[0] = '1';
break;
}
matrix_effect_wave.write(&update_value, 1);
matrix_effect_wave.write(update_value, 1);
matrix_effect_wave.flush();
break;
case RAZER_MODE_REACTIVE:
matrix_effect_reactive.write(&update_value, 1);
matrix_effect_reactive.write(update_value, 1);
matrix_effect_reactive.flush();
break;
}
@ -444,4 +487,4 @@ void RGBController_OpenRazer::UpdateMode()
}
#endif
}
}
}

107
RGBController/RGBController_OpenRazerWindows.cpp
View file

@ -235,65 +235,77 @@ 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_COLOR | MODE_FLAG_PER_LED_COLOR;
Custom.name = "Custom";
Custom.value = RAZER_MODE_CUSTOM;
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Custom.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Custom);
}
if(razer_functions->matrix_effect_none)
{
mode Off;
Off.name = "Off";
Off.value = RAZER_MODE_OFF;
Off.flags = 0;
Off.name = "Off";
Off.value = RAZER_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
}
if(razer_functions->matrix_effect_static)
{
mode Static;
Static.name = "Static";
Static.value = RAZER_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_COLOR;
Static.name = "Static";
Static.value = RAZER_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
modes.push_back(Static);
}
if(razer_functions->matrix_effect_breath)
{
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = RAZER_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
Breathing.random = false;
Breathing.name = "Breathing";
Breathing.value = RAZER_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Breathing.colors_min = 1;
Breathing.colors_max = 2;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize(2);
modes.push_back(Breathing);
}
if(razer_functions->matrix_effect_spectrum)
{
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = RAZER_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = 0;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = RAZER_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = 0;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
}
if(razer_functions->matrix_effect_wave)
{
mode Wave;
Wave.name = "Wave";
Wave.value = RAZER_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_DIRECTION_LR;
Wave.direction = MODE_DIRECTION_RIGHT;
Wave.name = "Wave";
Wave.value = RAZER_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_DIRECTION_LR;
Wave.direction = MODE_DIRECTION_RIGHT;
Wave.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave);
}
if(razer_functions->matrix_effect_reactive)
{
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = RAZER_MODE_REACTIVE;
Reactive.flags = 0;
Reactive.name = "Reactive";
Reactive.value = RAZER_MODE_REACTIVE;
Reactive.flags = 0;
Reactive.color_mode = MODE_COLORS_NONE;
modes.push_back(Reactive);
}
@ -359,7 +371,9 @@ void RGBController_OpenRazer::SetCustomMode()
void RGBController_OpenRazer::UpdateMode()
{
char update_value = 1;
char update_value[6];
update_value[0] = 1;
switch(matrix_type)
{
@ -369,41 +383,68 @@ 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:
razer_functions->matrix_effect_static->store(razer_device, NULL, &update_value, 1);
update_value[0] = RGBGetRValue(modes[RAZER_MODE_STATIC].colors[0]);
update_value[1] = RGBGetGValue(modes[RAZER_MODE_STATIC].colors[0]);
update_value[2] = RGBGetBValue(modes[RAZER_MODE_STATIC].colors[0]);
razer_functions->matrix_effect_static->store(razer_device, NULL, update_value, 3);
break;
case RAZER_MODE_BREATHING:
razer_functions->matrix_effect_breath->store(razer_device, NULL, &update_value, 1);
switch(modes[RAZER_MODE_BREATHING].color_mode)
{
case MODE_COLORS_MODE_SPECIFIC:
update_value[0] = RGBGetRValue(modes[RAZER_MODE_BREATHING].colors[0]);
update_value[1] = RGBGetGValue(modes[RAZER_MODE_BREATHING].colors[0]);
update_value[2] = RGBGetBValue(modes[RAZER_MODE_BREATHING].colors[0]);
if(modes[RAZER_MODE_BREATHING].colors.size() == 2)
{
update_value[3] = RGBGetRValue(modes[RAZER_MODE_BREATHING].colors[1]);
update_value[4] = RGBGetGValue(modes[RAZER_MODE_BREATHING].colors[1]);
update_value[5] = RGBGetBValue(modes[RAZER_MODE_BREATHING].colors[1]);
razer_functions->matrix_effect_breath->store(razer_device, NULL, update_value, 6);
}
else
{
razer_functions->matrix_effect_breath->store(razer_device, NULL, update_value, 3);
}
break;
case MODE_COLORS_RANDOM:
razer_functions->matrix_effect_breath->store(razer_device, NULL, update_value, 1);
break;
}
break;
case RAZER_MODE_SPECTRUM_CYCLE:
razer_functions->matrix_effect_spectrum->store(razer_device, NULL, &update_value, 1);
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 = '2';
update_value[0] = '2';
break;
default:
update_value = '1';
update_value[0] = '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;
}
}

114
RGBController/RGBController_PatriotViper.cpp
View file

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

154
RGBController/RGBController_Polychrome.cpp
View file

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

48
RGBController/RGBController_PoseidonZRGB.cpp
View file

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

33
RGBController/RGBController_RGBFusion.cpp
View file

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

16
RGBController/RGBController_RGBFusion2.cpp
View file

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

107
RGBController/RGBController_ThermaltakeRiing.cpp
View file

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

544
qt/OpenRGBDevicePage.cpp
View file

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

4
qt/OpenRGBDevicePage.h
View file

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

35
qt/OpenRGBDevicePage.ui
View file

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