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

Move Get/Set mode functions to generic RGBController.cpp functions and add device-specific UpdateMode function to use active_mode value

Browse source
This commit is contained in:
Adam Honse 2020-01-25 16:57:53 -06:00
parent f110589f91
commit d7740c2d28
42 changed files with 558 additions and 634 deletions
Download patch file Download diff file Expand all files Collapse all files

11
Controllers/CorsairProController/CorsairProController.cpp
View file

@ -159,17 +159,6 @@ void CorsairProController::SetEffect(unsigned char mode,
WaitReady();
}
void CorsairProController::SetCustom()
{
SetEffect(CORSAIR_PRO_MODE_STATIC,
0x00,
0x00,
false,
0x00, 0x00, 0x00,
0x00, 0x00, 0x00
);
}
bool CorsairProController::WaitReady()
{
int i = 0;

1
Controllers/CorsairProController/CorsairProController.h
View file

@ -81,7 +81,6 @@ public:
unsigned char grn2,
unsigned char blu2
);
void SetCustom();
void SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
void SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);

12
RGBController/RGBController.cpp
View file

@ -44,3 +44,15 @@ void RGBController::SetAllZoneLEDs(int zone, RGBColor color)
UpdateZoneLEDs(zone);
}
int RGBController::GetMode()
{
return(active_mode);
}
void RGBController::SetMode(int mode)
{
active_mode = mode;
UpdateMode();
}

11
RGBController/RGBController.h
View file

@ -121,7 +121,7 @@ public:
std::vector<mode> modes; /* Modes */
std::vector<RGBColor> colors; /* Color buffer */
device_type type; /* device type */
int active_mode; /* active mode */
int active_mode = 0;/* active mode */
virtual ~RGBController() = default;
@ -133,13 +133,16 @@ public:
void SetAllLEDs(RGBColor color);
void SetAllZoneLEDs(int zone, RGBColor color);
int GetMode();
void SetMode(int mode);
/*---------------------------------------------------------*\
| Functions to be implemented in device implementation |
\*---------------------------------------------------------*/
virtual int GetMode() = 0;
virtual void SetMode(int mode) = 0;
virtual void SetCustomMode() = 0;
virtual void UpdateLEDs() = 0;
virtual void UpdateZoneLEDs(int zone) = 0;
virtual void UpdateSingleLED(int led) = 0;
virtual void SetCustomMode() = 0;
virtual void UpdateMode() = 0;
};

85
RGBController/RGBController_AMDWraithPrism.cpp
View file

@ -129,51 +129,6 @@ RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
}
int RGBController_AMDWraithPrism::GetMode()
{
return 0;
}
void RGBController_AMDWraithPrism::SetMode(int mode)
{
wraith->SetRingMode(modes[mode].value, modes[mode].speed, modes[mode].direction, modes[mode].random);
switch(modes[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[mode].speed, modes[mode].random);
wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[mode].speed, modes[mode].random);
break;
case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[mode].speed, modes[mode].random);
wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[mode].speed, modes[mode].random);
break;
default:
if(modes[mode].random)
{
wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[mode].speed, modes[mode].random);
wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[mode].speed, modes[mode].random);
}
else
{
wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[mode].speed, modes[mode].random);
wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[mode].speed, modes[mode].random);
}
break;
}
UpdateLEDs();
}
void RGBController_AMDWraithPrism::SetCustomMode()
{
SetMode(0);
}
void RGBController_AMDWraithPrism::UpdateLEDs()
{
unsigned char red = RGBGetRValue(colors[0]);
@ -217,3 +172,43 @@ void RGBController_AMDWraithPrism::UpdateSingleLED(int led)
{
UpdateZoneLEDs(led);
}
void RGBController_AMDWraithPrism::SetCustomMode()
{
SetMode(0);
}
void RGBController_AMDWraithPrism::UpdateMode()
{
wraith->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, modes[active_mode].random);
switch(modes[active_mode].value)
{
case AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE:
case AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW:
case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE:
wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].random);
wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].random);
break;
case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].random);
wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].random);
break;
default:
if(modes[active_mode].random)
{
wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].random);
wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].random);
}
else
{
wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].random);
wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].random);
}
break;
}
UpdateLEDs();
}

6
RGBController/RGBController_AMDWraithPrism.h
View file

