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

Automatic generation of markdown pages for supported devices

Browse source 
+ Added build-supported-devices.sh script
+ Added new target in CI/CD to build at compile time
This commit is contained in:
Chris 2022-05-25 17:58:59 +10:00
parent a7adfe251b
commit 524675108d
163 changed files with 699 additions and 265 deletions
Download patch file Download diff file Expand all files Collapse all files

25
.gitlab-ci.yml
View file

@ -27,6 +27,31 @@ before_script:
- export QT_SELECT=qt5
- export APPIMAGE_EXTRACT_AND_RUN=1
#-----------------------------------------------------------------------#
# Supported Devices Build Target #
#-----------------------------------------------------------------------#
"Supported Devices":
<<: *ccache_init
image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
stage: build
script:
- qmake
- make -j$(nproc)
- ./scripts/build-supported-devices-md.sh $CI_PROJECT_DIR $CI_COMMIT_SHORT_SHA
artifacts:
name: "${CI_PROJECT_NAME}_Supported_Devices_${CI_COMMIT_SHORT_SHA}"
paths:
- ./*.md
exclude:
- README.md
- CONTRIBUTING.md
expire_in: 30 days
rules:
- if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
when: on_success
#-----------------------------------------------------------------------#
# Linux (AppImage) 32-bit Build Target #
#-----------------------------------------------------------------------#

1
Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name AMD Wraith Prism
@category Cooler
@type USB
@save :x:
@direct :white_check_mark:

3
Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.cpp
View file

@ -34,6 +34,7 @@ static const char* polychrome_v2_zone_names[] =
/**------------------------------------------------------------------*\
@name ASRock Polychrome SMBus
@category Motherboard
@type SMBus
@save :warning:
@direct :x:
@ -506,7 +507,7 @@ void RGBController_Polychrome::SetupZones()
{
new_zone->name = polychrome_v2_zone_names[zone_idx];
}
if(zone_idx == POLYCHROME_ZONE_ADDRESSABLE)
{
new_zone->leds_min = 1;

17
Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp
View file

@ -15,6 +15,7 @@
/**------------------------------------------------------------------*\
@name ASrock Polychrome USB
@category Motherboard
@type USB
@save :warning:
@direct :x:
@ -203,15 +204,15 @@ void RGBController_PolychromeUSB::SetupZones()
zones[channel_idx].name = polychrome_USB_zone_names[device_info.zone_type];
zones[channel_idx].leds_min = 0;
zones[channel_idx].leds_max = ASROCK_ADDRESSABLE_MAX_LEDS;
zones[channel_idx].leds_count = device_info.num_leds;
zones[channel_idx].leds_count = device_info.num_leds;
}
else if(device_info.device_type==PolychromeDeviceType::FIXED)
else if(device_info.device_type==PolychromeDeviceType::FIXED)
{
zones[channel_idx].name = polychrome_USB_zone_names[device_info.zone_type];
zones[channel_idx].leds_min = device_info.num_leds;
zones[channel_idx].leds_max = device_info.num_leds;
zones[channel_idx].leds_count = device_info.num_leds;
}
zones[channel_idx].leds_count = device_info.num_leds;
}
for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
@ -247,7 +248,7 @@ void RGBController_PolychromeUSB::SetupZones()
for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
{
PolychromeZoneInfo zoneinfo;
zoneinfo = controller->GetZoneConfig(channel_idx);
zoneinfo = controller->GetZoneConfig(channel_idx);
zones_info.push_back(zoneinfo);
}
@ -320,7 +321,7 @@ unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
dev_mode = controller->GetZoneConfig(zone).mode;
active_mode = dev_mode;
return(active_mode);
return(active_mode);
}
void RGBController_PolychromeUSB::SetCustomMode()
@ -337,10 +338,10 @@ void RGBController_PolychromeUSB::DeviceUpdateMode()
unsigned char set_mode =(unsigned char) modes[active_mode].value;
zones_info[zone_idx].mode =(unsigned char) modes[active_mode].value;
zones_info[zone_idx].speed =(unsigned char) modes[active_mode].speed;
if(set_mode > modes.size())
{
set_mode = active_mode;
set_mode = active_mode;
}
controller->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);

5
Controllers/AlienwareController/RGBController_Alienware.cpp
View file

@ -14,6 +14,7 @@
/**------------------------------------------------------------------*\
@name Alienware
@category Keyboard
@type USB
@save :x:
@direct :x:
@ -147,7 +148,7 @@ void RGBController_Alienware::SetupZones()
for(unsigned int led_idx = 0; led_idx < zones.size(); led_idx++)
{
led new_led;
new_led.name = zones[led_idx].name + std::string(" LED");
leds.emplace_back(new_led);
@ -228,7 +229,7 @@ void RGBController_Alienware::DeviceUpdateMode()
uint16_t period = 0x07d0;
controller->SetMode(zone_idx, current_mode.value);
switch(current_mode_idx)
{
case ALIENWARE_MODE_COLOR:

1
Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.cpp
View file

@ -160,6 +160,7 @@ static const led_type led_names[] =
/**------------------------------------------------------------------*\
@name Alienware AW510 Keyboard
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:

23
Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp
View file

@ -18,7 +18,7 @@ static unsigned int matrix_map[5][14] =
{ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 },
{ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27 },
{ 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, NA },
{ 41, NA, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, NA },
{ 41, NA, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, NA },
{ 53, NA, 54, 55, NA, NA, 56, NA, NA, 57, 58, 59, 60, NA } };
static const char* zone_names[] =
@ -110,6 +110,7 @@ static const led_type led_names[] =
/**------------------------------------------------------------------*\
@name Anne Pro 2
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:
@ -118,7 +119,7 @@ static const led_type led_names[] =
@comment
\*-------------------------------------------------------------------*/
RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_ptr)
RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_ptr)
{
controller = controller_ptr;
@ -139,12 +140,12 @@ RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_pt
SetupZones();
}
RGBController_AnnePro2::~RGBController_AnnePro2()
RGBController_AnnePro2::~RGBController_AnnePro2()
{
delete controller;
}
void RGBController_AnnePro2::SetupZones()
void RGBController_AnnePro2::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zones |
@ -187,14 +188,14 @@ void RGBController_AnnePro2::SetupZones()
SetupColors();
}
void RGBController_AnnePro2::ResizeZone(int /*zone*/, int /*new_size*/)
void RGBController_AnnePro2::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AnnePro2::DeviceUpdateLEDs()
void RGBController_AnnePro2::DeviceUpdateLEDs()
{
const unsigned char frame_buf_length = LED_REAL_COUNT * 3;
unsigned char frame_buf[frame_buf_length];
@ -225,22 +226,22 @@ void RGBController_AnnePro2::DeviceUpdateLEDs()
controller->SendDirect(frame_buf_length, frame_buf);
}
void RGBController_AnnePro2::UpdateZoneLEDs(int /*zone*/)
void RGBController_AnnePro2::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_AnnePro2::UpdateSingleLED(int /*led*/)
void RGBController_AnnePro2::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_AnnePro2::SetCustomMode()
void RGBController_AnnePro2::SetCustomMode()
{
active_mode = 0;
}
void RGBController_AnnePro2::DeviceUpdateMode()
void RGBController_AnnePro2::DeviceUpdateMode()
{
}

