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

Initial commit for AOC GK500 keyboard

Browse source
This commit is contained in:
Adam Honse 2023-05-10 17:08:06 -05:00
parent 164f53dc91
commit d1b4a97cb1
6 changed files with 557 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

140
Controllers/AOCKeyboardController/AOCKeyboardController.cpp Normal file
View file

@ -0,0 +1,140 @@
/*-----------------------------------------*\
| AOCKeyboardController.cpp |
| |
| Driver for AOC Keyboard lighting |
| controller |
| |
| Adam Honse (CalcProgrammer1) 5/10/2023 |
\*-----------------------------------------*/
#include "AOCKeyboardController.h"
#include <cstring>
#include <chrono>
#include <thread>
using namespace std::chrono_literals;
AOCKeyboardController::AOCKeyboardController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
}
AOCKeyboardController::~AOCKeyboardController()
{
hid_close(dev);
}
std::string AOCKeyboardController::GetDeviceLocation()
{
return("HID " + location);
}
std::string AOCKeyboardController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
std::wstring return_wstring = serial_string;
std::string return_string(return_wstring.begin(), return_wstring.end());
return(return_string);
}
/*-------------------------------------------------------------------------------------------------*\
| Private packet sending functions. |
\*-------------------------------------------------------------------------------------------------*/
void AOCKeyboardController::SendDirect
(
RGBColor* color_data
)
{
SendPacket(AOC_KEYBOARD_MODE_STATIC,
AOC_KEYBOARD_SINGLE_COLOR,
AOC_KEYBOARD_BRIGHTNESS_HIGH,
AOC_KEYBOARD_SPEED_MEDIUM,
AOC_KEYBOARD_DIRECTION_CLOCKWISE,
color_data);
}
void AOCKeyboardController::SendPacket
(
unsigned char mode,
unsigned char random,
unsigned char brightness,
unsigned char speed,
unsigned char direction,
RGBColor* color_data
)
{
unsigned char buf[117];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(buf, 0x00, sizeof(buf));
/*-----------------------------------------------------*\
| Set up RGB configuration packet |
\*-----------------------------------------------------*/
buf[0x00] = 0x14;
buf[0x01] = 0x01;
buf[0x06] = mode;
buf[0x07 + (9 * mode) + 0] = RGBGetRValue(color_data[0]);
buf[0x07 + (9 * mode) + 1] = RGBGetGValue(color_data[0]);
buf[0x07 + (9 * mode) + 2] = RGBGetBValue(color_data[0]);
buf[0x07 + (9 * mode) + 3] = random;
buf[0x07 + (9 * mode) + 4] = direction;
buf[0x07 + (9 * mode) + 5] = speed;
buf[0x07 + (9 * mode) + 6] = brightness;
unsigned short checksum = 0x4A9E;
for(unsigned int buf_idx = 0; buf_idx < 115; buf_idx++)
{
checksum += buf[buf_idx];
}
buf[115] = checksum & 0xFF;
buf[116] = checksum >> 8;
unsigned char buf3[] =
{
0x09, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
hid_write(dev, buf3, 64);
std::this_thread::sleep_for(10ms);
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, buf, 117);
std::this_thread::sleep_for(10ms);
unsigned char buf2[] =
{
0x09, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
hid_write(dev, buf2, 64);
}

90
Controllers/AOCKeyboardController/AOCKeyboardController.h Normal file
View file

@ -0,0 +1,90 @@
/*-----------------------------------------*\
| AOCKeyboardController.h |
| |
| Definitions and types for AOC keyboard |
| lighting controller |
| |
| Adam Honse (CalcProgrammer1) 5/10/2023 |
\*-----------------------------------------*/
#include "RGBController.h"
#include <hidapi/hidapi.h>
#include <string>
#pragma once
/*-----------------------------------------*\
| AOC Keyboard Modes |
\*-----------------------------------------*/
enum
{
AOC_KEYBOARD_MODE_STATIC = 0x00, /* Static mode */
AOC_KEYBOARD_MODE_BREATHING = 0x01, /* Breathing mode */
AOC_KEYBOARD_MODE_REACT = 0x02, /* React mode */
AOC_KEYBOARD_MODE_RIPPLE = 0x04, /* Ripple mode */
AOC_KEYBOARD_MODE_RADAR = 0x05, /* Radar mode */
AOC_KEYBOARD_MODE_FIREWORKS = 0x06, /* Fireworks mode */
AOC_KEYBOARD_MODE_BLINK = 0x07, /* Blink mode */
AOC_KEYBOARD_MODE_WAVE = 0x08, /* Wave mode */
AOC_KEYBOARD_MODE_CUSTOM = 0x09, /* Custom mode */
AOC_KEYBOARD_MODE_CONCENTRIC_CIRCLES = 0x0A, /* Concentric Circles mode */
AOC_KEYBOARD_MODE_W_WAVE = 0x0B, /* W Wave mode */
};
enum
{
AOC_KEYBOARD_SPEED_SLOW = 0x03, /* Slowest speed */
AOC_KEYBOARD_SPEED_MEDIUM = 0x02, /* Medium speed */
AOC_KEYBOARD_SPEED_FAST = 0x01, /* Fastest speed */
};
enum
{
AOC_KEYBOARD_BRIGHTNESS_OFF = 0x00, /* Lowest brightness (off) */
AOC_KEYBOARD_BRIGHTNESS_LOW = 0x01, /* Low brightness */
AOC_KEYBOARD_BRIGHTNESS_MEDIUM = 0x02, /* Medium brightness */
AOC_KEYBOARD_BRIGHTNESS_HIGH = 0x03, /* Highest brightness */
};
enum
{
AOC_KEYBOARD_SINGLE_COLOR = 0x00, /* Single color mode */
AOC_KEYBOARD_RANDOM = 0x01, /* Random color mode */
};
enum
{
AOC_KEYBOARD_DIRECTION_CLOCKWISE = 0x00, /* Clockwise direction */
AOC_KEYBOARD_DIRECTION_COUNTERCLOCKWISE = 0x01, /* Counter-clockwise direction */
};
class AOCKeyboardController
{
public:
AOCKeyboardController(hid_device* dev_handle, const char* path);
~AOCKeyboardController();
std::string GetDeviceLocation();
std::string GetSerialString();
void SendDirect
(
RGBColor* color_data
);
void SendPacket
(
unsigned char mode,
unsigned char random,
unsigned char brightness,
unsigned char speed,
unsigned char direction,
RGBColor* color_data
);
private:
hid_device* dev;
std::string location;
};

34
Controllers/AOCKeyboardController/AOCKeyboardControllerDetect.cpp Normal file
View file

@ -0,0 +1,34 @@
#include "Detector.h"
#include "AOCKeyboardController.h"
#include "RGBController.h"
#include "RGBController_AOCKeyboard.h"
/*-----------------------------------------------------*\
| AOC Mousemat IDs |
\*-----------------------------------------------------*/
#define AOC_VID 0x3938
#define AOC_GK500_PID 0x1178
/******************************************************************************************\
* *
* DetectAOCKeyboardControllers *
* *
* Tests the USB address to see if an AOC Keyboard controller exists there. *
* *
\******************************************************************************************/
void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AOCKeyboardController* controller = new AOCKeyboardController(dev, info->path);
RGBController_AOCKeyboard* rgb_controller = new RGBController_AOCKeyboard(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR_PU("AOC GK500", DetectAOCKeyboardControllers, AOC_VID, AOC_GK500_PID, 0xFF19, 0xFF19);

255
Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp Normal file
View file

@ -0,0 +1,255 @@
/*-----------------------------------------*\
| RGBController_AOCKeyboard.cpp |
| |
| Generic RGB Interface for AOC keyboard |
| |
| Adam Honse (CalcProgrammer1) 5/10/2023 |
\*-----------------------------------------*/
#include "RGBController_AOCKeyboard.h"
/**------------------------------------------------------------------*\
@name AOC Keyboard
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectAOCKeyboardControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* controller_ptr)
{
controller = controller_ptr;
name = "AOC Keyboard Device";
vendor = "AOC";
type = DEVICE_TYPE_KEYBOARD;
description = "AOC Keyboard Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Static;
Static.name = "Static";
Static.value = AOC_KEYBOARD_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Static.color_mode = MODE_COLORS_PER_LED;
Static.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
Static.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
Static.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
modes.push_back(Static);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = AOC_KEYBOARD_MODE_STATIC;
SpectrumCycle.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
SpectrumCycle.color_mode = MODE_COLORS_RANDOM;
SpectrumCycle.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
SpectrumCycle.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
SpectrumCycle.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
SpectrumCycle.speed_min = AOC_KEYBOARD_SPEED_SLOW;
SpectrumCycle.speed_max = AOC_KEYBOARD_SPEED_FAST;
SpectrumCycle.speed = AOC_KEYBOARD_SPEED_MEDIUM;
modes.push_back(SpectrumCycle);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = AOC_KEYBOARD_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
Breathing.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
Breathing.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
Breathing.speed_min = AOC_KEYBOARD_SPEED_SLOW;
Breathing.speed_max = AOC_KEYBOARD_SPEED_FAST;
Breathing.speed = AOC_KEYBOARD_SPEED_MEDIUM;
modes.push_back(Breathing);
mode React;
React.name = "React";
React.value = AOC_KEYBOARD_MODE_REACT;
React.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
React.color_mode = MODE_COLORS_PER_LED;
React.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
React.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
React.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
React.speed_min = AOC_KEYBOARD_SPEED_SLOW;
React.speed_max = AOC_KEYBOARD_SPEED_FAST;
React.speed = AOC_KEYBOARD_SPEED_MEDIUM;
modes.push_back(React);
mode Ripple;
Ripple.name = "Ripple";
Ripple.value = AOC_KEYBOARD_MODE_RIPPLE;
Ripple.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
Ripple.color_mode = MODE_COLORS_PER_LED;
Ripple.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
Ripple.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
Ripple.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
Ripple.speed_min = AOC_KEYBOARD_SPEED_SLOW;
Ripple.speed_max = AOC_KEYBOARD_SPEED_FAST;
Ripple.speed = AOC_KEYBOARD_SPEED_MEDIUM;
modes.push_back(Ripple);
mode Radar;
Radar.name = "Radar";
Radar.value = AOC_KEYBOARD_MODE_RADAR;
Radar.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Radar.color_mode = MODE_COLORS_PER_LED;
Radar.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
Radar.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
Radar.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
Radar.speed_min = AOC_KEYBOARD_SPEED_SLOW;
Radar.speed_max = AOC_KEYBOARD_SPEED_FAST;
Radar.speed = AOC_KEYBOARD_SPEED_MEDIUM;
modes.push_back(Radar);
mode Fireworks;
Fireworks.name = "Fireworks";
Fireworks.value = AOC_KEYBOARD_MODE_FIREWORKS;
Fireworks.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
Fireworks.color_mode = MODE_COLORS_PER_LED;
Fireworks.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
Fireworks.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
Fireworks.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
Fireworks.speed_min = AOC_KEYBOARD_SPEED_SLOW;
Fireworks.speed_max = AOC_KEYBOARD_SPEED_FAST;
Fireworks.speed = AOC_KEYBOARD_SPEED_MEDIUM;
modes.push_back(Fireworks);
mode Blink;
Blink.name = "Flashing";
Blink.value = AOC_KEYBOARD_MODE_BLINK;
Blink.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
Blink.color_mode = MODE_COLORS_PER_LED;
Blink.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
Blink.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
Blink.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
Blink.speed_min = AOC_KEYBOARD_SPEED_SLOW;
Blink.speed_max = AOC_KEYBOARD_SPEED_FAST;
Blink.speed = AOC_KEYBOARD_SPEED_MEDIUM;
modes.push_back(Blink);
mode Wave;
Wave.name = "Wave";
Wave.value = AOC_KEYBOARD_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Wave.color_mode = MODE_COLORS_PER_LED;
Wave.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
Wave.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
Wave.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
Wave.speed_min = AOC_KEYBOARD_SPEED_SLOW;
Wave.speed_max = AOC_KEYBOARD_SPEED_FAST;
Wave.speed = AOC_KEYBOARD_SPEED_MEDIUM;
modes.push_back(Wave);
mode RainbowWave;
RainbowWave.name = "Rainbow Wave";
RainbowWave.value = AOC_KEYBOARD_MODE_WAVE;
RainbowWave.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
RainbowWave.color_mode = MODE_COLORS_RANDOM;
RainbowWave.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
RainbowWave.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
RainbowWave.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
RainbowWave.speed_min = AOC_KEYBOARD_SPEED_SLOW;
RainbowWave.speed_max = AOC_KEYBOARD_SPEED_FAST;
RainbowWave.speed = AOC_KEYBOARD_SPEED_MEDIUM;
modes.push_back(RainbowWave);
mode ConcentricCircles;
ConcentricCircles.name = "Concentric Circles";
ConcentricCircles.value = AOC_KEYBOARD_MODE_CONCENTRIC_CIRCLES;
ConcentricCircles.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
ConcentricCircles.color_mode = MODE_COLORS_PER_LED;
ConcentricCircles.brightness_min= AOC_KEYBOARD_BRIGHTNESS_OFF;
ConcentricCircles.brightness_max= AOC_KEYBOARD_BRIGHTNESS_HIGH;
ConcentricCircles.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
ConcentricCircles.speed_min = AOC_KEYBOARD_SPEED_SLOW;
ConcentricCircles.speed_max = AOC_KEYBOARD_SPEED_FAST;
ConcentricCircles.speed = AOC_KEYBOARD_SPEED_MEDIUM;
modes.push_back(ConcentricCircles);
mode WWave;
WWave.name = "W Wave";
WWave.value = AOC_KEYBOARD_MODE_W_WAVE;
WWave.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
WWave.color_mode = MODE_COLORS_PER_LED;
WWave.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
WWave.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
WWave.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
WWave.speed_min = AOC_KEYBOARD_SPEED_SLOW;
WWave.speed_max = AOC_KEYBOARD_SPEED_FAST;
WWave.speed = AOC_KEYBOARD_SPEED_MEDIUM;
modes.push_back(WWave);
SetupZones();
};
RGBController_AOCKeyboard::~RGBController_AOCKeyboard()
{
delete controller;
}
void RGBController_AOCKeyboard::SetupZones()
{
zone keyboard_zone;
keyboard_zone.name = "Keyboard";
keyboard_zone.type = ZONE_TYPE_SINGLE;
keyboard_zone.leds_min = 1;
keyboard_zone.leds_max = 1;
keyboard_zone.leds_count = 1;
keyboard_zone.matrix_map = NULL;
zones.push_back(keyboard_zone);
led keyboard_led;
keyboard_led.name = "Keyboard";
leds.push_back(keyboard_led);
SetupColors();
}
void RGBController_AOCKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AOCKeyboard::DeviceUpdateLEDs()
{
DeviceUpdateMode();
}
void RGBController_AOCKeyboard::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_AOCKeyboard::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_AOCKeyboard::DeviceUpdateMode()
{
unsigned char aoc_direction = AOC_KEYBOARD_DIRECTION_CLOCKWISE;
unsigned char aoc_random = AOC_KEYBOARD_SINGLE_COLOR;
if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
{
aoc_direction = AOC_KEYBOARD_DIRECTION_COUNTERCLOCKWISE;
}
if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
{
aoc_random = AOC_KEYBOARD_RANDOM;
}
controller->SendPacket(modes[active_mode].value,
aoc_random,
modes[active_mode].brightness,
modes[active_mode].speed,
aoc_direction,
&colors[0]);
}

32
Controllers/AOCKeyboardController/RGBController_AOCKeyboard.h Normal file
View file

@ -0,0 +1,32 @@
/*-----------------------------------------*\
| RGBController_AOCKeyboard.h |
| |
| Generic RGB Interface for AOC keyboard |
| |
| Adam Honse (CalcProgrammer1) 5/10/2023 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AOCKeyboardController.h"
class RGBController_AOCKeyboard : public RGBController
{
public:
RGBController_AOCKeyboard(AOCKeyboardController* controller_ptr);
~RGBController_AOCKeyboard();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
AOCKeyboardController* controller;
};

6
OpenRGB.pro
View file

@ -83,6 +83,7 @@ INCLUDEPATH +=
Controllers/AlienwareController/ \
Controllers/AlienwareKeyboardController/ \
Controllers/AMDWraithPrismController/ \
Controllers/AOCKeyboardController/ \
Controllers/AOCMouseController/ \
Controllers/AOCMousematController/ \
Controllers/ASRockPolychromeUSBController/ \
@ -278,6 +279,8 @@ HEADERS +=
Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.h \
Controllers/AnnePro2Controller/AnnePro2Controller.h \
Controllers/AnnePro2Controller/RGBController_AnnePro2.h \
Controllers/AOCKeyboardController/AOCKeyboardController.h \
Controllers/AOCKeyboardController/RGBController_AOCKeyboard.h \
Controllers/AOCMouseController/AOCMouseController.h \
Controllers/AOCMouseController/RGBController_AOCMouse.h \
Controllers/AOCMousematController/AOCMousematController.h \
@ -841,6 +844,9 @@ SOURCES +=
Controllers/AnnePro2Controller/AnnePro2Controller.cpp \
Controllers/AnnePro2Controller/AnnePro2ControllerDetect.cpp \
Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp \
Controllers/AOCKeyboardController/AOCKeyboardController.cpp \
Controllers/AOCKeyboardController/AOCKeyboardControllerDetect.cpp \
Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp \
Controllers/AOCMouseController/AOCMouseController.cpp \
Controllers/AOCMouseController/AOCMouseControllerDetect.cpp \
Controllers/AOCMouseController/RGBController_AOCMouse.cpp \