@ -16,13 +16,13 @@ class RGBController_AMDWraithPrism : public RGBController
public:
RGBController_AMDWraithPrism(AMDWraithPrismController* wraith_ptr);
~RGBController_AMDWraithPrism();
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
AMDWraithPrismController* wraith;
};

25
RGBController/RGBController_AorusGPU.cpp
View file

@ -20,21 +20,6 @@ static unsigned char data[] = { 0x8E, 0x00, 0x00, 0x00,
0x64, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00 };
int RGBController_AorusGPU::GetMode()
{
return(0);
}
void RGBController_AorusGPU::SetMode(int mode)
{
}
void RGBController_AorusGPU::SetCustomMode()
{
}
void RGBController_AorusGPU::UpdateLEDs()
{
RGBColor color = colors[0];
@ -86,3 +71,13 @@ RGBController_AorusGPU::RGBController_AorusGPU()
aorus_zone.map.push_back(aorus_zone_map);
zones.push_back(aorus_zone);
}
void RGBController_AorusGPU::SetCustomMode()
{
}
void RGBController_AorusGPU::UpdateMode()
{
}

6
RGBController/RGBController_AorusGPU.h
View file

@ -19,13 +19,13 @@ class RGBController_AorusGPU : public RGBController
{
public:
RGBController_AorusGPU();
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
_GvWriteI2C GvWriteI2C;
_GvFreeDispLib GvFreeDispLib;

79
RGBController/RGBController_Aura.cpp
View file

@ -9,7 +9,7 @@
#include "RGBController_Aura.h"
int RGBController_Aura::GetMode()
int RGBController_Aura::GetDeviceMode()
{
int dev_mode = aura->AuraRegisterRead(AURA_REG_MODE);
bool random = false;
@ -49,44 +49,6 @@ int RGBController_Aura::GetMode()
return(active_mode);
}
void RGBController_Aura::SetMode(int mode)
{
active_mode = mode;
if (modes[active_mode].value == 0xFFFF)
{
aura->SetDirect(true);
}
else
{
int new_mode = modes[active_mode].value;
if(modes[active_mode].random == true)
{
switch(new_mode)
{
case AURA_MODE_CHASE:
new_mode = AURA_MODE_SPECTRUM_CYCLE_CHASE;
break;
case AURA_MODE_BREATHING:
new_mode = AURA_MODE_SPECTRUM_CYCLE_BREATHING;
break;
case AURA_MODE_CHASE_FADE:
new_mode = AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE;
break;
}
}
aura->SetMode(new_mode);
aura->SetDirect(false);
}
}
void RGBController_Aura::SetCustomMode()
{
aura->SetDirect(true);
}
void RGBController_Aura::UpdateLEDs()
{
for(std::size_t led = 0; led < colors.size(); led++)
@ -290,4 +252,43 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
zones.push_back(*new_zone);
}
}
// Initialize active mode
active_mode = GetDeviceMode();
}
void RGBController_Aura::SetCustomMode()
{
SetMode(0);
}
void RGBController_Aura::UpdateMode()
{
if (modes[active_mode].value == 0xFFFF)
{
aura->SetDirect(true);
}
else
{
int new_mode = modes[active_mode].value;
if(modes[active_mode].random == true)
{
switch(new_mode)
{
case AURA_MODE_CHASE:
new_mode = AURA_MODE_SPECTRUM_CYCLE_CHASE;
break;
case AURA_MODE_BREATHING:
new_mode = AURA_MODE_SPECTRUM_CYCLE_BREATHING;
break;
case AURA_MODE_CHASE_FADE:
new_mode = AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE;
break;
}
}
aura->SetMode(new_mode);
aura->SetDirect(false);
}
}

8
RGBController/RGBController_Aura.h
View file

