mirror of
https://github.com/CalcProgrammer1/OpenRGB.git
synced 2025-12-30 10:47:50 -05:00
246 lines
9.8 KiB
C++
246 lines
9.8 KiB
C++
/*----------------------------------------------*\
|
|
| RGBController_EVGAMouse.cpp |
|
|
| |
|
|
| RGB Implementation for EVGA X20 Gaming Mouse. |
|
|
| |
|
|
| Cooper Knaak 1/23/2022 |
|
|
\*----------------------------------------------*/
|
|
|
|
#include "RGBController_EVGAMouse.h"
|
|
#include "Colors.h"
|
|
|
|
RGBController_EVGAMouse::RGBController_EVGAMouse(EVGAMouseController* controller_ptr)
|
|
{
|
|
controller = controller_ptr;
|
|
|
|
name = controller->GetDeviceName();
|
|
vendor = "EVGA";
|
|
type = DEVICE_TYPE_MOUSE;
|
|
description = controller->GetDeviceName();
|
|
serial = controller->GetSerial();
|
|
location = controller->GetLocation();
|
|
|
|
mode Static;
|
|
Static.name = "Static";
|
|
Static.value = EVGA_PERIPHERAL_MODE_STATIC;
|
|
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
|
|
Static.brightness_min = EVGA_PERIPHERAL_BRIGHTNESS_MIN;
|
|
Static.brightness_max = EVGA_PERIPHERAL_BRIGHTNESS_MAX;
|
|
Static.brightness = EVGA_PERIPHERAL_BRIGHTNESS_MAX;
|
|
Static.colors_min = 1;
|
|
Static.colors_max = 1;
|
|
Static.colors.resize(Static.colors_max);
|
|
Static.color_mode = MODE_COLORS_PER_LED;
|
|
modes.push_back(Static);
|
|
|
|
mode Breathing;
|
|
Breathing.name = "Breathing";
|
|
Breathing.value = EVGA_PERIPHERAL_MODE_BREATHING;
|
|
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
|
|
Breathing.brightness_min = EVGA_PERIPHERAL_BRIGHTNESS_MIN;
|
|
Breathing.brightness_max = EVGA_PERIPHERAL_BRIGHTNESS_MAX;
|
|
Breathing.brightness = EVGA_PERIPHERAL_BRIGHTNESS_MAX;
|
|
Breathing.colors_min = 2;
|
|
Breathing.colors_max = 2;
|
|
Breathing.colors = {COLOR_GREEN, COLOR_BLUE};
|
|
Breathing.speed_min = EVGA_PERIPHERAL_SPEED_SLOWEST;
|
|
Breathing.speed_max = EVGA_PERIPHERAL_SPEED_FASTEST;
|
|
Breathing.speed = EVGA_PERIPHERAL_SPEED_FASTEST;
|
|
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
|
modes.push_back(Breathing);
|
|
|
|
mode Rainbow;
|
|
Rainbow.name = "Spectrum Cycle";
|
|
Rainbow.value = EVGA_PERIPHERAL_MODE_RAINBOW;
|
|
Rainbow.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
|
|
Rainbow.brightness_min = EVGA_PERIPHERAL_BRIGHTNESS_MIN;
|
|
Rainbow.brightness_max = EVGA_PERIPHERAL_BRIGHTNESS_MAX;
|
|
Rainbow.brightness = EVGA_PERIPHERAL_BRIGHTNESS_MAX;
|
|
Rainbow.speed_min = EVGA_PERIPHERAL_SPEED_SLOWEST;
|
|
Rainbow.speed_max = EVGA_PERIPHERAL_SPEED_FASTEST;
|
|
Rainbow.speed = EVGA_PERIPHERAL_SPEED_FASTEST;
|
|
Rainbow.colors = {COLOR_RED, COLOR_YELLOW, COLOR_GREEN, COLOR_CYAN, COLOR_BLUE, COLOR_MAGENTA, COLOR_WHITE};
|
|
Rainbow.color_mode = MODE_COLORS_NONE;
|
|
modes.push_back(Rainbow);
|
|
|
|
mode Pulse;
|
|
Pulse.name = "Pulse";
|
|
Pulse.value = EVGA_PERIPHERAL_MODE_PULSE;
|
|
Pulse.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
|
|
Pulse.brightness_min = EVGA_PERIPHERAL_BRIGHTNESS_MIN;
|
|
Pulse.brightness_max = EVGA_PERIPHERAL_BRIGHTNESS_MAX;
|
|
Pulse.brightness = EVGA_PERIPHERAL_BRIGHTNESS_MAX;
|
|
Pulse.speed_min = EVGA_PERIPHERAL_SPEED_SLOWEST;
|
|
Pulse.speed_max = EVGA_PERIPHERAL_SPEED_FASTEST;
|
|
Pulse.speed = EVGA_PERIPHERAL_SPEED_FASTEST;
|
|
Pulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
|
Pulse.colors_min = 2;
|
|
Pulse.colors_max = 7;
|
|
Pulse.colors = {COLOR_RED, COLOR_YELLOW, COLOR_GREEN, COLOR_CYAN, COLOR_BLUE, COLOR_MAGENTA, COLOR_WHITE};
|
|
modes.push_back(Pulse);
|
|
|
|
mode Trigger;
|
|
Trigger.name = "Trigger";
|
|
/*-----------------------------------*\
|
|
| Pulse to Trigger skips from 4 to 6. |
|
|
\*-----------------------------------*/
|
|
Trigger.value = EVGA_PERIPHERAL_MODE_TRIGGER;
|
|
Trigger.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
|
|
Trigger.brightness_min = EVGA_PERIPHERAL_BRIGHTNESS_MIN;
|
|
Trigger.brightness_max = EVGA_PERIPHERAL_BRIGHTNESS_MAX;
|
|
Trigger.brightness = EVGA_PERIPHERAL_BRIGHTNESS_MAX;
|
|
Trigger.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
|
Trigger.colors_min = 7;
|
|
Trigger.colors_max = 7;
|
|
Trigger.colors = {COLOR_RED, COLOR_YELLOW, COLOR_GREEN, COLOR_CYAN, COLOR_BLUE, COLOR_MAGENTA, COLOR_WHITE};
|
|
modes.push_back(Trigger);
|
|
|
|
active_mode = EVGA_PERIPHERAL_MODE_STATIC;
|
|
|
|
Init_Controller();
|
|
SetupZones();
|
|
|
|
EVGAMouseControllerDeviceState current_state = controller->GetState();
|
|
for(unsigned int i = 0; i < modes.size(); i++)
|
|
{
|
|
if(modes[i].value == current_state.mode)
|
|
{
|
|
active_mode = i;
|
|
break;
|
|
}
|
|
}
|
|
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
|
|
{
|
|
modes[active_mode].colors = current_state.colors;
|
|
}
|
|
modes[active_mode].brightness = current_state.brightness;
|
|
modes[active_mode].speed = current_state.speed;
|
|
colors.resize(EVGA_PERIPHERAL_LED_COUNT);
|
|
for(unsigned int i = 0; i < colors.size(); i++)
|
|
{
|
|
colors[i] = controller->GetColorOfLed(i);
|
|
}
|
|
}
|
|
|
|
RGBController_EVGAMouse::~RGBController_EVGAMouse()
|
|
{
|
|
delete controller;
|
|
}
|
|
|
|
void RGBController_EVGAMouse::Init_Controller()
|
|
{
|
|
/*------------------------------------------------------------------------------------------*\
|
|
| Since each LED can have its own mode, each one needs to be its own zone with a single LED. |
|
|
\*------------------------------------------------------------------------------------------*/
|
|
zone front_zone;
|
|
front_zone.name = "Front";
|
|
front_zone.type = ZONE_TYPE_SINGLE;
|
|
front_zone.leds_min = 1;
|
|
front_zone.leds_max = 1;
|
|
front_zone.leds_count = 1;
|
|
front_zone.matrix_map = NULL;
|
|
zones.push_back(front_zone);
|
|
|
|
zone wheel_zone;
|
|
wheel_zone.name = "Scroll Wheel";
|
|
wheel_zone.type = ZONE_TYPE_SINGLE;
|
|
wheel_zone.leds_min = 1;
|
|
wheel_zone.leds_max = 1;
|
|
wheel_zone.leds_count = 1;
|
|
wheel_zone.matrix_map = NULL;
|
|
zones.push_back(wheel_zone);
|
|
|
|
zone logo_zone;
|
|
logo_zone.name = "Logo";
|
|
logo_zone.type = ZONE_TYPE_SINGLE;
|
|
logo_zone.leds_min = 1;
|
|
logo_zone.leds_max = 1;
|
|
logo_zone.leds_count = 1;
|
|
logo_zone.matrix_map = NULL;
|
|
zones.push_back(logo_zone);
|
|
|
|
led front_led;
|
|
front_led.name = "Front LED";
|
|
front_led.value = 0;
|
|
leds.push_back(front_led);
|
|
|
|
led wheel_led;
|
|
wheel_led.name = "Scroll Wheel LED";
|
|
wheel_led.value = 1;
|
|
leds.push_back(wheel_led);
|
|
|
|
led back_led;
|
|
back_led.name = "Back LED";
|
|
back_led.value = 2;
|
|
leds.push_back(back_led);
|
|
}
|
|
|
|
void RGBController_EVGAMouse::SetupZones()
|
|
{
|
|
SetupColors();
|
|
}
|
|
|
|
void RGBController_EVGAMouse::ResizeZone(int /* zone */, int /* new_size */)
|
|
{
|
|
/*--------------------------------------*\
|
|
| This device does not support resizing. |
|
|
\*--------------------------------------*/
|
|
}
|
|
|
|
void RGBController_EVGAMouse::DeviceUpdateLEDs()
|
|
{
|
|
for(unsigned int i = 0; i < colors.size(); i++)
|
|
{
|
|
controller->SetLed(i, modes[active_mode].brightness, modes[active_mode].speed, colors[i]);
|
|
}
|
|
}
|
|
|
|
void RGBController_EVGAMouse::UpdateZoneLEDs(int zone)
|
|
{
|
|
controller->SetLed(zone, modes[active_mode].brightness, modes[active_mode].speed, colors[zone]);
|
|
}
|
|
|
|
void RGBController_EVGAMouse::UpdateSingleLED(int led)
|
|
{
|
|
controller->SetLed(led, modes[active_mode].brightness, modes[active_mode].speed, colors[led]);
|
|
}
|
|
|
|
void RGBController_EVGAMouse::DeviceUpdateMode()
|
|
{
|
|
controller->SetMode(modes[active_mode].value);
|
|
/*--------------------------------------------------------------------*\
|
|
| Modes with specific colors should use their mode's colors. All other |
|
|
| modes should use the colors stored in this controller. |
|
|
\*--------------------------------------------------------------------*/
|
|
std::vector<RGBColor>* temp_colors = &colors;
|
|
/*-------------------------------------------------------------------------------------------------*\
|
|
| Rainbow does not have mode specific colors that can be controlled by OpenRGB, so it does not have |
|
|
| the corresponding flag. However, to properly activate it, you still must pass the correct list of |
|
|
| colors in the LED packet. Specifying the wrong number of colors causes the effect to restart the |
|
|
| cycle earlier in the sequence than it is supposed to. |
|
|
\*-------------------------------------------------------------------------------------------------*/
|
|
if((modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR) || modes[active_mode].value == EVGA_PERIPHERAL_MODE_RAINBOW)
|
|
{
|
|
temp_colors = &(modes[active_mode].colors);
|
|
}
|
|
if(modes[active_mode].value == EVGA_PERIPHERAL_MODE_BREATHING)
|
|
{
|
|
controller->SetAllLedsAndActivate(modes[active_mode].brightness, modes[active_mode].speed, *temp_colors);
|
|
}
|
|
else
|
|
{
|
|
controller->SetAllLeds(modes[active_mode].brightness, modes[active_mode].speed, *temp_colors);
|
|
}
|
|
}
|
|
|
|
void RGBController_EVGAMouse::DeviceSaveMode()
|
|
{
|
|
|
|
}
|
|
|
|
int RGBController_EVGAMouse::GetDeviceMode()
|
|
{
|
|
return controller->GetMode();
|
|
}
|
|
|