mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-01-19 12:37:52 -05:00
Code Issues Packages Projects Releases Wiki Activity
Files
next_hotplug
OpenRGB/Controllers/GigabyteAorusLaptopController/RGBController_GigabyteAorusLaptop.cpp
Adam Honse a3b023d86c RGBController API Overhaul 
* Reorganize and clean up RGBController API functions
    * Add functions to get protected RGBController member values
    * Make NetworkClient, ProfileManager, and ResourceManager friend classes so they can access protected members
    * Protected previously-public RGBController members
        * Information strings (name, vendor, description, version, serial location)
        * Device type
        * Active mode
        * Flags
        * LEDs vector
        * LED alternate names vector
        * Modes vector
        * Colors vector
        * Zones vector
    * Add CONTROLLER_FLAG_HIDDEN to allow plugins to hide controllers from control GUI
    * Add update reason codes to RGBController update callback and signal updates on more RGBController events
    * Add loop zone types and segmented zone type
    * Add matrix map field to segments
    * Rework matrix_map_type from using pointers to vector to prevent memory leaks
    * Rework KeyboardLayoutManager to return new matrix_map_type
    * Add access mutex to RGBController API
    * Add per-zone modes ot RGBController API
    * Add JSON description functions to RGBController API
2026-01-11 13:10:40 -06:00

490 lines
27 KiB
C++
Raw Permalink Blame History