@ -16,13 +16,15 @@ class RGBController_Aura : public RGBController
{
public:
RGBController_Aura(AuraController* aura_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
AuraController* aura;
int GetDeviceMode();
};

25
RGBController/RGBController_Corsair.cpp
View file

@ -9,21 +9,6 @@
#include "RGBController_Corsair.h"
int RGBController_Corsair::GetMode()
{
return(0);
}
void RGBController_Corsair::SetMode(int mode)
{
corsair->SetMode(modes[mode].value);
}
void RGBController_Corsair::SetCustomMode()
{
corsair->SetMode(CORSAIR_VENGEANCE_RGB_MODE_SINGLE);
}
void RGBController_Corsair::UpdateLEDs()
{
RGBColor color = colors[0];
@ -97,3 +82,13 @@ RGBController_Corsair::RGBController_Corsair(CorsairController* corsair_ptr)
zones.push_back(new_zone);
}
void RGBController_Corsair::SetCustomMode()
{
SetMode(0);
}
void RGBController_Corsair::UpdateMode()
{
corsair->SetMode(modes[active_mode].value);
}

6
RGBController/RGBController_Corsair.h
View file

@ -16,13 +16,13 @@ class RGBController_Corsair : public RGBController
{
public:
RGBController_Corsair(CorsairController* corsair_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
CorsairController* corsair;
};

81
RGBController/RGBController_CorsairCmdrPro.cpp
View file

@ -175,50 +175,6 @@ RGBController_CorsairCmdrPro::RGBController_CorsairCmdrPro(CorsairCmdrProControl
}
}
int RGBController_CorsairCmdrPro::GetMode()
{
return 0;
}
void RGBController_CorsairCmdrPro::SetMode(int mode)
{
active_mode = mode;
if(modes[active_mode].value == 0xFFFF)
{
UpdateLEDs();
}
else
{
for(int channel = 0; channel < CORSAIR_CMDR_PRO_NUM_CHANNELS; channel++)
{
unsigned int direction = 0;
if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
{
direction = 1;
}
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]));
}
}
}
void RGBController_CorsairCmdrPro::SetCustomMode()
{
}
void RGBController_CorsairCmdrPro::UpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
@ -281,3 +237,40 @@ void RGBController_CorsairCmdrPro::UpdateSingleLED(int led)
corsair->SetChannelLEDs(channel, channel_colors);
}
}
void RGBController_CorsairCmdrPro::SetCustomMode()
{
SetMode(9);
}
void RGBController_CorsairCmdrPro::UpdateMode()
{
if(modes[active_mode].value == 0xFFFF)
{
UpdateLEDs();
}
else
{
for(int channel = 0; channel < CORSAIR_CMDR_PRO_NUM_CHANNELS; channel++)
{
unsigned int direction = 0;
if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
{
direction = 1;
}
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]));
}
}
}

6
RGBController/RGBController_CorsairCmdrPro.h
View file

@ -16,13 +16,13 @@ class RGBController_CorsairCmdrPro : public RGBController
{
public:
RGBController_CorsairCmdrPro(CorsairCmdrProController* corsair_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
CorsairCmdrProController* corsair;
std::vector<unsigned int> leds_channel;

81
RGBController/RGBController_CorsairNodePro.cpp
View file

@ -175,50 +175,6 @@ RGBController_CorsairNodePro::RGBController_CorsairNodePro(CorsairNodeProControl
}
}
int RGBController_CorsairNodePro::GetMode()
{
return 0;
}
void RGBController_CorsairNodePro::SetMode(int mode)
{
active_mode = mode;
if(modes[active_mode].value == 0xFFFF)
{
UpdateLEDs();
}
else
{
for(int channel = 0; channel < CORSAIR_CMDR_PRO_NUM_CHANNELS; channel++)
{
unsigned int direction = 0;
if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
{
direction = 1;
}
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]));
}
}
}
void RGBController_CorsairNodePro::SetCustomMode()
{
}
void RGBController_CorsairNodePro::UpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
@ -281,3 +237,40 @@ void RGBController_CorsairNodePro::UpdateSingleLED(int led)
corsair->SetChannelLEDs(channel, channel_colors);
}
}
void RGBController_CorsairNodePro::SetCustomMode()
{
SetMode(9);
}
void RGBController_CorsairNodePro::UpdateMode()
{
if(modes[active_mode].value == 0xFFFF)
{
UpdateLEDs();
}
else
{
for(int channel = 0; channel < CORSAIR_CMDR_PRO_NUM_CHANNELS; channel++)
{
unsigned int direction = 0;
if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
{
direction = 1;
}
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]));
}
}
}

6
RGBController/RGBController_CorsairNodePro.h
View file