3
Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.cpp
View file

@ -10,6 +10,7 @@
/**------------------------------------------------------------------*\
@name Asus AURA Core
@category Keyboard,LEDStrip
@type USB
@save :x:
@direct :warning:
@ -25,7 +26,7 @@ RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_pt
name = "ASUS Aura Core Device";
vendor = "ASUS";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
serial = controller->GetSerialString();
description = "ASUS Aura Core Device";
type = DEVICE_TYPE_UNKNOWN;

15
Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp
View file

@ -18,7 +18,7 @@ int RGBController_AuraGPU::GetDeviceMode()
if (controller->direct)
{
dev_mode = AURA_GPU_MODE_DIRECT;
}
}
}
switch(dev_mode)
@ -35,7 +35,7 @@ int RGBController_AuraGPU::GetDeviceMode()
{
active_mode = mode;
modes[mode].color_mode = color_mode;
}
}
}
return(active_mode);
@ -43,10 +43,11 @@ int RGBController_AuraGPU::GetDeviceMode()
/**------------------------------------------------------------------*\
@name Asus Aura GPU
@type I2C
@category GPU
@type SMBus
@save :x:
@direct :white_check_mark:
@effects :white_check_mark::
@effects :white_check_mark:
@detectors DetectAsusAuraGPUControllers
@comment
\*-------------------------------------------------------------------*/
@ -165,7 +166,7 @@ void RGBController_AuraGPU::DeviceUpdateLEDs()
{
controller->SetLEDColorsDirect(red, grn, blu);
}
else
else
{
controller->SetLEDColorsEffect(red, grn, blu);
}
@ -191,7 +192,7 @@ void RGBController_AuraGPU::DeviceUpdateMode()
{
int new_mode = modes[active_mode].value;
controller->direct = false;
switch(new_mode)
{
// Set all LEDs to 0 and Mode to static as a workaround for the non existing Off Mode
@ -199,7 +200,7 @@ void RGBController_AuraGPU::DeviceUpdateMode()
controller->SetLEDColorsEffect(0, 0, 0);
new_mode = AURA_GPU_MODE_STATIC;
break;
// Direct mode is done by switching to Static and not applying color changes
case AURA_GPU_MODE_DIRECT:
controller->direct = true;

1
Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Asus Aura Headset Stand
@category HeadsetStand
@type USB
@save :white_check_mark:
@direct :white_check_mark:

3
Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp
View file

@ -40,7 +40,7 @@ static unsigned int scope_tkl_matrix_map[6][18] =
static unsigned int falchion_matrix_map[5][16] =
{ { 0, 5, 9, 14, 18, 22, 26, 31, 35, 39, 44, 49, 54, 58, NA, 63 },
{ 1, NA, 6, 10, 15, 19, 23, 27, 32, 36, 40, 45, 50, 55, 59, 64 },
{ 2, NA, 7, 11, 16, 20, 24, 28, 33, 37, 41, 46, 51, 60, NA, 65 },
{ 2, NA, 7, 11, 16, 20, 24, 28, 33, 37, 41, 46, 51, 60, NA, 65 },
{ 3, NA, 12, 17, 21, 25, 29, 34, 38, 42, 47, 52, 56, NA, 61, 66 },
{ 4, 8, 13, NA, NA, NA, 30, NA, NA, NA, 43, 48, 53, 57, 62, 67 } };
@ -345,6 +345,7 @@ static const std::vector<led_type> default_65pct_led_names =
/**------------------------------------------------------------------*\
@name Asus Aura Keyboard
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:

1
Controllers/AsusAuraUSBController/RGBController_AsusAuraMonitor.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Asus Aura Monitor
@category LEDStrip
@type USB
@save :x:
@direct :white_check_mark:

1
Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp
View file

@ -18,6 +18,7 @@ static std::string aura_mouse_zone_names[3]
/**------------------------------------------------------------------*\
@name Asus Aura Mouse
@category Mouse
@type USB
@save :white_check_mark:
@direct :white_check_mark:

3
Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Asus Aura Mousemat
@category Mousemat
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@ -259,7 +260,7 @@ void RGBController_AuraMousemat::DeviceUpdateMode()
case AURA_MOUSEMAT_MODE_WAVE:
pattern = modes[active_mode].colors.size() * 16 + modes[active_mode].direction;
break;
case AURA_MOUSEMAT_MODE_WAVE_PLANE:
case AURA_MOUSEMAT_MODE_WAVE_PLANE:
switch(modes[active_mode].direction)
{
case MODE_DIRECTION_LEFT:

1
Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Asus Aura Strix Evolve
@category Mouse
@type USB
@save :white_check_mark:
@direct :white_check_mark:

3
Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp
View file

@ -13,6 +13,7 @@
/**------------------------------------------------------------------*\
@name Asus Aura TUF Keyboard
@category Keyboard
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@ -276,7 +277,7 @@ void RGBController_AuraTUFKeyboard::SetCustomMode()
}
void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
{
{
unsigned char color_mode;
std::vector<RGBColor> mode_colors;

3
Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp
View file

@ -11,12 +11,13 @@
/**------------------------------------------------------------------*\
@name Asus Aura USB
@category Motherboard
@type USB
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable,DetectAsusAuraUSBMotherboards
@comment The Asus AUra USB controller applies to most AMD and
@comment The Asus Aura USB controller applies to most AMD and
Intel mainboards from the x470 and z390 chipsets onwards.
\*-------------------------------------------------------------------*/

1
Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp
View file

@ -13,6 +13,7 @@
/**------------------------------------------------------------------*\
@name Asus ROG Strix Liquid Cooler
@category Cooler
@type USB
@save :x:
@direct :white_check_mark:

1
Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.cpp
View file

@ -12,6 +12,7 @@ using namespace std::chrono_literals;
/**------------------------------------------------------------------*\
@name Asus TUF Laptop
@category Keyboard
@type WMI
@save :x:
@direct :white_check_mark:

1
Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp
View file

@ -10,6 +10,7 @@
/**------------------------------------------------------------------*\
@name Blinky Tape
@category LEDStrip
@type Serial
@save :x:
@direct :white_check_mark:

1
Controllers/CoolerMasterController/RGBController_CMARGBController.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Coolermaster ARGB
@category LEDStrip
@type USB
@save :warning:
@direct :white_check_mark:

31
Controllers/CoolerMasterController/RGBController_CMMKController.cpp
View file

@ -22,6 +22,7 @@ using namespace std::chrono_literals;
/**------------------------------------------------------------------*\
@name Coolermaster Masterkeys Keyboards
@category Keyboard
@type USB
@save :warning:
@direct :white_check_mark:
@ -41,7 +42,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
version = controller->GetFirmwareVersion();
serial = "";
location = controller->GetLocation();
mode Direct;
Direct.name = "Direct";
Direct.value = CMMK_MODE_MANUAL;
@ -58,7 +59,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
Static.colors_max = 1;
Static.colors.resize(1);
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = CMMK_EFFECT_BREATHE;
@ -108,7 +109,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
Wave.colors_max = 1;
Wave.colors.resize(1);
modes.push_back(Wave);
mode Ripple;
Ripple.name = "Ripple Effect";
Ripple.value = CMMK_EFFECT_RIPPLE;
@ -121,7 +122,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
Ripple.colors_max = 2;
Ripple.colors.resize(2);
modes.push_back(Ripple);
mode Cross;
Cross.name = "Cross";
Cross.value = CMMK_EFFECT_CROSS;
@ -147,7 +148,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
Raindrops.colors_max = 2;
Raindrops.colors.resize(2);
modes.push_back(Raindrops);
mode Stars;
Stars.name = "Starfield";
Stars.value = CMMK_EFFECT_STARS;
@ -224,7 +225,7 @@ void RGBController_CMMKController::SetupZones()
std::stringstream namestrm;
led key;
namestrm << "Key @ Row " << (y + 1) << ", Column" << (x + 1);
key.name = namestrm.str();
@ -365,7 +366,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
case CMMK_MODE_FIRMWARE:
controller->SetFirmwareControl();
break;
case CMMK_MODE_MANUAL:
controller->SetManualControl();
break;
@ -400,7 +401,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
controller->SetMode(cycle_effect);
}
break;
case CMMK_EFFECT_SINGLE:
{
cmmk_effect_single single_effect;
@ -412,7 +413,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
controller->SetMode(single_effect);
}
break;
case CMMK_EFFECT_WAVE:
{
cmmk_effect_wave wave_effect;
@ -424,7 +425,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
controller->SetMode(wave_effect);
}
break;
case CMMK_EFFECT_RIPPLE:
{
cmmk_effect_ripple ripple_effect;
@ -445,7 +446,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
controller->SetMode(ripple_effect);
}
break;
case CMMK_EFFECT_CROSS:
{
cmmk_effect_cross cross_effect;
@ -457,7 +458,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
controller->SetMode(cross_effect);
}
break;
case CMMK_EFFECT_RAINDROPS:
{
cmmk_effect_raindrops raindrops_effect;
@ -474,12 +475,12 @@ void RGBController_CMMKController::DeviceUpdateMode()
case CMMK_EFFECT_STARS:
{
cmmk_effect_stars stars_effect;
stars_effect.speed = (uint8_t)modes[active_mode].speed;
stars_effect.interval = CMMK_SPEED_MID;
stars_effect.active = map_to_cmmk_rgb(modes[active_mode].colors[0]);
stars_effect.rest = map_to_cmmk_rgb(modes[active_mode].colors[1]);
controller->SetMode(stars_effect);
}
break;
@ -487,7 +488,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
case CMMK_EFFECT_SNAKE:
{
cmmk_effect_snake snake_effect;
snake_effect.speed = (uint8_t)modes[active_mode].speed;
controller->SetMode(snake_effect);

1
Controllers/CoolerMasterController/RGBController_CMMM711Controller.cpp
View file

@ -13,6 +13,7 @@
/**------------------------------------------------------------------*\
@name Coolermaster Master Mouse
@category Mouse
@type USB
@save :warning:
@direct :white_check_mark:

1
Controllers/CoolerMasterController/RGBController_CMMMController.cpp
View file

@ -14,6 +14,7 @@
/**------------------------------------------------------------------*\
@name Coolermaster Master Mouse
@category Mouse
@type USB
@save :white_check_mark:
@direct :white_check_mark:

1
Controllers/CoolerMasterController/RGBController_CMMP750Controller.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Coolermaster Mouse Pad
@category Mousemat
@type USB
@save :warning:
@direct :x:

3
Controllers/CoolerMasterController/RGBController_CMR6000Controller.cpp
View file

@ -10,6 +10,7 @@
/**------------------------------------------------------------------*\
@name AMD Radeon 6000
@category GPU
@type USB
@save :x:
@direct :white_check_mark:
@ -77,7 +78,7 @@ RGBController_CMR6000Controller::RGBController_CMR6000Controller(CMR6000Controll
Breathing.colors_max = 1;
Breathing.colors.resize(1);
Breathing.speed = speed;
modes.push_back(Breathing);
modes.push_back(Breathing);
SetupZones();
active_mode = 1;

1
Controllers/CoolerMasterController/RGBController_CMRGBController.cpp
View file

@ -45,6 +45,7 @@
/**------------------------------------------------------------------*\
@name Coolermaster RGB
@category LEDStrip
@type USB
@save :warning:
@direct :x:

1
Controllers/CoolerMasterController/RGBController_CMSmallARGBController.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Coolermaster Small ARGB
@category LEDStrip
@type USB
@save :warning:
@direct :white_check_mark:

1
Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Corsair Commander Core
@category Cooler
@type USB
@save :x:
@direct :white_check_mark:

1
Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.cpp
View file

@ -10,6 +10,7 @@
/**------------------------------------------------------------------*\
@name Corsair Dominator Platinum
@category RAM
@type SMBus
@save :x:
@direct :white_check_mark:

3
Controllers/CorsairHydroController/RGBController_CorsairHydro.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Corsair Hydro
@category Cooler
@type USB
@save :x:
@direct :white_check_mark:
@ -86,7 +87,7 @@ RGBController_CorsairHydro::~RGBController_CorsairHydro()
void RGBController_CorsairHydro::SetupZones()
{
zone new_zone;
new_zone.name = "Pump Zone";
new_zone.type = ZONE_TYPE_SINGLE;
new_zone.leds_min = 1;

1
Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.cpp
View file

@ -21,6 +21,7 @@ static unsigned int matrix_map[5][5] =
/**------------------------------------------------------------------*\
@name Corsair Hydro Platinum
@category Cooler
@type USB
@save :x:
@direct :white_check_mark:

3
Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Corsair Lighting Node
@category LEDStrip
@type USB
@save :warning:
@direct :white_check_mark:
@ -259,7 +260,7 @@ void RGBController_CorsairLightingNode::SetupZones()
}
zones[channel_idx].matrix_map = NULL;
for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
{
char led_idx_string[4];

1
Controllers/CorsairPeripheralController/RGBController_CorsairK100.cpp
View file

@ -221,6 +221,7 @@ typedef struct
/**------------------------------------------------------------------*\
@name Corsair K100 Keyboard
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:

1
Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPRO.cpp
View file

@ -11,6 +11,7 @@ using namespace std::chrono_literals;
/**------------------------------------------------------------------*\
@name Corsair K55 RGB Pro
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:

1
Controllers/CorsairPeripheralController/RGBController_CorsairK65Mini.cpp
View file

@ -122,6 +122,7 @@ std::vector<std::tuple<unsigned int, std::string>> keys =
/**------------------------------------------------------------------*\
@name Corsair K65 Mini
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:

7
Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp
View file

@ -756,8 +756,9 @@ static const char* corsair_harpoon_pro_leds[] =
/**------------------------------------------------------------------*\
@name Corsair Peripheral
@category Keyboard,Mouse,Mousemat,HeadsetStand
@type USB
@save :white_check_mark: or :warning: or :x:
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectCorsairPeripheralControllers
@ -1037,14 +1038,14 @@ void RGBController_CorsairPeripheral::SetupZones()
new_led.name = corsair_mouse_leds[led_idx];
}
break;
case DEVICE_TYPE_MOUSEMAT:
case DEVICE_TYPE_HEADSET_STAND:
new_led.name = "Mousemat LED ";
new_led.name.append(std::to_string(led_idx + 1));
break;
}
leds.push_back(new_led);
}

1
Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Corsair Vengeance
@category RAM
@type SMBus
@save :warning:
@direct :x:

3
Controllers/CorsairVengeanceProController/RGBController_CorsairVengeancePro.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Corsair Vengeance Pro
@category RAM
@type SMBus
@save :warning:
@direct :white_check_mark:
@ -291,7 +292,7 @@ void RGBController_CorsairVengeancePro::DeviceUpdateMode()
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]);
}
}
}
if (modes[active_mode].name == "Direct")

1
Controllers/CorsairWirelessController/RGBController_CorsairWireless.cpp
View file

@ -182,6 +182,7 @@ static const char* led_names[] =
/**------------------------------------------------------------------*\
@name Corsair Wireless Peripheral
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:

1
Controllers/CougarController/RGBController_CougarRevengerST.cpp
View file

@ -14,6 +14,7 @@
/**------------------------------------------------------------------*\
@name Cougar Revenger ST
@category Mouse
@type USB
@save :x:
@direct :white_check_mark:

1
Controllers/CreativeController/RGBController_CreativeSoundBlasterXG6.cpp
View file

@ -2,6 +2,7 @@
/**------------------------------------------------------------------*\
@name Creative Sound BlasterX G6
@category Headset
@type USB
@save :x:
@direct :white_check_mark:

3
Controllers/CrucialController/RGBController_Crucial.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Crucial RAM
@category RAM
@type SMBus
@save :x:
@direct :white_check_mark:
@ -43,7 +44,7 @@ RGBController_Crucial::RGBController_Crucial(CrucialController* controller_ptr)
Shift.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Shift.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Shift);
mode GradientShift;
GradientShift.name = "Gradient Shift";
GradientShift.value = CRUCIAL_MODE_GRADIENT_SHIFT;

5
Controllers/DarkProject/RGBController_DarkProjectKeyboard.cpp
View file

@ -116,8 +116,9 @@ static const char *led_names[] =
KEY_EN_RIGHT_ARROW
};
/**
/**------------------------------------------------------------------*\
@name Dark Project Keyboard
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:
@ -125,7 +126,7 @@ static const char *led_names[] =
@detectors DetectDarkProjectKeyboardControllers
@comment The Dark Project keyboard controller currently supports
the full size KD3B Version 2 (ANSI layout).
*/
\*-------------------------------------------------------------------*/
RGBController_DarkProjectKeyboard::RGBController_DarkProjectKeyboard(DarkProjectKeyboardController *controller_ptr)
{

1
Controllers/DasKeyboardController/RGBController_DasKeyboard.cpp
View file

@ -192,6 +192,7 @@ static const char *led_names[] =
/**------------------------------------------------------------------*\
@name Das Keyboard
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:

5
Controllers/DebugController/RGBController_Debug.cpp
View file

@ -5,6 +5,7 @@
/**------------------------------------------------------------------*\
@name Debug
@category Unknown
@type I2C
@save :x:
@direct :x:
@ -43,7 +44,7 @@ void RGBController_Debug::ResizeZone(int index, int new_size)
// Add the new ammount of LEDs to the old ammount
size_t new_leds_size = leds.size() - old_size + new_size;
leds.resize(std::max(old_leds_size, new_leds_size));
memmove(&leds[zones[index].start_idx] + old_leds_size, &leds[zones[index].start_idx] + new_leds_size, (old_leds_size - zones[index].start_idx - old_size) * sizeof(led));
@ -54,6 +55,6 @@ void RGBController_Debug::ResizeZone(int index, int new_size)
{
leds[zones[index].start_idx + i].name = "Linear LED " + std::to_string(i);
}
SetupColors();
}

7
Controllers/DuckyKeyboardController/RGBController_DuckyKeyboard.cpp
View file

@ -188,9 +188,10 @@ static const char *led_names[] =
/**------------------------------------------------------------------*\
@name Ducky Keyboard
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark
@direct :white_check_mark:
@effects :x:
@detectors DetectDuckyKeyboardControllers
@comment
@ -291,11 +292,11 @@ void RGBController_DuckyKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_DuckyKeyboard::DeviceUpdateLEDs()
{
unsigned char colordata[155*3];
for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
{
colordata[(color_idx*3)+0] = RGBGetRValue(colors[color_idx]);

71
Controllers/DygmaRaiseController/RGBController_DygmaRaise.cpp
View file

@ -17,8 +17,8 @@ static unsigned int kb_matrix_map_ISO[6][14] =
{ { 0, 1, 2, 3, 4, 5, 6, 39, 38, 37, 36, 35, 34, 33 },
{ 7, 8, 9, 10, 11, 12, 47, 46, 45, 44, 43, 42, 41, 40 },
{ 13, 14, 15, 16, 17, 18, 54, 53, 52, 51, 50, 49, 48, NA },
{ 19, 20, 21, 22, 23, 24, 25, 60, 59, 58, 57, 56, 55, NA },
{ 26, 27, 28, NA, 29, 30, NA, 66, 65, NA, 64, 63, 62, 61 },
{ 19, 20, 21, 22, 23, 24, 25, 60, 59, 58, 57, 56, 55, NA },
{ 26, 27, 28, NA, 29, 30, NA, 66, 65, NA, 64, 63, 62, 61 },
{ NA, NA, NA, NA, 31, 32, NA, 68, 67, NA, NA, NA, NA, NA } };
static unsigned int underglow_matrix[11][14] =
@ -77,20 +77,20 @@ static const char* led_names[] =
KEY_EN_D,
KEY_EN_F,
KEY_EN_G,
KEY_EN_LEFT_SHIFT,
KEY_EN_ISO_BACK_SLASH,
KEY_EN_LEFT_SHIFT,
KEY_EN_ISO_BACK_SLASH,
KEY_EN_Z,
KEY_EN_X,
KEY_EN_C,
KEY_EN_V,
KEY_EN_B,
KEY_EN_LEFT_CONTROL,
KEY_EN_LEFT_WINDOWS,
KEY_EN_LEFT_CONTROL,
KEY_EN_LEFT_WINDOWS,
KEY_EN_LEFT_ALT,
"Key: T1",
"Key: T2",
"Key: T3",
"Key: T4",
"Key: T1",
"Key: T2",
"Key: T3",
"Key: T4",
KEY_EN_BACKSPACE,
KEY_EN_EQUALS,
KEY_EN_MINUS,
@ -98,9 +98,9 @@ static const char* led_names[] =
KEY_EN_9,
KEY_EN_8,
KEY_EN_7,
KEY_EN_ANSI_ENTER,
KEY_EN_RIGHT_BRACKET,
KEY_EN_LEFT_BRACKET,
KEY_EN_ANSI_ENTER,
KEY_EN_RIGHT_BRACKET,
KEY_EN_LEFT_BRACKET,
KEY_EN_P,
KEY_EN_O,
KEY_EN_I,
@ -113,24 +113,25 @@ static const char* led_names[] =
KEY_EN_K,
KEY_EN_J,
KEY_EN_H,
KEY_EN_RIGHT_SHIFT,
KEY_EN_FORWARD_SLASH,
KEY_EN_RIGHT_SHIFT,
KEY_EN_FORWARD_SLASH,
KEY_EN_PERIOD,
KEY_EN_COMMA,
KEY_EN_M,
KEY_EN_N,
KEY_EN_RIGHT_CONTROL,
KEY_EN_RIGHT_WINDOWS,
KEY_EN_RIGHT_FUNCTION,
KEY_EN_RIGHT_ALT,
"Key: T6",
"Key: T5",
"Key: T8",
"Key: T7",
KEY_EN_RIGHT_CONTROL,
KEY_EN_RIGHT_WINDOWS,
KEY_EN_RIGHT_FUNCTION,
KEY_EN_RIGHT_ALT,
"Key: T6",
"Key: T5",
"Key: T8",
"Key: T7",
};
/**------------------------------------------------------------------*\
@name Dygma Raise Keyboard
@category Keyboard
@type Serial
@save :x:
@direct :white_check_mark:
@ -139,7 +140,7 @@ static const char* led_names[] =
@comment
\*-------------------------------------------------------------------*/
RGBController_DygmaRaise::RGBController_DygmaRaise(DygmaRaiseController* controller_ptr)
RGBController_DygmaRaise::RGBController_DygmaRaise(DygmaRaiseController* controller_ptr)
{
controller = controller_ptr;
@ -159,12 +160,12 @@ RGBController_DygmaRaise::RGBController_DygmaRaise(DygmaRaiseController* control
SetupZones();
}
RGBController_DygmaRaise::~RGBController_DygmaRaise()
RGBController_DygmaRaise::~RGBController_DygmaRaise()
{
delete controller;
}
void RGBController_DygmaRaise::SetupZones()
void RGBController_DygmaRaise::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zones |
@ -192,10 +193,10 @@ void RGBController_DygmaRaise::SetupZones()
new_zone.matrix_map->width = 14;
new_zone.matrix_map->map = (unsigned int *)&underglow_matrix;
}
zones.push_back(new_zone);
}
/*---------------------------------------------------------*\
| Set up keyboard LEDs |
\*---------------------------------------------------------*/
@ -226,7 +227,7 @@ void RGBController_DygmaRaise::SetupZones()
SetupColors();
}
void RGBController_DygmaRaise::ResizeZone(int /*zone*/, int /*new_size*/)
void RGBController_DygmaRaise::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
@ -234,27 +235,27 @@ void RGBController_DygmaRaise::ResizeZone(int /*zone*/, int /*new_size*/)
}
void RGBController_DygmaRaise::DeviceUpdateLEDs()
void RGBController_DygmaRaise::DeviceUpdateLEDs()
{
controller->SendDirect(colors,leds.size());
}
void RGBController_DygmaRaise::UpdateZoneLEDs(int /*zone*/)
void RGBController_DygmaRaise::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_DygmaRaise::UpdateSingleLED(int /*led*/)
void RGBController_DygmaRaise::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_DygmaRaise::SetCustomMode()
void RGBController_DygmaRaise::SetCustomMode()
{
active_mode = 0;
}
void RGBController_DygmaRaise::DeviceUpdateMode()
void RGBController_DygmaRaise::DeviceUpdateMode()
{
}

