mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-04-04 22:24:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

Add support for Redragon M914. Create generic Areson driver

Browse Source
This commit is contained in:
Dawid Kasieczka
2025-12-29 19:43:51 +00:00
committed by Adam Honse
parent 1a6d68d3bf
commit 1d208c14fa
6 changed files with 277 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
Controllers/ZETEdgeAirProController/ZETEdgeAirProController.cpp → Controllers/AresonController/AresonController.cpp
View File

@@ -1,7 +1,7 @@
/*---------------------------------------------------------*\
| ZETEdgeAirProController.cpp |
| AresonController.cpp |
| |
| Driver for ZET Edge Air Pro |
| Driver for Areson mice |
| |
| Morgan Guimard (morg) 29 Jan 2022 |
| |
@@ -11,31 +11,31 @@
#include <string.h>
#include "StringUtils.h"
#include "ZETEdgeAirProController.h"
#include "AresonController.h"
ZETEdgeAirProController::ZETEdgeAirProController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name)
AresonController::AresonController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name)
{
dev = dev_handle;
location = info.path;
name = dev_name;
}
ZETEdgeAirProController::~ZETEdgeAirProController()
AresonController::~AresonController()
{
hid_close(dev);
}
std::string ZETEdgeAirProController::GetDeviceLocation()
std::string AresonController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string ZETEdgeAirProController::GetNameString()
std::string AresonController::GetNameString()
{
return(name);
}
std::string ZETEdgeAirProController::GetSerialString()
std::string AresonController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
@@ -48,19 +48,47 @@ std::string ZETEdgeAirProController::GetSerialString()
return(StringUtils::wstring_to_string(serial_string));
}
void ZETEdgeAirProController::SetMode(RGBColor color, unsigned char brightness, unsigned char speed, unsigned char mode_value)
unsigned char AresonController::GetSpeedValue(unsigned char speed, unsigned char mode_value)
{
unsigned char speed_values_lookup_high[ARESON_SPEED_MAX] =
{
0xFF, 0xE6, 0xD2, 0xBe, 0xAA, 0x96, 0x82, 0x6E, 0x46, 0x28
};
unsigned char speed_values_lookup_low[ARESON_SPEED_MAX] =
{
0x2D, 0x28, 0x23, 0x1E, 0x19, 0x13, 0x0F, 0x0A, 0x05, 0x03
};
switch (mode_value)
{
case BREATHING_MODE_VALUE:
case SPECRTUM_CYCLE_MODE_VALUE:
case SINGLE_COLOR_WAVE_MODE_VALUE:
case BREATHING_COLORFUL_MODE_VALUE:
return speed_values_lookup_high[speed -1];
case RAINBOW_WAVE_MODE_VALUE:
return speed_values_lookup_low[speed -1];
default:
return 0;
}
}
void AresonController::SetMode(RGBColor color, unsigned char brightness, unsigned char speed, unsigned char mode_value)
{
/*---------------------------------------------------------*\
| Init the packet buffer |
\*---------------------------------------------------------*/
unsigned char usb_buf[ZET_EDGE_AIR_PRO_PACKET_SIZE];
unsigned char usb_buf[ARESON_PACKET_SIZE];
memset(usb_buf, 0x00, sizeof(usb_buf));
/*---------------------------------------------------------*\œ
| Constant data |
\*---------------------------------------------------------*/
usb_buf[0x00] = ZET_EDGE_AIR_PRO_REPORT_ID;
usb_buf[0x00] = ARESON_REPORT_ID;
usb_buf[0x01] = 0x07;
usb_buf[0x04] = 0xA0;
usb_buf[0x05] = 0x07;
@@ -80,30 +108,14 @@ void ZETEdgeAirProController::SetMode(RGBColor color, unsigned char brightness,
/*---------------------------------------------------------*\
| Set speed if needed |
\*---------------------------------------------------------*/
if(mode_value == BREATHING_MODE_VALUE)
{
unsigned char speed_values[ZET_EDGE_AIR_PRO_SPEED_MAX] =
{
0xFF, 0xE6, 0xD2, 0xBe, 0xAA, 0x96, 0x82, 0x6E, 0x46, 0x28
};
usb_buf[0x0A] = GetSpeedValue(speed, mode_value);
usb_buf[0x0A] = speed_values[speed - 1];
}
else if(mode_value == RAINBOW_MODE_VALUE)
{
unsigned char speed_values[ZET_EDGE_AIR_PRO_SPEED_MAX] =
{
0x2D, 0x28, 0x23, 0x1E, 0x19, 0x13, 0x0F, 0x0A, 0x05, 0x03
};
usb_buf[0x0A] = speed_values[speed - 1];
}
/*---------------------------------------------------------*\
| Set brightness if needed |
\*---------------------------------------------------------*/
if(mode_value != OFF_MODE_VALUE)
{
unsigned char brightness_values[ZET_EDGE_AIR_PRO_BRIGHTNESS_MAX] =
unsigned char brightness_values[ARESON_BRIGHTNESS_MAX] =
{
0x19, 0x32, 0x4B, 0x64, 0x7D, 0x96, 0xAF, 0xC8, 0xE1, 0xFF
};
@@ -119,10 +131,10 @@ void ZETEdgeAirProController::SetMode(RGBColor color, unsigned char brightness,
/*---------------------------------------------------------*\
| Constant data |
\*---------------------------------------------------------*/
usb_buf[0x10] = ZET_EDGE_AIR_PRO_PACKET_END;
usb_buf[0x10] = ARESON_PACKET_END;
/*---------------------------------------------------------*\
| Send the report |
\*---------------------------------------------------------*/
hid_send_feature_report(dev, usb_buf, ZET_EDGE_AIR_PRO_PACKET_SIZE);
hid_send_feature_report(dev, usb_buf, ARESON_PACKET_SIZE);
}

37
Controllers/ZETEdgeAirProController/ZETEdgeAirProController.h → Controllers/AresonController/AresonController.h
View File

@@ -1,7 +1,7 @@
/*---------------------------------------------------------*\
| ZETEdgeAirProController.h |
| AresonController.h |
| |
| Driver for ZET Edge Air Pro |
| Driver for Areson mice |
| |
| Morgan Guimard (morg) 29 Jan 2022 |
| |
@@ -15,31 +15,35 @@
#include <hidapi.h>
#include "RGBController.h"
#define ZET_EDGE_AIR_PRO_PACKET_SIZE 17
#define ZET_EDGE_AIR_PRO_REPORT_ID 0x08
#define ZET_EDGE_AIR_PRO_PACKET_END 0x4a
#define ARESON_PACKET_SIZE 17
#define ARESON_REPORT_ID 0x08
#define ARESON_PACKET_END 0x4A
enum
{
STATIC_MODE_VALUE = 0x02,
OFF_MODE_VALUE = 0x04,
RAINBOW_MODE_VALUE = 0x00,
BREATHING_MODE_VALUE = 0x01
RAINBOW_WAVE_MODE_VALUE = 0x00,
BREATHING_MODE_VALUE = 0x01,
STATIC_MODE_VALUE = 0x02,
SPECRTUM_CYCLE_MODE_VALUE = 0x03,
OFF_MODE_VALUE = 0x04,
SINGLE_COLOR_WAVE_MODE_VALUE = 0x05,
BREATHING_COLORFUL_MODE_VALUE = 0x07,
};
enum
{
ZET_EDGE_AIR_PRO_BRIGHTNESS_MIN = 1,
ZET_EDGE_AIR_PRO_BRIGHTNESS_MAX = 10,
ZET_EDGE_AIR_PRO_SPEED_MIN = 1,
ZET_EDGE_AIR_PRO_SPEED_MAX = 10
ARESON_BRIGHTNESS_MIN = 1,
ARESON_BRIGHTNESS_MAX = 10,
ARESON_SPEED_MIN = 1,
ARESON_SPEED_MAX = 10
};
class ZETEdgeAirProController
class AresonController
{
public:
ZETEdgeAirProController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name);
~ZETEdgeAirProController();
AresonController(hid_device* dev_handle, const hid_device_info& info, std::string dev_name);
~AresonController();
std::string GetDeviceLocation();
std::string GetNameString();
@@ -53,4 +57,5 @@ protected:
private:
std::string location;
std::string name;
unsigned char GetSpeedValue(unsigned char speed, unsigned char mode_value);
};

30
Controllers/ZETEdgeAirProController/ZETEdgeAirProControllerDetect.cpp → Controllers/AresonController/AresonControllerDetect.cpp
View File

@@ -1,7 +1,7 @@
/*---------------------------------------------------------*\
| ZETEdgeAirProControllerDetect.cpp |
| AresonControllerDetect.cpp |
| |
| Detector for ZET Edge Air Pro |
| Detector for Areson mice |
| |
| Morgan Guimard (morg) 29 Jan 2022 |
| |
@@ -10,13 +10,13 @@
\*---------------------------------------------------------*/
#include "Detector.h"
#include "ZETEdgeAirProController.h"
#include "RGBController_ZETEdgeAirPro.h"
#include "AresonController.h"
#include "RGBController_Areson.h"
/*---------------------------------------------------------*\
| ZET GAMING vendor ID |
| Areson vendor ID |
\*---------------------------------------------------------*/
#define ZET_GAMING_VID 0x25A7
#define ARESON_VID 0x25A7
/*---------------------------------------------------------*\
| Product ID |
@@ -25,21 +25,25 @@
#define ZET_GAMING_EDGE_AIR_PRO_PID 0xFA40
#define ZET_GAMING_EDGE_AIR_ELIT_WIRELESS_PID 0xFA48
#define ZET_GAMING_EDGE_AIR_ELIT_PID 0xFA49
#define REDRAGON_M914_PID 0xFA7B
#define REDRAGON_M914_WIRELESS_PID 0xFA7C
void DetectZETGAMINGEdgeAirProControllers(hid_device_info* info, const std::string& name)
void DetectAresonControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
ZETEdgeAirProController* controller = new ZETEdgeAirProController(dev, *info, name);
RGBController_ZETEdgeAirPro* rgb_controller = new RGBController_ZETEdgeAirPro(controller);
AresonController* controller = new AresonController(dev, *info, name);
RGBController_Areson* rgb_controller = new RGBController_Areson(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR_IPU("ZET GAMING Edge Air Pro (Wireless)", DetectZETGAMINGEdgeAirProControllers, ZET_GAMING_VID, ZET_GAMING_EDGE_AIR_PRO_WIRELESS_PID, 1, 0xFF02, 2);
REGISTER_HID_DETECTOR_IPU("ZET GAMING Edge Air Pro", DetectZETGAMINGEdgeAirProControllers, ZET_GAMING_VID, ZET_GAMING_EDGE_AIR_PRO_PID, 1, 0xFF02, 2);
REGISTER_HID_DETECTOR_IPU("ZET GAMING Edge Air Elit (Wireless)", DetectZETGAMINGEdgeAirProControllers, ZET_GAMING_VID, ZET_GAMING_EDGE_AIR_ELIT_WIRELESS_PID, 1, 0xFF02, 2);
REGISTER_HID_DETECTOR_IPU("ZET GAMING Edge Air Elit", DetectZETGAMINGEdgeAirProControllers, ZET_GAMING_VID, ZET_GAMING_EDGE_AIR_ELIT_PID, 1, 0xFF02, 2);
REGISTER_HID_DETECTOR_IPU("ZET GAMING Edge Air Pro (Wireless)", DetectAresonControllers, ARESON_VID, ZET_GAMING_EDGE_AIR_PRO_WIRELESS_PID, 1, 0xFF02, 2);
REGISTER_HID_DETECTOR_IPU("ZET GAMING Edge Air Pro", DetectAresonControllers, ARESON_VID, ZET_GAMING_EDGE_AIR_PRO_PID, 1, 0xFF02, 2);
REGISTER_HID_DETECTOR_IPU("ZET GAMING Edge Air Elit (Wireless)", DetectAresonControllers, ARESON_VID, ZET_GAMING_EDGE_AIR_ELIT_WIRELESS_PID, 1, 0xFF02, 2);
REGISTER_HID_DETECTOR_IPU("ZET GAMING Edge Air Elit", DetectAresonControllers, ARESON_VID, ZET_GAMING_EDGE_AIR_ELIT_PID, 1, 0xFF02, 2);
REGISTER_HID_DETECTOR_IPU("Redragon M914 NIX (Wireless)", DetectAresonControllers, ARESON_VID, REDRAGON_M914_WIRELESS_PID, 1, 0xFF02, 2);
REGISTER_HID_DETECTOR_IPU("Redragon M914 NIX", DetectAresonControllers, ARESON_VID, REDRAGON_M914_PID, 1, 0xFF02, 2);

189
Controllers/AresonController/RGBController_Areson.cpp Normal file
View File

@@ -0,0 +1,189 @@
/*---------------------------------------------------------*\
| RGBController_Areson.cpp |
| |
| RGBController for Areson mice |
| |
| Morgan Guimard (morg) 29 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <chrono>
#include <thread>
#include "RGBController_Areson.h"
/**------------------------------------------------------------------*\
@name Areson
@category Mouse
@type USB
@save :x:
@direct :x:
@effects :white_check_mark:
@detectors DetectAresonControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_Areson::RGBController_Areson(AresonController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetNameString();
vendor = "Areson";
type = DEVICE_TYPE_MOUSE;
description = "Areson mouse";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Static;
Static.name = "Static";
Static.value = STATIC_MODE_VALUE;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_PER_LED;
Static.brightness_min = ARESON_BRIGHTNESS_MIN;
Static.brightness_max = ARESON_BRIGHTNESS_MAX;
Static.brightness = ARESON_BRIGHTNESS_MAX;
modes.push_back(Static);
mode RainbowWave;
RainbowWave.name = "Rainbow Wave";
RainbowWave.value = RAINBOW_WAVE_MODE_VALUE;
RainbowWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
RainbowWave.color_mode = MODE_COLORS_NONE;
RainbowWave.brightness_min = ARESON_BRIGHTNESS_MIN;
RainbowWave.brightness_max = ARESON_BRIGHTNESS_MAX;
RainbowWave.brightness = ARESON_BRIGHTNESS_MAX;
RainbowWave.speed_min = ARESON_SPEED_MIN;
RainbowWave.speed_max = ARESON_SPEED_MAX;
RainbowWave.speed = ARESON_SPEED_MAX;
modes.push_back(RainbowWave);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = BREATHING_MODE_VALUE;
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.brightness_min = ARESON_BRIGHTNESS_MIN;
Breathing.brightness_max = ARESON_BRIGHTNESS_MAX;
Breathing.brightness = ARESON_BRIGHTNESS_MAX;
Breathing.speed_min = ARESON_SPEED_MIN;
Breathing.speed_max = ARESON_SPEED_MAX;
Breathing.speed = ARESON_SPEED_MIN;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = SPECRTUM_CYCLE_MODE_VALUE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
SpectrumCycle.brightness_min = ARESON_BRIGHTNESS_MIN;
SpectrumCycle.brightness_max = ARESON_BRIGHTNESS_MAX;
SpectrumCycle.brightness = ARESON_BRIGHTNESS_MAX;
SpectrumCycle.speed_min = ARESON_SPEED_MIN;
SpectrumCycle.speed_max = ARESON_SPEED_MAX;
SpectrumCycle.speed = ARESON_SPEED_MAX;
modes.push_back(SpectrumCycle);
mode SingleColorWave;
SingleColorWave.name = "Single Color Wave";
SingleColorWave.value = SINGLE_COLOR_WAVE_MODE_VALUE;
SingleColorWave.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
SingleColorWave.color_mode = MODE_COLORS_PER_LED;
SingleColorWave.brightness_min = ARESON_BRIGHTNESS_MIN;
SingleColorWave.brightness_max = ARESON_BRIGHTNESS_MAX;
SingleColorWave.brightness = ARESON_BRIGHTNESS_MAX;
SingleColorWave.speed_min = ARESON_SPEED_MIN;
SingleColorWave.speed_max = ARESON_SPEED_MAX;
SingleColorWave.speed = ARESON_SPEED_MAX;
SingleColorWave.colors.resize(1);
modes.push_back(SingleColorWave);
mode ColorfulBreathing;
ColorfulBreathing.name = "Colorful Breathing";
ColorfulBreathing.value = BREATHING_COLORFUL_MODE_VALUE;
ColorfulBreathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
ColorfulBreathing.color_mode = MODE_COLORS_NONE;
ColorfulBreathing.brightness_min = ARESON_BRIGHTNESS_MIN;
ColorfulBreathing.brightness_max = ARESON_BRIGHTNESS_MAX;
ColorfulBreathing.brightness = ARESON_BRIGHTNESS_MAX;
ColorfulBreathing.speed_min = ARESON_SPEED_MIN;
ColorfulBreathing.speed_max = ARESON_SPEED_MAX;
ColorfulBreathing.speed = ARESON_SPEED_MAX;
ColorfulBreathing.colors.resize(1);
modes.push_back(ColorfulBreathing);
mode OFF;
OFF.name = "Off";
OFF.value = OFF_MODE_VALUE;
OFF.flags = MODE_FLAG_AUTOMATIC_SAVE;
OFF.color_mode = MODE_COLORS_NONE;
modes.push_back(OFF);
SetupZones();
}
RGBController_Areson::~RGBController_Areson()
{
delete controller;
}
void RGBController_Areson::SetupZones()
{
zone new_zone;
new_zone.name = "Mouse";
new_zone.type = ZONE_TYPE_LINEAR;
new_zone.leds_min = 1;
new_zone.leds_max = 1;
new_zone.leds_count = 1;
new_zone.matrix_map = nullptr;
zones.emplace_back(new_zone);
leds.resize(1);
led new_led;
new_led.name = "LED 1";
leds[0] = new_led;
SetupColors();
}
void RGBController_Areson::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_Areson::DeviceUpdateLEDs()
{
DeviceUpdateMode();
}
void RGBController_Areson::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateMode();
}
void RGBController_Areson::UpdateSingleLED(int /*led*/)
{
DeviceUpdateMode();
}
void RGBController_Areson::DeviceUpdateMode()
{
RGBColor color;
if(modes[active_mode].flags & MODE_FLAG_HAS_PER_LED_COLOR)
{
color = colors[0];
}
else
{
color = ToRGBColor(0,0,0);
}
controller->SetMode(color, modes[active_mode].brightness, modes[active_mode].speed, modes[active_mode].value);
}

14
Controllers/ZETEdgeAirProController/RGBController_ZETEdgeAirPro.h → Controllers/AresonController/RGBController_Areson.h
View File

@@ -1,7 +1,7 @@
/*---------------------------------------------------------*\
| RGBController_ZETEdgeAirPro.h |
| RGBController_Areson.h |
| |
| RGBController for ZET Edge Air Pro |
| RGBController for Areson mice |
| |
| Morgan Guimard (morg) 29 Jan 2022 |
| |
@@ -12,13 +12,13 @@
#pragma once
#include "RGBController.h"
#include "ZETEdgeAirProController.h"
#include "AresonController.h"
class RGBController_ZETEdgeAirPro : public RGBController
class RGBController_Areson : public RGBController
{
public:
RGBController_ZETEdgeAirPro(ZETEdgeAirProController* controller_ptr);
~RGBController_ZETEdgeAirPro();
RGBController_Areson(AresonController* controller_ptr);
~RGBController_Areson();
void SetupZones();
void ResizeZone(int zone, int new_size);
@@ -30,5 +30,5 @@ public:
void DeviceUpdateMode();
private:
ZETEdgeAirProController* controller;
AresonController* controller;
};

148
Controllers/ZETEdgeAirProController/RGBController_ZETEdgeAirPro.cpp
View File

@@ -1,148 +0,0 @@
/*---------------------------------------------------------*\
| RGBController_ZETEdgeAirPro.cpp |
| |
| RGBController for ZET Edge Air Pro |
| |
| Morgan Guimard (morg) 29 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <chrono>
#include <thread>
#include "RGBController_ZETEdgeAirPro.h"
/**------------------------------------------------------------------*\
@name ZET Edge Air Pro
@category Mouse
@type USB
@save :x:
@direct :x:
@effects :white_check_mark:
@detectors DetectZETGAMINGEdgeAirProControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_ZETEdgeAirPro::RGBController_ZETEdgeAirPro(ZETEdgeAirProController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetNameString();
vendor = "ZET Gaming";
type = DEVICE_TYPE_MOUSE;
description = "ZET Edge Air Pro Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Static;
Static.name = "Static";
Static.value = STATIC_MODE_VALUE;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_PER_LED;
Static.brightness_min = ZET_EDGE_AIR_PRO_BRIGHTNESS_MIN;
Static.brightness_max = ZET_EDGE_AIR_PRO_BRIGHTNESS_MAX;
Static.brightness = ZET_EDGE_AIR_PRO_BRIGHTNESS_MAX;
modes.push_back(Static);
mode OFF;
OFF.name = "Off";
OFF.value = OFF_MODE_VALUE;
OFF.flags = MODE_FLAG_AUTOMATIC_SAVE;
OFF.color_mode = MODE_COLORS_NONE;
modes.push_back(OFF);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = RAINBOW_MODE_VALUE;
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.brightness_min = ZET_EDGE_AIR_PRO_BRIGHTNESS_MIN;
Rainbow.brightness_max = ZET_EDGE_AIR_PRO_BRIGHTNESS_MAX;
Rainbow.brightness = ZET_EDGE_AIR_PRO_BRIGHTNESS_MAX;
Rainbow.speed_min = ZET_EDGE_AIR_PRO_SPEED_MIN;
Rainbow.speed_max = ZET_EDGE_AIR_PRO_SPEED_MAX;
Rainbow.speed = ZET_EDGE_AIR_PRO_SPEED_MIN;
modes.push_back(Rainbow);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = BREATHING_MODE_VALUE;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.brightness_min = ZET_EDGE_AIR_PRO_BRIGHTNESS_MIN;
Breathing.brightness_max = ZET_EDGE_AIR_PRO_BRIGHTNESS_MAX;
Breathing.brightness = ZET_EDGE_AIR_PRO_BRIGHTNESS_MAX;
Breathing.speed_min = ZET_EDGE_AIR_PRO_SPEED_MIN;
Breathing.speed_max = ZET_EDGE_AIR_PRO_SPEED_MAX;
Breathing.speed = ZET_EDGE_AIR_PRO_SPEED_MIN;
Breathing.colors.resize(1);
modes.push_back(Breathing);
SetupZones();
}
RGBController_ZETEdgeAirPro::~RGBController_ZETEdgeAirPro()
{
delete controller;
}
void RGBController_ZETEdgeAirPro::SetupZones()
{
zone new_zone;
new_zone.name = "Mouse";
new_zone.type = ZONE_TYPE_LINEAR;
new_zone.leds_min = 1;
new_zone.leds_max = 1;
new_zone.leds_count = 1;
new_zone.matrix_map = nullptr;
zones.emplace_back(new_zone);
leds.resize(1);
led new_led;
new_led.name = "LED 1";
leds[0] = new_led;
SetupColors();
}
void RGBController_ZETEdgeAirPro::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_ZETEdgeAirPro::DeviceUpdateLEDs()
{
DeviceUpdateMode();
}
void RGBController_ZETEdgeAirPro::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateMode();
}
void RGBController_ZETEdgeAirPro::UpdateSingleLED(int /*led*/)
{
DeviceUpdateMode();
}
void RGBController_ZETEdgeAirPro::DeviceUpdateMode()
{
RGBColor color;
if(modes[active_mode].flags & MODE_FLAG_HAS_PER_LED_COLOR)
{
color = colors[0];
}
else
{
color = ToRGBColor(0,0,0);
}
controller->SetMode(color, modes[active_mode].brightness, modes[active_mode].speed, modes[active_mode].value);
}