@ -16,13 +16,13 @@ class RGBController_CorsairNodePro : public RGBController
{
public:
RGBController_CorsairNodePro(CorsairNodeProController* corsair_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
CorsairNodeProController* corsair;
std::vector<unsigned int> leds_channel;

94
RGBController/RGBController_CorsairPro.cpp
View file

@ -9,57 +9,6 @@
#include "RGBController_CorsairPro.h"
int RGBController_CorsairPro::GetMode()
{
return(active_mode);
}
void RGBController_CorsairPro::SetMode(int mode)
{
unsigned int corsair_direction;
active_mode = mode;
switch(modes[active_mode].direction)
{
case MODE_DIRECTION_LEFT:
corsair_direction = CORSAIR_PRO_DIRECTION_LEFT;
break;
case MODE_DIRECTION_RIGHT:
corsair_direction = CORSAIR_PRO_DIRECTION_RIGHT;
break;
case MODE_DIRECTION_UP:
corsair_direction = CORSAIR_PRO_DIRECTION_UP;
break;
case MODE_DIRECTION_DOWN:
corsair_direction = CORSAIR_PRO_DIRECTION_DOWN;
break;
case MODE_DIRECTION_HORIZONTAL:
corsair_direction = CORSAIR_PRO_DIRECTION_HORIZONTAL;
break;
case MODE_DIRECTION_VERTICAL:
corsair_direction = CORSAIR_PRO_DIRECTION_VERTICAL;
break;
}
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]));
}
void RGBController_CorsairPro::SetCustomMode()
{
active_mode = 9;
corsair->SetCustom();
}
void RGBController_CorsairPro::UpdateLEDs()
{
for (std::size_t led = 0; led < colors.size(); led++)
@ -233,3 +182,46 @@ RGBController_CorsairPro::RGBController_CorsairPro(CorsairProController* corsair
zones.push_back(new_zone);
}
void RGBController_CorsairPro::SetCustomMode()
{
SetMode(9);
}
void RGBController_CorsairPro::UpdateMode()
{
unsigned int corsair_direction;
switch(modes[active_mode].direction)
{
case MODE_DIRECTION_LEFT:
corsair_direction = CORSAIR_PRO_DIRECTION_LEFT;
break;
case MODE_DIRECTION_RIGHT:
corsair_direction = CORSAIR_PRO_DIRECTION_RIGHT;
break;
case MODE_DIRECTION_UP:
corsair_direction = CORSAIR_PRO_DIRECTION_UP;
break;
case MODE_DIRECTION_DOWN:
corsair_direction = CORSAIR_PRO_DIRECTION_DOWN;
break;
case MODE_DIRECTION_HORIZONTAL:
corsair_direction = CORSAIR_PRO_DIRECTION_HORIZONTAL;
break;
case MODE_DIRECTION_VERTICAL:
corsair_direction = CORSAIR_PRO_DIRECTION_VERTICAL;
break;
}
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]));
}

6
RGBController/RGBController_CorsairPro.h
View file

@ -16,13 +16,13 @@ class RGBController_CorsairPro : public RGBController
{
public:
RGBController_CorsairPro(CorsairProController* corsair_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
CorsairProController* corsair;
};

25
RGBController/RGBController_E131.cpp
View file

@ -86,21 +86,6 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
}
}
int RGBController_E131::GetMode()
{
return 0;
}
void RGBController_E131::SetMode(int /*mode*/)
{
}
void RGBController_E131::SetCustomMode()
{
}
void RGBController_E131::UpdateLEDs()
{
int color_idx = 0;
@ -171,3 +156,13 @@ void RGBController_E131::UpdateSingleLED(int led)
{
UpdateLEDs();
}
void RGBController_E131::SetCustomMode()
{
}
void RGBController_E131::UpdateMode()
{
}

6
RGBController/RGBController_E131.h
View file

@ -37,13 +37,13 @@ class RGBController_E131 : public RGBController
{
public:
RGBController_E131(std::vector<E131Device> device_list);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
std::vector<E131Device> devices;
std::vector<e131_packet_t> packets;

77
RGBController/RGBController_Hue2.cpp
View file

@ -144,47 +144,6 @@ RGBController_Hue2::RGBController_Hue2(Hue2Controller* hue2_ptr)
}
}
int RGBController_Hue2::GetMode()
{
return 0;
}
void RGBController_Hue2::SetMode(int mode)
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned int channel = zones_channel[zone_idx];
std::vector<RGBColor> channel_colors;
for(std::size_t color = 0; color < colors.size(); color++)
{
if(leds_channel[color] == channel)
{
channel_colors.push_back(colors[color]);
}
}
if(channel_colors.size() > 0)
{
bool direction = false;
if(modes[mode].direction == MODE_DIRECTION_LEFT)
{
direction = true;
}
hue2->SetMode(modes[mode].value, modes[mode].speed, direction);
hue2->SetChannelLEDs(channel, channel_colors);
}
}
}
void RGBController_Hue2::SetCustomMode()
{
}
void RGBController_Hue2::UpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
@ -247,3 +206,39 @@ void RGBController_Hue2::UpdateSingleLED(int led)
hue2->SetChannelLEDs(channel, channel_colors);
}
}
void RGBController_Hue2::SetCustomMode()
{
SetMode(0);
}
void RGBController_Hue2::UpdateMode()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned int channel = zones_channel[zone_idx];
std::vector<RGBColor> channel_colors;
for(std::size_t color = 0; color < colors.size(); color++)
{
if(leds_channel[color] == channel)
{
channel_colors.push_back(colors[color]);
}
}
if(channel_colors.size() > 0)
{
bool direction = false;
if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
{
direction = true;
}
hue2->SetMode(modes[active_mode].value, modes[active_mode].speed, direction);
hue2->SetChannelLEDs(channel, channel_colors);
}
}
}