13
Controllers/E131Controller/RGBController_E131.cpp
View file

@ -15,6 +15,7 @@ using namespace std::chrono_literals;
/**------------------------------------------------------------------*\
@name E1.31 Devices
@category LEDStrip
@type E1.31
@save :x:
@direct :white_check_mark:
@ -114,7 +115,7 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
for(unsigned int univ_list_idx = 0; univ_list_idx < universe_list.size(); univ_list_idx++)
{
location += std::to_string(universe_list[univ_list_idx]);
if(univ_list_idx < (universe_list.size() - 1))
{
location += ", ";
@ -135,7 +136,7 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
| Create E1.31 socket |
\*-----------------------------------------*/
sockfd = e131_socket();
keepalive_delay = 0ms;
SetupZones();
@ -291,7 +292,7 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
}
zones[device_idx].matrix_map = new_map;
}
}
}
if(keepalive_delay.count() > 0)
{
@ -380,7 +381,7 @@ void RGBController_E131::DeviceUpdateLEDs()
int color_idx = 0;
last_update_time = std::chrono::steady_clock::now();
for(std::size_t device_idx = 0; device_idx < devices.size(); device_idx++)
{
float universe_size = devices[device_idx].universe_size;
@ -441,12 +442,12 @@ void RGBController_E131::DeviceUpdateLEDs()
void RGBController_E131::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
DeviceUpdateLEDs();
}
void RGBController_E131::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
DeviceUpdateLEDs();
}
void RGBController_E131::SetCustomMode()