/*---------------------------------------------------------*\
| RGBController_GigabyteAorusLaptop.cpp |
| |
| RGBController for Gigabyte Aorus laptop |
| |
| Morgan Guimard (morg) 05 Jun 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_GigabyteAorusLaptop.h"
#include "RGBControllerKeyNames.h"
/**------------------------------------------------------------------*\
@name Aorus Laptop
@category
@type USB
@save :robot:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectGigabyteAorusLaptopKeyboardControllers,DetectGigabyteAorusLaptopBacklightControllers
@comment Direct mode will only exposes the whole keyboard as one
big led, only custom mode can do real per key lightning.
This is impossible to determine if it auto saves to flash
(the battery cannot be removed) then we assume it does.
This device has 5 onboard memory profiles, we only use
the first one.
\*-------------------------------------------------------------------*/
#define NA 0xFFFFFFFF
typedef struct
{
const unsigned int width; /* matrix width */
const unsigned int height; /* matrix height */
std::vector<std::vector<unsigned int>> matrix_map; /* matrix map */
std::vector<std::string> led_names; /* led names */
std::vector<unsigned int> led_sequence_positions; /* position in buffers */
} aorus_laptop_keyboard_layout;
static aorus_laptop_keyboard_layout aorus_laptop_default_keyboard_layout =
{
19,
6,
{
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}, // 19
{ 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, NA, 32, 33, 34, 35, 36}, // 18
{ 37, NA, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54}, // 18
{ 55, NA, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, NA, 67, 68, 69, 70, NA}, // 16
{ 71, NA, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, NA, 82, 83, 84, 85, 86, 87}, // 17
{ 88, 89, 90, 91, NA, NA, NA, 92, NA, NA, 93, 94, 95, 96, 97, 98, 99, 100, NA} // 13
},
{
KEY_EN_ESCAPE, KEY_EN_F1, KEY_EN_F2, KEY_EN_F3, KEY_EN_F4, KEY_EN_F5, KEY_EN_F6, KEY_EN_F7, KEY_EN_F8, KEY_EN_F9, KEY_EN_F10, KEY_EN_F11, KEY_EN_F12, KEY_EN_PAUSE_BREAK, KEY_EN_DELETE, KEY_EN_HOME, KEY_EN_PAGE_UP, KEY_EN_PAGE_DOWN, KEY_EN_END,
KEY_EN_BACK_TICK, KEY_EN_1, KEY_EN_2, KEY_EN_3, KEY_EN_4, KEY_EN_5, KEY_EN_6, KEY_EN_7, KEY_EN_8, KEY_EN_9, KEY_EN_0, KEY_EN_MINUS, KEY_EN_EQUALS, KEY_EN_BACKSPACE, KEY_EN_NUMPAD_LOCK, KEY_EN_NUMPAD_DIVIDE, KEY_EN_NUMPAD_TIMES, KEY_EN_NUMPAD_MINUS,
KEY_EN_TAB, KEY_EN_Q, KEY_EN_W, KEY_EN_E, KEY_EN_R, KEY_EN_T, KEY_EN_Y, KEY_EN_U, KEY_EN_I, KEY_EN_O, KEY_EN_P, KEY_EN_LEFT_BRACKET, KEY_EN_RIGHT_BRACKET, KEY_EN_BACK_SLASH, KEY_EN_NUMPAD_7, KEY_EN_NUMPAD_8, KEY_EN_NUMPAD_9, KEY_EN_NUMPAD_PLUS,
KEY_EN_CAPS_LOCK, KEY_EN_A, KEY_EN_S, KEY_EN_D, KEY_EN_F, KEY_EN_G, KEY_EN_H, KEY_EN_J, KEY_EN_K, KEY_EN_L, KEY_EN_SEMICOLON, KEY_EN_QUOTE, KEY_EN_ISO_ENTER, KEY_EN_NUMPAD_4, KEY_EN_NUMPAD_5, KEY_EN_NUMPAD_6,
KEY_EN_LEFT_SHIFT, KEY_EN_Z, KEY_EN_X, KEY_EN_C, KEY_EN_V, KEY_EN_B, KEY_EN_N, KEY_EN_M, KEY_EN_COMMA, KEY_EN_PERIOD, KEY_EN_FORWARD_SLASH, KEY_EN_RIGHT_SHIFT, KEY_EN_UP_ARROW, KEY_EN_NUMPAD_1, KEY_EN_NUMPAD_2, KEY_EN_NUMPAD_3, KEY_EN_NUMPAD_ENTER,
KEY_EN_LEFT_CONTROL, KEY_EN_LEFT_FUNCTION, KEY_EN_LEFT_WINDOWS, KEY_EN_LEFT_ALT, KEY_EN_SPACE, KEY_EN_RIGHT_ALT, KEY_EN_MENU, KEY_EN_RIGHT_CONTROL, KEY_EN_LEFT_ARROW, KEY_EN_DOWN_ARROW, KEY_EN_RIGHT_ARROW, KEY_EN_NUMPAD_0, KEY_EN_NUMPAD_PERIOD
},
{
11, 17, 23, 29, 35, 41, 47, 53, 59, 65, 71, 77, 83, 89, 95, 101, 107, 113, 119,
10, 16, 22, 28, 34, 40, 46, 52, 58, 64, 70, 76, 82, 94, 100, 106, 112, 118,
9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 99, 105, 111, 116,
8, 14, 20, 26, 32, 38, 44, 50, 56, 62, 68, 74, 92, 98, 104, 110,
7, 19, 25, 31, 37, 43, 49, 55, 61, 67, 73, 85, 91, 97, 103, 109, 114,
6, 12, 18, 24, 42, 60, 66, 72, 84, 90, 96, 102, 108
}
};
RGBController_GigabyteAorusLaptop::RGBController_GigabyteAorusLaptop(GigabyteAorusLaptopController* controller_ptr, GIGABYTE_AORUS_LAPTOP_DEV_TYPE dev_type)
{
this->dev_type = dev_type;
controller = controller_ptr;
name = controller->GetNameString();
vendor = "Gigabyte";
type = DEVICE_TYPE_LAPTOP;
description = "Aorus Laptop";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
/*---------------------------------------------------------*\
| Only keyboard supports Direct mode |
\*---------------------------------------------------------*/
if(dev_type == GIGABYTE_AORUS_LAPTOP_KEYBOARD_TYPE)
{
mode Direct;
Direct.name = "Direct";
Direct.value = GIGABYTE_AORUS_LAPTOP_DIRECT_MODE_VALUE;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Direct.color_mode = MODE_COLORS_PER_LED;
Direct.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Direct.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Direct.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
modes.push_back(Direct);
}
/*---------------------------------------------------------*\
| Common modes to keyboard + backlight |
\*---------------------------------------------------------*/
mode Static;
Static.name = "Static";
Static.value = GIGABYTE_AORUS_LAPTOP_STATIC_MODE_VALUE;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
Static.colors_min = 1;
Static.colors_max = 1;
Static.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Static.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Static.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
modes.push_back(Static);
mode Pulse;
Pulse.name = "Breathing";
Pulse.value = GIGABYTE_AORUS_LAPTOP_PULSE_MODE_VALUE;
Pulse.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Pulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
Pulse.colors.resize(1);
Pulse.colors_min = 1;
Pulse.colors_max = 1;
Pulse.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Pulse.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Pulse.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
Pulse.speed_min = GIGABYTE_AORUS_LAPTOP_SPEED_MIN;
Pulse.speed_max = GIGABYTE_AORUS_LAPTOP_SPEED_MAX;
Pulse.speed = GIGABYTE_AORUS_LAPTOP_SPEED_MAX/2;
modes.push_back(Pulse);
mode Wave;
Wave.name = "Rainbow Wave";
Wave.value = GIGABYTE_AORUS_LAPTOP_WAVE_MODE_VALUE;
Wave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
Wave.colors.resize(1);
Wave.colors_min = 1;
Wave.colors_max = 1;
Wave.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Wave.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Wave.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
Wave.speed_min = GIGABYTE_AORUS_LAPTOP_SPEED_MIN;
Wave.speed_max = GIGABYTE_AORUS_LAPTOP_SPEED_MAX;
Wave.speed = GIGABYTE_AORUS_LAPTOP_SPEED_MAX/2;
Wave.direction = MODE_DIRECTION_LEFT;
modes.push_back(Wave);
mode Cycle;
Cycle.name = "Spectrum Cycle";
Cycle.value = GIGABYTE_AORUS_LAPTOP_CYCLE_MODE_VALUE;
Cycle.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Cycle.color_mode = MODE_COLORS_MODE_SPECIFIC;
Cycle.colors.resize(1);
Cycle.colors_min = 1;
Cycle.colors_max = 1;
Cycle.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Cycle.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Cycle.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
Cycle.speed_min = GIGABYTE_AORUS_LAPTOP_SPEED_MIN;
Cycle.speed_max = GIGABYTE_AORUS_LAPTOP_SPEED_MAX;
Cycle.speed = GIGABYTE_AORUS_LAPTOP_SPEED_MAX/2;
modes.push_back(Cycle);
mode Droplet;
Droplet.name = "Droplet";
Droplet.value = GIGABYTE_AORUS_LAPTOP_DROPLET_MODE_VALUE;
Droplet.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Droplet.color_mode = MODE_COLORS_MODE_SPECIFIC;
Droplet.colors.resize(1);
Droplet.colors_min = 1;
Droplet.colors_max = 1;
Droplet.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Droplet.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Droplet.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
Droplet.speed_min = GIGABYTE_AORUS_LAPTOP_SPEED_MIN;
Droplet.speed_max = GIGABYTE_AORUS_LAPTOP_SPEED_MAX;
Droplet.speed = GIGABYTE_AORUS_LAPTOP_SPEED_MAX/2;
modes.push_back(Droplet);
mode Spiral;
Spiral.name = "Spiral";
Spiral.value = GIGABYTE_AORUS_LAPTOP_SPIRAL_MODE_VALUE;
Spiral.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE;
Spiral.color_mode = MODE_COLORS_MODE_SPECIFIC;
Spiral.colors.resize(1);
Spiral.colors_min = 1;
Spiral.colors_max = 1;
Spiral.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Spiral.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Spiral.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
Spiral.speed_min = GIGABYTE_AORUS_LAPTOP_SPEED_MIN;
Spiral.speed_max = GIGABYTE_AORUS_LAPTOP_SPEED_MAX;
Spiral.speed = GIGABYTE_AORUS_LAPTOP_SPEED_MAX/2;
Spiral.direction = MODE_DIRECTION_LEFT;
modes.push_back(Spiral);
/*---------------------------------------------------------*\
| Modes for backlight only |
\*---------------------------------------------------------*/
if(dev_type == GIGABYTE_AORUS_LAPTOP_BACKLIGHT_TYPE)
{
mode Curtain;
Curtain.name = "Curtain";
Curtain.value = GIGABYTE_AORUS_LAPTOP_CURTAIN_MODE_VALUE;
Curtain.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Curtain.color_mode = MODE_COLORS_MODE_SPECIFIC;
Curtain.colors.resize(1);
Curtain.colors_min = 1;
Curtain.colors_max = 1;
Curtain.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Curtain.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Curtain.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
modes.push_back(Curtain);
mode Comet;
Comet.name = "Comet";
Comet.value = GIGABYTE_AORUS_LAPTOP_COMET_MODE_VALUE;
Comet.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Comet.color_mode = MODE_COLORS_MODE_SPECIFIC;
Comet.colors.resize(1);
Comet.colors_min = 1;
Comet.colors_max = 1;
Comet.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Comet.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Comet.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
modes.push_back(Comet);
mode Chase;
Chase.name = "Chase";
Chase.value = GIGABYTE_AORUS_LAPTOP_CHASE_MODE_VALUE;
Chase.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Chase.color_mode = MODE_COLORS_MODE_SPECIFIC;
Chase.colors.resize(1);
Chase.colors_min = 1;
Chase.colors_max = 1;
Chase.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Chase.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Chase.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
modes.push_back(Chase);
}
/*---------------------------------------------------------*\
| Modes for keyboard only |
\*---------------------------------------------------------*/
if(dev_type == GIGABYTE_AORUS_LAPTOP_KEYBOARD_TYPE)
{
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = GIGABYTE_AORUS_LAPTOP_REACTIVE_MODE_VALUE;
Reactive.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
Reactive.colors.resize(1);
Reactive.colors_min = 1;
Reactive.colors_max = 1;
Reactive.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Reactive.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Reactive.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
modes.push_back(Reactive);
mode Marquee;
Marquee.name = "Marquee";
Marquee.value = GIGABYTE_AORUS_LAPTOP_MARQUEE_MODE_VALUE;
Marquee.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
Marquee.colors.resize(1);
Marquee.colors_min = 1;
Marquee.colors_max = 1;
Marquee.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Marquee.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Marquee.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
Marquee.speed_min = GIGABYTE_AORUS_LAPTOP_SPEED_MIN;
Marquee.speed_max = GIGABYTE_AORUS_LAPTOP_SPEED_MAX;
Marquee.speed = GIGABYTE_AORUS_LAPTOP_SPEED_MAX/2;
modes.push_back(Marquee);
mode CircleMarquee;
CircleMarquee.name = "Circle Marquee";
CircleMarquee.value = GIGABYTE_AORUS_LAPTOP_CIRCLE_MARQUEE_MODE_VALUE;
CircleMarquee.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
CircleMarquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
CircleMarquee.colors.resize(1);
CircleMarquee.colors_min = 1;
CircleMarquee.colors_max = 1;
CircleMarquee.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
CircleMarquee.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
CircleMarquee.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
CircleMarquee.speed_min = GIGABYTE_AORUS_LAPTOP_SPEED_MIN;
CircleMarquee.speed_max = GIGABYTE_AORUS_LAPTOP_SPEED_MAX;
CircleMarquee.speed = GIGABYTE_AORUS_LAPTOP_SPEED_MAX/2;
modes.push_back(CircleMarquee);
mode RainbowMarquee;
RainbowMarquee.name = "Rainbow Marquee";
RainbowMarquee.value = GIGABYTE_AORUS_LAPTOP_RAINBOW_MARQUEE_MODE_VALUE;
RainbowMarquee.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
RainbowMarquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
RainbowMarquee.colors.resize(1);
RainbowMarquee.colors_min = 1;
RainbowMarquee.colors_max = 1;
RainbowMarquee.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
RainbowMarquee.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
RainbowMarquee.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
RainbowMarquee.speed_min = GIGABYTE_AORUS_LAPTOP_SPEED_MIN;
RainbowMarquee.speed_max = GIGABYTE_AORUS_LAPTOP_SPEED_MAX;
RainbowMarquee.speed = GIGABYTE_AORUS_LAPTOP_SPEED_MAX/2;
modes.push_back(RainbowMarquee);
mode Ripple;
Ripple.name = "Ripple";
Ripple.value = GIGABYTE_AORUS_LAPTOP_RIPPLE_MODE_VALUE;
Ripple.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC;
Ripple.colors.resize(1);
Ripple.colors_min = 1;
Ripple.colors_max = 1;
Ripple.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Ripple.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Ripple.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
Ripple.speed_min = GIGABYTE_AORUS_LAPTOP_SPEED_MIN;
Ripple.speed_max = GIGABYTE_AORUS_LAPTOP_SPEED_MAX;
Ripple.speed = GIGABYTE_AORUS_LAPTOP_SPEED_MAX/2;
modes.push_back(Ripple);
mode Hedge;
Hedge.name = "Hedge";
Hedge.value = GIGABYTE_AORUS_LAPTOP_HEDGE_MODE_VALUE;
Hedge.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Hedge.color_mode = MODE_COLORS_MODE_SPECIFIC;
Hedge.colors.resize(1);
Hedge.colors_min = 1;
Hedge.colors_max = 1;
Hedge.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Hedge.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Hedge.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
Hedge.speed_min = GIGABYTE_AORUS_LAPTOP_SPEED_MIN;
Hedge.speed_max = GIGABYTE_AORUS_LAPTOP_SPEED_MAX;
Hedge.speed = GIGABYTE_AORUS_LAPTOP_SPEED_MAX/2;
modes.push_back(Hedge);
mode Custom;
Custom.name = "Custom";
Custom.value = GIGABYTE_AORUS_LAPTOP_CUSTOM_MODE_VALUE;
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Custom.color_mode = MODE_COLORS_PER_LED;
Custom.brightness_min = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MIN;
Custom.brightness_max = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX;
Custom.brightness = GIGABYTE_AORUS_LAPTOP_BRIGHTNESS_MAX/2;
modes.push_back(Custom);
}
SetupZones();
}
RGBController_GigabyteAorusLaptop::~RGBController_GigabyteAorusLaptop()
{
delete controller;
}
void RGBController_GigabyteAorusLaptop::SetupZones()
{
/*---------------------------------------------------------*\
| Main zone 1 LED only |
\*---------------------------------------------------------*/
zone new_zone;
switch(dev_type)
{
case GIGABYTE_AORUS_LAPTOP_KEYBOARD_TYPE:
new_zone.name = "Keyboard";
break;
case GIGABYTE_AORUS_LAPTOP_BACKLIGHT_TYPE:
new_zone.name = "Backlight";
break;
default:
new_zone.name = "Unknonw";
break;
}
new_zone.type = ZONE_TYPE_SINGLE;
new_zone.leds_min = 1;
new_zone.leds_max = 1;
new_zone.leds_count = 1;
zones.push_back(new_zone);
led new_led;
new_led.name = "LED";
leds.push_back(new_led);
/*---------------------------------------------------------*\
| Adding an extra zone for the keyboard real layout |
\*---------------------------------------------------------*/
if(dev_type == GIGABYTE_AORUS_LAPTOP_KEYBOARD_TYPE)
{
/*-----------------------------------------*\
| Create the zone |
\*-----------------------------------------*/
unsigned int zone_size = 0;
zone keyboard_zone;
keyboard_zone.name = "Keyboard layout";
keyboard_zone.type = ZONE_TYPE_MATRIX;
keyboard_zone.matrix_map.Set(aorus_laptop_default_keyboard_layout.height, aorus_laptop_default_keyboard_layout.width, (unsigned int *)&aorus_laptop_default_keyboard_layout.matrix_map);
for(unsigned int h = 0; h < aorus_laptop_default_keyboard_layout.height; h++)
{
for(unsigned int w = 0; w < aorus_laptop_default_keyboard_layout.width; w++)
{
unsigned int key = aorus_laptop_default_keyboard_layout.matrix_map[h][w];
if(key != NA)
{
led new_led;
new_led.name = aorus_laptop_default_keyboard_layout.led_names[key];
leds.push_back(new_led);
zone_size++;
}
}
}
keyboard_zone.leds_min = zone_size;
keyboard_zone.leds_max = zone_size;
keyboard_zone.leds_count = zone_size;
zones.push_back(keyboard_zone);
}
SetupColors();
}
void RGBController_GigabyteAorusLaptop::DeviceUpdateLEDs()
{
/*---------------------------------------------------------*\
| This device supports direct mode per LED for main zone |
| only |
\*---------------------------------------------------------*/
if(modes[active_mode].value == GIGABYTE_AORUS_LAPTOP_DIRECT_MODE_VALUE)
{
controller->SetDirect(modes[active_mode].brightness, colors[0]);
}
/*---------------------------------------------------------*\
| This device supports custom mode per LED for the layout |
| zone only, this isnt a direct mode |
| Skip first color from colors array (that's the first zone |
\*---------------------------------------------------------*/
else if(modes[active_mode].value == GIGABYTE_AORUS_LAPTOP_CUSTOM_MODE_VALUE)
{
std::vector<RGBColor> layout_zone_colors;
for(unsigned int i = 1; i < colors.size(); i++)
{
layout_zone_colors.push_back(colors[i]);
}
controller->SetCustom(layout_zone_colors, aorus_laptop_default_keyboard_layout.led_sequence_positions, modes[active_mode].brightness);
}
}
void RGBController_GigabyteAorusLaptop::DeviceUpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_GigabyteAorusLaptop::DeviceUpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_GigabyteAorusLaptop::DeviceUpdateMode()
{
const mode& current_mode = modes[active_mode];
/*---------------------------------------------------------*\
| Redirect direct and custom mode to per led handler |
\*---------------------------------------------------------*/
if(current_mode.value == GIGABYTE_AORUS_LAPTOP_DIRECT_MODE_VALUE || current_mode.value == GIGABYTE_AORUS_LAPTOP_CUSTOM_MODE_VALUE)
{
return DeviceUpdateLEDs();
}
/*---------------------------------------------------------*\
| Hardware modes update |
\*---------------------------------------------------------*/
unsigned char brightness = current_mode.colors[0] == 0 ? 0 : current_mode.brightness; // handles black color (not indexed)
controller->SetMode(current_mode.value, current_mode.speed, brightness, current_mode.direction + 1, current_mode.colors[0]);
}
Reference in New Issue View Git Blame Copy Permalink