6
RGBController/RGBController_Hue2.h
View file

@ -15,13 +15,13 @@ class RGBController_Hue2 : public RGBController
{
public:
RGBController_Hue2(Hue2Controller* hue2_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
Hue2Controller* hue2;
std::vector<unsigned int> leds_channel;

77
RGBController/RGBController_HuePlus.cpp
View file

@ -178,47 +178,6 @@ RGBController_HuePlus::RGBController_HuePlus(HuePlusController* hueplus_ptr)
}
}
int RGBController_HuePlus::GetMode()
{
return 0;
}
void RGBController_HuePlus::SetMode(int mode)
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned int channel = zones_channel[zone_idx];
std::vector<RGBColor> channel_colors;
for(std::size_t color = 0; color < colors.size(); color++)
{
if(leds_channel[color] == channel)
{
channel_colors.push_back(colors[color]);
}
}
if(channel_colors.size() > 0)
{
bool direction = false;
if(modes[mode].direction == MODE_DIRECTION_LEFT)
{
direction = true;
}
hueplus->SetMode(modes[mode].value, modes[mode].speed, direction);
hueplus->SetChannelLEDs(channel, channel_colors);
}
}
}
void RGBController_HuePlus::SetCustomMode()
{
}
void RGBController_HuePlus::UpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
@ -281,3 +240,39 @@ void RGBController_HuePlus::UpdateSingleLED(int led)
hueplus->SetChannelLEDs(channel, channel_colors);
}
}
void RGBController_HuePlus::SetCustomMode()
{
SetMode(0);
}
void RGBController_HuePlus::UpdateMode()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned int channel = zones_channel[zone_idx];
std::vector<RGBColor> channel_colors;
for(std::size_t color = 0; color < colors.size(); color++)
{
if(leds_channel[color] == channel)
{
channel_colors.push_back(colors[color]);
}
}
if(channel_colors.size() > 0)
{
bool direction = false;
if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
{
direction = true;
}
hueplus->SetMode(modes[active_mode].value, modes[active_mode].speed, direction);
hueplus->SetChannelLEDs(channel, channel_colors);
}
}
}

6
RGBController/RGBController_HuePlus.h
View file