1
Controllers/EKController/RGBController_EKController.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name EK Loop Connect
@category LEDStrip
@type USB
@save :warning:
@direct :x:

5
Controllers/ENESMBusController/RGBController_ENESMBus.cpp
View file

@ -10,6 +10,7 @@
/**------------------------------------------------------------------*\
@name ENE SMBus Device
@category RAM,Motherboard,GPU,Storage
@type SMBus
@save :white_check_mark:
@direct :white_check_mark:
@ -64,7 +65,7 @@ RGBController_ENESMBus::RGBController_ENESMBus(ENESMBusController * controller_p
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = ENE_MODE_BREATHING;
@ -361,7 +362,7 @@ void RGBController_ENESMBus::SetupZones()
}
new_zone->matrix_map = NULL;
/*---------------------------------------------------------*\
| Push new zone to zones vector |
\*---------------------------------------------------------*/

7
Controllers/EVGAAmpereGPUController/RGBController_EVGAGPUv3.cpp
View file

@ -20,6 +20,7 @@ static const char* evga_v3_zone_names[] =
/**------------------------------------------------------------------*\
@name EVGA RGB v3 GPU
@category GPU
@type I2C
@save :white_check_mark:
@direct :white_check_mark:
@ -167,7 +168,7 @@ RGBController_EVGAGPUv3::RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr)
for( uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
{
active_mode = evga->GetZoneMode(0); // Hard coding zone 0 until per zone modes are available.
if(active_mode != EVGA_GPU_V3_MODE_OFF)
{
EVGAv3_config hw_config = evga->GetZoneConfig(zoneIndexMap[zone_idx], active_mode);
@ -266,7 +267,7 @@ void RGBController_EVGAGPUv3::DeviceUpdateLEDs()
| modes and as such colorB will always be black (0x000000) |
\*---------------------------------------------------------*/
EVGAv3_config zone_config;
zone_config.brightness = modes[active_mode].brightness;
zone_config.speed = modes[active_mode].speed;
zone_config.direction = modes[active_mode].direction;
@ -311,7 +312,7 @@ void RGBController_EVGAGPUv3::DeviceUpdateMode()
for(uint8_t zone = 0; zone < 4; zone++)
{
evga->SetZoneMode(zone, modes[active_mode].value);
}
}
*/
//LOG_TRACE("[%s] Updating to mode %1d", evga->evgaGPUName, modes[active_mode].value);
DeviceUpdateLEDs();