@ -15,13 +15,13 @@ class RGBController_HuePlus : public RGBController
{
public:
RGBController_HuePlus(HuePlusController* hueplus_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
HuePlusController* hueplus;
std::vector<unsigned int> leds_channel;

25
RGBController/RGBController_HyperX.cpp
View file

@ -9,20 +9,6 @@
#include "RGBController_HyperX.h"
int RGBController_HyperX::GetMode()
{
return(0);
}
void RGBController_HyperX::SetMode(int mode)
{
hyperx->SetMode(modes[mode].value, modes[mode].random, modes[mode].speed);
}
void RGBController_HyperX::SetCustomMode()
{
hyperx->SetMode(HYPERX_MODE_DIRECT, false, 0x00);
}
void RGBController_HyperX::UpdateLEDs()
{
@ -223,3 +209,14 @@ RGBController_HyperX::RGBController_HyperX(HyperXController* hyperx_ptr)
zones.push_back(*new_zone);
}
}
void RGBController_HyperX::SetCustomMode()
{
SetMode(0);
}
void RGBController_HyperX::UpdateMode()
{
hyperx->SetMode(modes[active_mode].value, modes[active_mode].random, modes[active_mode].speed);
}

6
RGBController/RGBController_HyperX.h
View file

@ -16,13 +16,13 @@ class RGBController_HyperX : public RGBController
{
public:
RGBController_HyperX(HyperXController* hyperx_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
HyperXController* hyperx;
};

25
RGBController/RGBController_LEDStrip.cpp
View file

@ -42,21 +42,6 @@ RGBController_LEDStrip::RGBController_LEDStrip(LEDStripController* ledstrip_ptr)
zones.push_back(led_zone);
}
int RGBController_LEDStrip::GetMode()
{
return 0;
}
void RGBController_LEDStrip::SetMode(int /*mode*/)
{
}
void RGBController_LEDStrip::SetCustomMode()
{
}
void RGBController_LEDStrip::UpdateLEDs()
{
strip->SetLEDs(colors);
@ -71,3 +56,13 @@ void RGBController_LEDStrip::UpdateSingleLED(int led)
{
strip->SetLEDs(colors);
}
void RGBController_LEDStrip::SetCustomMode()
{
}
void RGBController_LEDStrip::UpdateMode()
{
}

5
RGBController/RGBController_LEDStrip.h
View file

@ -16,13 +16,12 @@ class RGBController_LEDStrip : public RGBController
{
public:
RGBController_LEDStrip(LEDStripController* ledstrip_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
LEDStripController* strip;

25
RGBController/RGBController_MSI3Zone.cpp
View file

@ -64,21 +64,6 @@ RGBController_MSI3Zone::~RGBController_MSI3Zone()
}
int RGBController_MSI3Zone::GetMode()
{
return 0;
}
void RGBController_MSI3Zone::SetMode(int mode)
{
}
void RGBController_MSI3Zone::SetCustomMode()
{
}
void RGBController_MSI3Zone::UpdateLEDs()
{
msi->SetLEDs(colors);
@ -92,4 +77,14 @@ void RGBController_MSI3Zone::UpdateZoneLEDs(int zone)
void RGBController_MSI3Zone::UpdateSingleLED(int led)
{
msi->SetLEDs(colors);
}
void RGBController_MSI3Zone::SetCustomMode()
{
}
void RGBController_MSI3Zone::UpdateMode()
{
}

6
RGBController/RGBController_MSI3Zone.h
View file

@ -16,13 +16,13 @@ class RGBController_MSI3Zone : public RGBController
public:
RGBController_MSI3Zone(MSI3ZoneController* msi_ptr);
~RGBController_MSI3Zone();
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
MSI3ZoneController* msi;
};

151
RGBController/RGBController_OpenRazer.cpp
View file

@ -11,84 +11,7 @@
#include <fstream>
#include <unistd.h>
int RGBController_OpenRazer::GetMode()
{
return(0);
}
void RGBController_OpenRazer::SetMode(int mode)
{
char update_value = 1;
switch(matrix_type)
{
case RAZER_TYPE_MATRIX_FRAME:
case RAZER_TYPE_MATRIX_NOFRAME:
{
switch(mode)
{
case RAZER_MODE_CUSTOM:
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.flush();
break;
case RAZER_MODE_STATIC:
break;
case RAZER_MODE_BREATHING:
break;
case RAZER_MODE_SPECTRUM_CYCLE:
matrix_effect_spectrum.write(&update_value, 1);
matrix_effect_spectrum.flush();
break;
case RAZER_MODE_WAVE:
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.flush();
break;
}
}
break;
case RAZER_TYPE_NOMATRIX:
{
switch(mode)
{
case RAZER_MODE_CUSTOM:
update_value = 0;
logo_led_effect.write(&update_value, 1);
scroll_led_effect.write(&update_value, 1);
logo_led_effect.flush();
scroll_led_effect.flush();
break;
case RAZER_MODE_SPECTRUM_CYCLE:
update_value = '4';
logo_led_effect.write(&update_value, 1);
scroll_led_effect.write(&update_value, 1);
logo_led_effect.flush();
scroll_led_effect.flush();
break;
}
}
}
}
void RGBController_OpenRazer::SetCustomMode()
{
SetMode(RAZER_MODE_CUSTOM);
}
void RGBController_OpenRazer::UpdateLEDs()
{
@ -401,3 +324,77 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
}
}
}
void RGBController_OpenRazer::SetCustomMode()
{
SetMode(RAZER_MODE_CUSTOM);
}
void RGBController_OpenRazer::UpdateMode()
{
char update_value = 1;
switch(matrix_type)
{
case RAZER_TYPE_MATRIX_FRAME:
case RAZER_TYPE_MATRIX_NOFRAME:
{
switch(active_mode)
{
case RAZER_MODE_CUSTOM:
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.flush();
break;
case RAZER_MODE_STATIC:
break;
case RAZER_MODE_BREATHING:
break;
case RAZER_MODE_SPECTRUM_CYCLE:
matrix_effect_spectrum.write(&update_value, 1);
matrix_effect_spectrum.flush();
break;
case RAZER_MODE_WAVE:
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.flush();
break;
}
}
break;
case RAZER_TYPE_NOMATRIX:
{
switch(active_mode)
{
case RAZER_MODE_CUSTOM:
update_value = 0;
logo_led_effect.write(&update_value, 1);
scroll_led_effect.write(&update_value, 1);
logo_led_effect.flush();
scroll_led_effect.flush();
break;
case RAZER_MODE_SPECTRUM_CYCLE:
update_value = '4';
logo_led_effect.write(&update_value, 1);
scroll_led_effect.write(&update_value, 1);
logo_led_effect.flush();
scroll_led_effect.flush();
break;
}
}
}
}

6
RGBController/RGBController_OpenRazer.h
View file

@ -920,13 +920,13 @@ public:
public:
RGBController_OpenRazer(std::string dev_path);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
int device;
private:

39
RGBController/RGBController_PatriotViper.cpp
View file

@ -9,28 +9,6 @@
#include "RGBController_PatriotViper.h"
int RGBController_PatriotViper::GetMode()
{
return(0);
}
void RGBController_PatriotViper::SetMode(int mode)
{
if(modes[mode].value == 0xFFFF)
{
viper->SetDirect();
}
else
{
viper->SetMode(modes[mode].value, modes[mode].speed);
}
}
void RGBController_PatriotViper::SetCustomMode()
{
viper->SetDirect();
}
void RGBController_PatriotViper::UpdateLEDs()
{
if(viper->direct == true)
@ -205,3 +183,20 @@ RGBController_PatriotViper::RGBController_PatriotViper(PatriotViperController* v
zones.push_back(*new_zone);
}
}
void RGBController_PatriotViper::SetCustomMode()
{
SetMode(0);
}
void RGBController_PatriotViper::UpdateMode()
{
if(modes[active_mode].value == 0xFFFF)
{
viper->SetDirect();
}
else
{
viper->SetMode(modes[active_mode].value, modes[active_mode].speed);
}
}

6
RGBController/RGBController_PatriotViper.h
View file

@ -16,13 +16,13 @@ class RGBController_PatriotViper : public RGBController
{
public:
RGBController_PatriotViper(PatriotViperController* viper_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
PatriotViperController* viper;
};

24
RGBController/RGBController_Polychrome.cpp
View file

@ -9,20 +9,6 @@
#include "RGBController_Polychrome.h"
int RGBController_Polychrome::GetMode()
{
return(polychrome->GetMode());
}
void RGBController_Polychrome::SetMode(int mode)
{
polychrome->SetMode(mode);
}
void RGBController_Polychrome::SetCustomMode()
{
polychrome->SetMode(POLYCHROME_MODE_STATIC);
}
void RGBController_Polychrome::UpdateLEDs()
{
@ -95,3 +81,13 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
zones.push_back(*new_zone);
}
}
void RGBController_Polychrome::SetCustomMode()
{
SetMode(0);
}
void RGBController_Polychrome::UpdateMode()
{
polychrome->SetMode(active_mode);
}

6
RGBController/RGBController_Polychrome.h
View file

@ -16,13 +16,13 @@ class RGBController_Polychrome : public RGBController
{
public:
RGBController_Polychrome(PolychromeController* polychrome_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
PolychromeController* polychrome;
};

25
RGBController/RGBController_PoseidonZRGB.cpp
View file

@ -27,21 +27,6 @@ RGBController_PoseidonZRGB::~RGBController_PoseidonZRGB()
}
int RGBController_PoseidonZRGB::GetMode()
{
return 0;
}
void RGBController_PoseidonZRGB::SetMode(int mode)
{
}
void RGBController_PoseidonZRGB::SetCustomMode()
{
}
void RGBController_PoseidonZRGB::UpdateLEDs()
{
poseidon->SetLEDs(colors);
@ -55,4 +40,14 @@ void RGBController_PoseidonZRGB::UpdateZoneLEDs(int zone)
void RGBController_PoseidonZRGB::UpdateSingleLED(int led)
{
poseidon->SetLEDs(colors);
}
void RGBController_PoseidonZRGB::SetCustomMode()
{
}
void RGBController_PoseidonZRGB::UpdateMode()
{
}

6
RGBController/RGBController_PoseidonZRGB.h
View file

@ -16,13 +16,13 @@ class RGBController_PoseidonZRGB : public RGBController
public:
RGBController_PoseidonZRGB(PoseidonZRGBController* poseidon_ptr);
~RGBController_PoseidonZRGB();
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
PoseidonZRGBController* poseidon;
};

52
RGBController/RGBController_RGBFusion.cpp
View file

@ -9,30 +9,6 @@
#include "RGBController_RGBFusion.h"
int RGBController_RGBFusion::GetMode()
{
int dev_mode = rgb_fusion->GetMode();
for(int mode = 0; mode < modes.size(); mode++)
{
if(modes[mode].value == dev_mode)
{
return(mode);
}
}
return(0);
}
void RGBController_RGBFusion::SetMode(int mode)
{
rgb_fusion->SetMode(modes[mode].value, modes[mode].speed);
}
void RGBController_RGBFusion::SetCustomMode()
{
rgb_fusion->SetMode(RGB_FUSION_MODE_STATIC, 0);
}
void RGBController_RGBFusion::UpdateLEDs()
{
@ -128,4 +104,32 @@ RGBController_RGBFusion::RGBController_RGBFusion(RGBFusionController* rgb_fusion
// Push new zone to zones vector
zones.push_back(*new_zone);
}
// Initialize active mode
active_mode = GetDeviceMode();
}
int RGBController_RGBFusion::GetDeviceMode()
{
int dev_mode = rgb_fusion->GetMode();
for(int mode = 0; mode < modes.size(); mode++)
{
if(modes[mode].value == dev_mode)
{
return(mode);
}
}
return(0);
}
void RGBController_RGBFusion::SetCustomMode()
{
rgb_fusion->SetMode(RGB_FUSION_MODE_STATIC, 0);
}
void RGBController_RGBFusion::UpdateMode()
{
rgb_fusion->SetMode(modes[active_mode].value, modes[active_mode].speed);
}

8
RGBController/RGBController_RGBFusion.h
View file

@ -16,13 +16,15 @@ class RGBController_RGBFusion : public RGBController
{
public:
RGBController_RGBFusion(RGBFusionController* rgb_fusion_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
RGBFusionController* rgb_fusion;
int GetDeviceMode();
};

25
RGBController/RGBController_RazerChromaSDK.cpp
View file

@ -70,21 +70,6 @@ RGBController_RazerChromaSDK::RGBController_RazerChromaSDK(unsigned int device_t
if(CreateChromaLinkEffect == NULL) CreateChromaLinkEffect = (CREATECHROMALINKEFFECT)GetProcAddress(*hModule, "CreateChromaLinkEffect");
}
int RGBController_RazerChromaSDK::GetMode()
{
return 0;
}
void RGBController_RazerChromaSDK::SetMode(int mode)
{
}
void RGBController_RazerChromaSDK::SetCustomMode()
{
}
void RGBController_RazerChromaSDK::UpdateLEDs()
{
switch (device->razer_type)
@ -169,3 +154,13 @@ void RGBController_RazerChromaSDK::UpdateSingleLED(int led)
{
UpdateLEDs();
}
void RGBController_RazerChromaSDK::SetCustomMode()
{
}
void RGBController_RazerChromaSDK::UpdateMode()
{
}

6
RGBController/RGBController_RazerChromaSDK.h
View file

@ -229,13 +229,13 @@ class RGBController_RazerChromaSDK : public RGBController
{
public:
RGBController_RazerChromaSDK(unsigned int device_type, HMODULE* hModule);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
const razer_device* device;