1
Controllers/EVGAGP102GPUController/RGBController_EVGAGP102.cpp
View file

@ -12,6 +12,7 @@
/**------------------------------------------------------------------*\
@name EVGA GP102 GPU
@category GPU
@type I2C
@save :x:
@direct :white_check_mark:

1
Controllers/EVGAPascalGPUController/RGBController_EVGAGPUv1.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name EVGA RGB v1 GPU
@category GPU
@type I2C
@save :white_check_mark:
@direct :white_check_mark:

3
Controllers/EVGATuringGPUController/RGBController_EVGAGPUv2.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name EVGA RGB v2 GPU
@category GPU
@type I2C
@save :white_check_mark:
@direct :white_check_mark:
@ -218,7 +219,7 @@ void RGBController_EVGAGPUv2::DeviceUpdateMode()
colorA = modes[active_mode].colors[0];
colorB = (modes[active_mode].colors.size() == 2) ? modes[active_mode].colors[1] : 0 ;
}
evga->SetMode( modes[active_mode].value, colorA, colorB, modes[active_mode].speed, modes[active_mode].brightness);
}

1
Controllers/EVGAUSBController/RGBController_EVGAKeyboard.cpp
View file

@ -184,6 +184,7 @@ static const char *led_names[] =
/**------------------------------------------------------------------*\
@name EVGA USB Keyboard
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:

5
Controllers/EVisionKeyboardController/RGBController_EVisionKeyboard.cpp
View file

@ -22,6 +22,7 @@ static unsigned int matrix_map[6][23] =
/**------------------------------------------------------------------*\
@name EVision Keyboard
@category Keyboard
@type USB
@save :warning:
@direct :x:
@ -175,7 +176,7 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
Blooming.speed = EVISION_KB_SPEED_NORMAL;
Blooming.color_mode = MODE_COLORS_NONE;
modes.push_back(Blooming);
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = EVISION_KB_MODE_REACTIVE;
@ -247,7 +248,7 @@ void RGBController_EVisionKeyboard::SetupZones()
new_zone.matrix_map->height = 6;
new_zone.matrix_map->width = 23;
new_zone.matrix_map->map = (unsigned int *)&matrix_map;
zones.push_back(new_zone);
for(int led_idx = 0; led_idx < 126; led_idx++)

1
Controllers/EspurnaController/RGBController_Espurna.cpp
View file

@ -10,6 +10,7 @@
/**------------------------------------------------------------------*\
@name Espurna
@category Light
@type TCP
@save :x:
@direct :white_check_mark:

1
Controllers/FanBusController/RGBController_FanBus.cpp
View file

@ -10,6 +10,7 @@
/**------------------------------------------------------------------*\
@name FanBus
@category Cooler
@type Serial
@save :x:
@direct :white_check_mark:

1
Controllers/FaustusController/RGBController_Faustus.cpp
View file

@ -5,6 +5,7 @@
/**------------------------------------------------------------------*\
@name ASUS TUF Keyboard (Faustus)
@category Keyboard
@type File Stream
@save :x:
@direct :x:

1
Controllers/GainwardGPUController/RGBController_GainwardGPUv1.cpp
View file

@ -16,6 +16,7 @@ int RGBController_GainwardGPUv1::GetDeviceMode()
/**------------------------------------------------------------------*\
@name Gainward GPU v1
@category GPU
@type I2C
@save :x:
@direct :white_check_mark:

3
Controllers/GainwardGPUController/RGBController_GainwardGPUv2.cpp
View file

@ -10,6 +10,7 @@
/**------------------------------------------------------------------*\
@name Gainward GPU v2
@category GPU
@type I2C
@save :x:
@direct :x:
@ -181,7 +182,7 @@ void RGBController_GainwardGPUv2::DeviceUpdateMode()
unsigned char b = RGBGetBValue(current_mode.colors[0]);
controller->SetLEDColors(r, g, b, GAINWARD_V2_COLOR_REGISTER_TERTIARY);
}
case 2:
controller->SetMode((unsigned char)(current_mode.value), (unsigned char)(current_mode.speed));
controller->SetDirection(current_mode.direction);

1
Controllers/GalaxGPUController/RGBController_GalaxGPU.cpp
View file

@ -42,6 +42,7 @@ int RGBController_GalaxGPU::GetDeviceMode()
/**------------------------------------------------------------------*\
@name Galax GPU
@category GPU
@type I2C
@save :x:
@direct :white_check_mark:

1
Controllers/GigabyteAorusCPUCoolerController/RGBController_AorusATC800.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Aorus ATC800
@category Cooler
@type USB
@save :x:
@direct :x:

1
Controllers/GigabyteRGBFusion2DRAMController/RGBController_GigabyteRGBFusion2DRAM.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Gigabyte Fusion2 DRAM
@category RAM
@type I2C
@save :x:
@direct :x:

3
Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.cpp
View file

@ -20,6 +20,7 @@ static const char* gigabyte_fusion2_gpu_zone[] =
/**------------------------------------------------------------------*\
@name Gigabyte Fusion 2 GPU
@category GPU
@type I2C
@save :white_check_mark:
@direct :white_check_mark:
@ -130,7 +131,7 @@ RGBController_RGBFusion2GPU::RGBController_RGBFusion2GPU(RGBFusion2GPUController
mode Shift;
Shift.name = "Color Shift";
Shift.value = RGB_FUSION2_GPU_MODE_COLOR_SHIFT;
Shift.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Shift.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Shift.speed_min = RGB_FUSION2_GPU_SPEED_SLOWEST;
Shift.speed_max = RGB_FUSION2_GPU_SPEED_FASTEST;
Shift.speed = RGB_FUSION2_GPU_SPEED_NORMAL;

1
Controllers/GigabyteRGBFusion2SMBusController/RGBController_GigabyteRGBFusion2SMBus.cpp
View file

@ -39,6 +39,7 @@ static const char* rgb_fusion_zone_names[] =
/**------------------------------------------------------------------*\
@name Gigabyte Fusion2 SMBus
@category Motherboard
@type I2C
@save :x:
@direct :white_check_mark:

9
Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.cpp
View file

@ -112,7 +112,7 @@ static KnownLayout knownLayoutsLookup
}
}
}
},
},
{
"STD_ATX",
{
@ -190,6 +190,7 @@ static KnownLayout knownLayoutsLookup
/**------------------------------------------------------------------*\
@name Gigabyte RGB Fusion 2 USB
@category Motherboard
@type USB
@save :x:
@direct :white_check_mark:
@ -555,7 +556,7 @@ void RGBController_RGBFusion2USB::UpdateZoneLEDs(int zone)
unsigned char red = 0;
unsigned char grn = 0;
unsigned char blu = 0;
for(std::size_t led_idx = 0; led_idx < zones[zone].leds_count; led_idx++)
{
/*---------------------------------------------------------*\
@ -590,7 +591,7 @@ void RGBController_RGBFusion2USB::UpdateZoneLEDs(int zone)
\*---------------------------------------------------------*/
controller->SetLEDEffect(zones[zone].leds[led_idx].value, mode_value, modes[active_mode].speed, modes[active_mode].brightness, random, red, grn, blu);
}
controller->ApplyEffect();
}
/*---------------------------------------------------------*\
@ -658,7 +659,7 @@ void RGBController_RGBFusion2USB::UpdateSingleLED(int led)
unsigned char red = 0;
unsigned char grn = 0;
unsigned char blu = 0;
/*---------------------------------------------------------*\
| Motherboard LEDs always use effect mode, so use static for|
| direct mode but get colors from zone |

1
Controllers/GigabyteRGBFusionController/RGBController_GigabyteRGBFusion.cpp
View file

@ -17,6 +17,7 @@ static const char* rgb_fusion_zone_names[] =
/**------------------------------------------------------------------*\
@name Gigabyte Fusion SMBus
@category Motherboard
@type I2C
@save :x:
@direct :white_check_mark:

1
Controllers/GigabyteRGBFusionGPUController/RGBController_GigabyteRGBFusionGPU.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Gigabyte Fusion GPU
@category GPU
@type I2C
@save :white_check_mark:
@direct :white_check_mark:

3
Controllers/HPOmen30LController/RGBController_HPOmen30L.cpp
View file

@ -8,6 +8,7 @@
/**------------------------------------------------------------------*\
@name HP Omen 30L
@category Motherboard
@type USB
@save :x:
@direct :white_check_mark:
@ -208,6 +209,6 @@ void RGBController_HPOmen30L::DeviceUpdateMode()
{
controller->SetZoneMode(i, modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness);
}
DeviceUpdateLEDs();
}

1
Controllers/HoltekController/RGBController_HoltekA070.cpp
View file

@ -10,6 +10,7 @@
/**------------------------------------------------------------------*\
@name Holtek A070
@category Mouse
@type USB
@save :x:
@direct :x:

1
Controllers/HoltekController/RGBController_HoltekA1FA.cpp
View file

@ -10,6 +10,7 @@
/**------------------------------------------------------------------*\
@name Holtek A1FA
@category Mouse
@type USB
@save :x:
@direct :x:

1
Controllers/HyperXDRAMController/RGBController_HyperXDRAM.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name HyperX DRAM
@category RAM
@type I2C
@save :x:
@direct :white_check_mark:

1
Controllers/HyperXKeyboardController/RGBController_HyperXAlloyElite.cpp
View file

@ -178,6 +178,7 @@ static const char *led_names[] =
/**------------------------------------------------------------------*\
@name HyperX Alloy Elite
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:

1
Controllers/HyperXKeyboardController/RGBController_HyperXAlloyElite2.cpp
View file

@ -195,6 +195,7 @@ static const char *led_names[] =
/**------------------------------------------------------------------*\
@name HyperX Alloy Elite 2
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:

1
Controllers/HyperXKeyboardController/RGBController_HyperXAlloyFPS.cpp
View file

@ -150,6 +150,7 @@ static const char *led_names[] =
/**------------------------------------------------------------------*\
@name HyperX Alloy FPS
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:

3
Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOrigins.cpp
View file

@ -170,6 +170,7 @@ static const char *led_names[] =
/**------------------------------------------------------------------*\
@name HyperX Alloy Origins
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:
@ -276,7 +277,7 @@ void RGBController_HyperXAlloyOrigins::ResizeZone(int /*zone*/, int /*new_size*/
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_HyperXAlloyOrigins::DeviceUpdateLEDs()
{
controller->SetLEDsDirect(colors);

15
Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOriginsCore.cpp
View file

@ -17,12 +17,12 @@ using namespace std::chrono_literals;
static unsigned int matrix_map[6][19] =
{
{ 0, NA, 1, 2, 3, 4, 5, 6, 7, 44, NA, 45, 46, 47, 48, NA, 49, 50, 51 },
{ 8, 9, 10, 11, 12, 13, 14, 15, 16, 52, 53, 54, 55, 56, NA, NA, 57, 58, 59 },
{ 17, NA, 18, 19, 20, 21, 22, 23, 24, 60, 61, 62, 63, 64, 65, NA, 66, 67, 68 },
{ 25, NA, 26, 27, 28, 29, 30, 31, 32, 69, 70, 71, 72, 73, NA, NA, NA, NA, NA },
{ 33, NA, 34, 35, 36, 37, 38, NA, 39, 74, 75, 76, 77, 78, NA, NA, NA, 79, NA },
{ 40, 41, 42, NA, NA, NA, 43, NA, NA, NA, NA, 80, 81, 82, 83, NA, 84, 85, 86 }
{ 0, NA, 1, 2, 3, 4, 5, 6, 7, 44, NA, 45, 46, 47, 48, NA, 49, 50, 51 },
{ 8, 9, 10, 11, 12, 13, 14, 15, 16, 52, 53, 54, 55, 56, NA, NA, 57, 58, 59 },
{ 17, NA, 18, 19, 20, 21, 22, 23, 24, 60, 61, 62, 63, 64, 65, NA, 66, 67, 68 },
{ 25, NA, 26, 27, 28, 29, 30, 31, 32, 69, 70, 71, 72, 73, NA, NA, NA, NA, NA },
{ 33, NA, 34, 35, 36, 37, 38, NA, 39, 74, 75, 76, 77, 78, NA, NA, NA, 79, NA },
{ 40, 41, 42, NA, NA, NA, 43, NA, NA, NA, NA, 80, 81, 82, 83, NA, 84, 85, 86 }
};
static const char* zone_names[] =
@ -92,7 +92,7 @@ static const char *led_names[] =
KEY_EN_LEFT_ALT,
KEY_EN_SPACE,
// End of first section
// End of first section
KEY_EN_F8,
KEY_EN_F9,
@ -148,6 +148,7 @@ static const char *led_names[] =
/**------------------------------------------------------------------*\
@name HyperX Alloy Origins Core
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:

1
Controllers/HyperXMouseController/RGBController_HyperXPulsefireDart.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name HyoerX Pulsefire Dart
@category Mouse
@type USB
@save :white_check_mark:
@direct :white_check_mark:

5
Controllers/HyperXMouseController/RGBController_HyperXPulsefireFPSPro.cpp
View file

@ -13,6 +13,7 @@ using namespace std::chrono_literals;
/**------------------------------------------------------------------*\
@name HyperX Pulsefire FPS
@category Mouse
@type USB
@save :x:
@direct :white_check_mark:
@ -76,14 +77,14 @@ void RGBController_HyperXPulsefireFPSPro::SetupZones()
for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
{
led new_led;
new_led.name = zones[zone_idx].name;
if(zones[zone_idx].leds_count > 1)
{
new_led.name.append(" LED ");
new_led.name.append(std::to_string(led_idx + 1));
}
}
leds.push_back(new_led);
}

5
Controllers/HyperXMouseController/RGBController_HyperXPulsefireHaste.cpp
View file

@ -13,6 +13,7 @@ using namespace std::chrono_literals;
/**------------------------------------------------------------------*\
@name HyperX Pulsefire Haste
@category Mouse
@type USB
@save :x:
@direct :white_check_mark:
@ -76,14 +77,14 @@ void RGBController_HyperXPulsefireHaste::SetupZones()
for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
{
led new_led;
new_led.name = zones[zone_idx].name;
if(zones[zone_idx].leds_count > 1)
{
new_led.name.append(" LED ");
new_led.name.append(std::to_string(led_idx + 1));
}
}
leds.push_back(new_led);
}

5
Controllers/HyperXMouseController/RGBController_HyperXPulsefireSurge.cpp
View file

@ -13,6 +13,7 @@ using namespace std::chrono_literals;
/**------------------------------------------------------------------*\
@name HyperX Pulsefire Surge
@category Mouse
@type USB
@save :x:
@direct :white_check_mark:
@ -85,14 +86,14 @@ void RGBController_HyperXPulsefireSurge::SetupZones()
for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
{
led new_led;
new_led.name = zones[zone_idx].name;
if(zones[zone_idx].leds_count > 1)
{
new_led.name.append(" LED ");
new_led.name.append(std::to_string(led_idx + 1));
}
}
leds.push_back(new_led);
}

5
Controllers/HyperXMousematController/RGBController_HyperXMousemat.cpp
View file

@ -13,6 +13,7 @@ using namespace std::chrono_literals;
/**------------------------------------------------------------------*\
@name HyperX Mousemat
@category Mousemat
@type USB
@save :x:
@direct :white_check_mark:
@ -85,14 +86,14 @@ void RGBController_HyperXMousemat::SetupZones()
for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
{
led new_led;
new_led.name = zones[zone_idx].name;
if(zones[zone_idx].leds_count > 1)
{
new_led.name.append(" LED ");
new_led.name.append(std::to_string(led_idx + 1));
}
}
leds.push_back(new_led);
}

1
Controllers/KeychronKeyboardController/RGBController_KeychronKeyboard.cpp
View file

@ -416,6 +416,7 @@ typedef struct
/**------------------------------------------------------------------*\
@name Keychron Keyboard
@category Keyboard
@type USB
@save :x:
@direct :x:

1
Controllers/LEDStripController/RGBController_LEDStrip.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Serial LED Strip
@category LEDStrip
@type Serial
@save :x:
@direct :white_check_mark:

1
Controllers/LIFXController/RGBController_LIFX.cpp
View file

@ -10,6 +10,7 @@
/**------------------------------------------------------------------*\
@name LIFX Globes
@category Light
@type USB
@save :x:
@direct :white_check_mark:

1
Controllers/LexipMouseController/RGBController_LexipMouse.cpp
View file

@ -14,6 +14,7 @@
/**------------------------------------------------------------------*\
@name Lexip Mouse
@category Mouse
@type USB
@save :x:
@direct :white_check_mark:

1
Controllers/LianLiController/RGBController_LianLiUniHub.cpp
View file

@ -30,6 +30,7 @@ mode makeMode()
/**------------------------------------------------------------------*\
@name Lian Li Uni Hub
@category Cooler
@type USB
@save :x:
@direct :warning:

1
Controllers/LinuxLEDController/RGBController_LinuxLED.cpp
View file

@ -10,6 +10,7 @@
/**------------------------------------------------------------------*\
@name Dummy
@category LEDStrip
@type File Stream
@save :x:
@direct :white_check_mark:

3
Controllers/LogitechController/RGBController_LogitechG203L.cpp
View file

@ -2,6 +2,7 @@
/**------------------------------------------------------------------*\
@name Logitech G203L
@category Mouse
@type USB
@save :warning:
@direct :white_check_mark:
@ -165,7 +166,7 @@ void RGBController_LogitechG203L::DeviceUpdateMode()
blu = RGBGetBValue(modes[active_mode].colors[0]);
}
if(modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR)
if(modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR)
{
dir = (unsigned char)modes[active_mode].direction;
}

1
Controllers/LogitechController/RGBController_LogitechG213.cpp
View file

@ -30,6 +30,7 @@ static const unsigned char led_values[] =
/**------------------------------------------------------------------*\
@name Logitech G213
@category Keyboard
@type USB
@save :warning:
@direct :white_check_mark:

1
Controllers/LogitechController/RGBController_LogitechG560.cpp
View file

@ -13,6 +13,7 @@
/**------------------------------------------------------------------*\
@name Logitech G560
@category Speaker
@type USB
@save :x:
@direct :white_check_mark:

5
Controllers/LogitechController/RGBController_LogitechG810.cpp
View file

@ -168,6 +168,7 @@ static const led_type led_names[] =
/**------------------------------------------------------------------*\
@name Logitech G810
@category Keyboard
@type USB
@save :warning:
@direct :white_check_mark:
@ -202,7 +203,7 @@ RGBController_LogitechG810::RGBController_LogitechG810(LogitechG810Controller* c
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
modes.push_back(Static);
mode Off;
Off.name = "Off";
Off.value = LOGITECH_G810_MODE_OFF;
@ -330,7 +331,7 @@ void RGBController_LogitechG810::DeviceUpdateLEDs()
frame_buf[(frame_cnt * 4) + 1] = RGBGetRValue(colors[led_idx]);
frame_buf[(frame_cnt * 4) + 2] = RGBGetGValue(colors[led_idx]);
frame_buf[(frame_cnt * 4) + 3] = RGBGetBValue(colors[led_idx]);
frame_cnt++;
prev_zone = zone;

1
Controllers/LogitechController/RGBController_LogitechG815.cpp
View file

@ -172,6 +172,7 @@ static const led_type led_names[] =
/**------------------------------------------------------------------*\
@name Logitech G815
@category Keyboard
@type USB
@save :warning:
@direct :white_check_mark:

5
Controllers/LogitechController/RGBController_LogitechG910.cpp
View file

@ -169,6 +169,7 @@ static const led_type led_names[] =
/**------------------------------------------------------------------*\
@name Logitech G910
@category Keyboard
@type USB
@save :warning:
@direct :white_check_mark:
@ -203,7 +204,7 @@ RGBController_LogitechG910::RGBController_LogitechG910(LogitechG910Controller* c
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
modes.push_back(Static);
mode Off;
Off.name = "Off";
Off.value = LOGITECH_G910_MODE_OFF;
@ -331,7 +332,7 @@ void RGBController_LogitechG910::DeviceUpdateLEDs()
frame_buf[(frame_cnt * 4) + 1] = RGBGetRValue(colors[led_idx]);
frame_buf[(frame_cnt * 4) + 2] = RGBGetGValue(colors[led_idx]);
frame_buf[(frame_cnt * 4) + 3] = RGBGetBValue(colors[led_idx]);
frame_cnt++;
prev_zone = zone;

1
Controllers/LogitechController/RGBController_LogitechG915.cpp
View file

@ -184,6 +184,7 @@ static const led_type led_names[] =
/**------------------------------------------------------------------*\
@name Logitech G915
@category Keyboard
@type USB
@save :warning:
@direct :white_check_mark:

5
Controllers/LogitechController/RGBController_LogitechG933.cpp
View file

@ -12,8 +12,9 @@
#include "RGBController_LogitechG933.h"
/**------------------------------------------------------------------*\
@name Dummy
@type I2C or Serial or WMI or USB
@name Logitech G933
@category Headset
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:

1
Controllers/LogitechController/RGBController_LogitechGLightsync.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Logitech Lightsync Mouse
@category Mouse
@type USB
@save :warning:
@direct :white_check_mark:

1
Controllers/LogitechController/RGBController_LogitechGLightsync1zone.cpp
View file

@ -11,6 +11,7 @@
/**------------------------------------------------------------------*\
@name Logitech Lightsync Mouse (1 Zone)
@category Mouse
@type USB
@save :warning:
@direct :white_check_mark:

Some files were not shown because too many files have changed in this diff Show more