diff --git a/Controllers/LightSaltController/LightSaltController.cpp b/Controllers/LightSaltController/LightSaltController.cpp new file mode 100644 index 00000000..7abc32fb --- /dev/null +++ b/Controllers/LightSaltController/LightSaltController.cpp @@ -0,0 +1,314 @@ +/*---------------------------------------------------------*\ +| LightSaltController.cpp | +| | +| Driver for LightSalt Peripherals | +| | +| James Buren (braewoods) 23 Jul 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#include +#include "LightSaltController.h" + +static const int mode_map[LIGHTSALT_MODE_MAXIMUM][6] = +{ + {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, + {0x0100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, + {0x0400, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, + {0x0700, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, + {0x0A00, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, + {0x0D00, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, + {0x0E00, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, + {0x0F00, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, + {0x1100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, + {0x0000, 0x0000, 0x0000, 0x0000, 0x3301, 0x3302}, + {0x3402, 0x3401, 0x0000, 0x0000, 0x0000, 0x0000}, + {0x3502, 0x3501, 0x0000, 0x0000, 0x0000, 0x0000}, + {0x3602, 0x3601, 0x0000, 0x0000, 0x0000, 0x0000}, + {0x3802, 0x3801, 0x0000, 0x0000, 0x0000, 0x0000}, + {0x0000, 0x0000, 0x3901, 0x3902, 0x0000, 0x0000}, + {0x0000, 0x0000, 0x3A01, 0x3A02, 0x0000, 0x0000}, + {0x0000, 0x0000, 0x0000, 0x0000, 0x3702, 0x3701}, + {0x3B02, 0x3B01, 0x0000, 0x0000, 0x0000, 0x0000} +}; + +LightSaltController::LightSaltController(hid_device* dev_handle, const hid_device_info& info) +{ + wchar_t usb_string[128]; + + dev = dev_handle; + device_location = info.path; + + if(hid_get_serial_number_string(dev, usb_string, 128) == 0) + { + std::wstring tmp_wstring = usb_string; + serial = std::string(tmp_wstring.begin(), tmp_wstring.end()); + } + else + { + serial = ""; + } + + if(hid_get_manufacturer_string(dev, usb_string, 128) == 0) + { + std::wstring tmp_wstring = usb_string; + manufacturer = std::string(tmp_wstring.begin(), tmp_wstring.end()); + } + else + { + manufacturer = ""; + } + + if(hid_get_product_string(dev, usb_string, 128) == 0) + { + std::wstring tmp_wstring = usb_string; + product = std::string(tmp_wstring.begin(), tmp_wstring.end()); + } + else + { + product = ""; + } + + if(strstr(manufacturer.c_str(), "Light&Salt") && strstr(product.c_str(), "Light&Salt")) + { + QueryDeviceModel(); + QueryDeviceClass(); + SetDeviceType(); + } + else + { + device_model = ""; + device_class = ""; + firmware_version = ""; + device_type = LIGHTSALT_TYPE_MAXIMUM; + } +} + +LightSaltController::~LightSaltController() +{ + hid_close(dev); +} + +std::string LightSaltController::GetDeviceLocation() +{ + return("HID: " + device_location); +} + +std::string LightSaltController::GetSerial() +{ + return(serial); +} + +std::string LightSaltController::GetManufacturer() +{ + return(manufacturer); +} + +std::string LightSaltController::GetProduct() +{ + return(product); +} + +std::string LightSaltController::GetDeviceModel() +{ + return(device_model); +} + +std::string LightSaltController::GetDeviceClass() +{ + return(device_class); +} + +std::string LightSaltController::GetFirmwareVersion() +{ + return(firmware_version); +} + +int LightSaltController::GetDeviceType() +{ + return(device_type); +} + +void LightSaltController::SetColors(RGBColor* colors, int sets, int rows, int columns) +{ + uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH]; + int color_idx = 0; + + write_buffer[0] = 0x00; + + for(int set_idx = 0; set_idx < sets; set_idx++) + { + write_buffer[1] = 0x03 + set_idx; + + for(int row_idx = 0; row_idx < rows; row_idx++) + { + int write_idx = 2; + + write_buffer[write_idx++] = 0x01 + row_idx * columns; + + for(int column_idx = 0; column_idx < columns; column_idx++) + { + RGBColor color = colors[color_idx++]; + write_buffer[write_idx++] = RGBGetRValue(color); + write_buffer[write_idx++] = RGBGetGValue(color); + write_buffer[write_idx++] = RGBGetBValue(color); + } + + hid_write(dev, write_buffer, sizeof(write_buffer)); + } + } +} + +void LightSaltController::ApplyColors(int sets) +{ + uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH]; + int write_idx = 1; + + memset(write_buffer, 0x00, sizeof(write_buffer)); + write_buffer[write_idx++] = 0xFE; + write_buffer[write_idx++] = 0x01; + + for(int set_idx = 0; set_idx < sets; set_idx++) + { + write_buffer[write_idx++] = 0x03 + set_idx; + } + + hid_write(dev, write_buffer, sizeof(write_buffer)); +} + +void LightSaltController::SaveColors(int sets) +{ + uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH]; + int write_idx = 1; + + memset(write_buffer, 0x00, sizeof(write_buffer)); + write_buffer[write_idx++] = 0xFE; + write_buffer[write_idx++] = 0xF0; + + for(int set_idx = 0; set_idx < sets; set_idx++) + { + write_buffer[write_idx++] = 0x03 + set_idx; + } + + hid_write(dev, write_buffer, sizeof(write_buffer)); +} + +void LightSaltController::SetMode(int mode, int direction, int speed) +{ + uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH]; + int actual_mode = mode_map[mode][direction]; + + memset(write_buffer, 0x00, sizeof(write_buffer)); + write_buffer[1] = 0xFE; + write_buffer[2] = 0x03; + write_buffer[3] = (actual_mode & 0xFF00) >> 8; + write_buffer[4] = (actual_mode & 0x00FF) >> 0; + write_buffer[5] = speed; + + hid_write(dev, write_buffer, sizeof(write_buffer)); +} + +void LightSaltController::SetFilter(RGBColor color) +{ + uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH]; + + memset(write_buffer, 0x00, sizeof(write_buffer)); + write_buffer[1] = 0xFE; + write_buffer[2] = 0x04; + write_buffer[3] = RGBGetRValue(color); + write_buffer[4] = RGBGetGValue(color); + write_buffer[5] = RGBGetBValue(color); + + hid_write(dev, write_buffer, sizeof(write_buffer)); +} + +void LightSaltController::SetBrightness(uint8_t brightness) +{ + uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH]; + + memset(write_buffer, 0x00, sizeof(write_buffer)); + write_buffer[1] = 0xFE; + write_buffer[2] = 0x05; + write_buffer[3] = brightness; + + hid_write(dev, write_buffer, sizeof(write_buffer)); +} + +void LightSaltController::QueryDeviceModel() +{ + uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH]; + uint8_t read_buffer[LIGHTSALT_READ_LENGTH]; + + memset(write_buffer, 0x00, sizeof(write_buffer)); + write_buffer[1] = 0xFE; + write_buffer[2] = 0xF5; + write_buffer[3] = 0x06; + + if(hid_write(dev, write_buffer, sizeof(write_buffer)) != sizeof(write_buffer)) + { + device_model = ""; + return; + } + + if(hid_read_timeout(dev, read_buffer, sizeof(read_buffer), 100) != sizeof(read_buffer)) + { + device_model = ""; + return; + } + + device_model = (char *)(read_buffer + 3); +} + +void LightSaltController::QueryDeviceClass() +{ + uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH]; + uint8_t read_buffer[LIGHTSALT_READ_LENGTH]; + + memset(write_buffer, 0x00, sizeof(write_buffer)); + write_buffer[1] = 0xFE; + write_buffer[2] = 0xFF; + + if(hid_write(dev, write_buffer, sizeof(write_buffer)) != sizeof(write_buffer)) + { + device_class = ""; + firmware_version = ""; + return; + } + + if(hid_read_timeout(dev, read_buffer, sizeof(read_buffer), 100) != sizeof(read_buffer)) + { + device_class = ""; + firmware_version = ""; + return; + } + + device_class = (char *)(read_buffer ); + firmware_version = (char *)(read_buffer + device_class.size() + 1); +} + +void LightSaltController::SetDeviceType() +{ + struct device_class_table + { + std::string device_class; + int device_type; + }; + static const device_class_table table[] = + { + {"Light&Salt_keyboard1", LIGHTSALT_TYPE_KEYBOARD}, + {"Light&Salt_KEY_PAD", LIGHTSALT_TYPE_KEYPAD } + }; + + device_type = LIGHTSALT_TYPE_MAXIMUM; + + for(const device_class_table& match : table) + { + if(match.device_class == device_class) + { + device_type = match.device_type; + break; + } + } +} diff --git a/Controllers/LightSaltController/LightSaltController.h b/Controllers/LightSaltController/LightSaltController.h new file mode 100644 index 00000000..54890a52 --- /dev/null +++ b/Controllers/LightSaltController/LightSaltController.h @@ -0,0 +1,103 @@ +/*---------------------------------------------------------*\ +| LightSaltController.h | +| | +| Driver for LightSalt Peripherals | +| | +| James Buren (braewoods) 23 Jul 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#pragma once + +#include +#include +#include "RGBController.h" + +#define LIGHTSALT_PACKET_LENGTH 32 +#define LIGHTSALT_WRITE_LENGTH (LIGHTSALT_PACKET_LENGTH + 1) +#define LIGHTSALT_READ_LENGTH (LIGHTSALT_PACKET_LENGTH) + +enum +{ + LIGHTSALT_TYPE_KEYBOARD, + LIGHTSALT_TYPE_KEYPAD, + LIGHTSALT_TYPE_MAXIMUM +}; + +enum +{ + LIGHTSALT_MODE_CUSTOM, + LIGHTSALT_MODE_POINT, + LIGHTSALT_MODE_AREA, + LIGHTSALT_MODE_COLLAPSE, + LIGHTSALT_MODE_EXPAND, + LIGHTSALT_MODE_EXPLODE, + LIGHTSALT_MODE_DART, + LIGHTSALT_MODE_FLAME, + LIGHTSALT_MODE_LASER, + LIGHTSALT_MODE_BREATHING, + LIGHTSALT_MODE_TRICOLOR_RADAR, + LIGHTSALT_MODE_WHEEL_1, + LIGHTSALT_MODE_WHEEL_2, + LIGHTSALT_MODE_WAVE_1, + LIGHTSALT_MODE_WAVE_2, + LIGHTSALT_MODE_WAVE_3, + LIGHTSALT_MODE_RAINBOW_1, + LIGHTSALT_MODE_RAINBOW_2, + LIGHTSALT_MODE_MAXIMUM +}; + +enum +{ + LIGHTSALT_SPEED_MINIMUM = 0x01, + LIGHTSALT_SPEED_MAXIMUM = 0x32, + LIGHTSALT_SPEED_DEFAULT = 0x19 +}; + +enum +{ + LIGHTSALT_BRIGHTNESS_MINIMUM = 0x00, + LIGHTSALT_BRIGHTNESS_MAXIMUM = 0xFF, + LIGHTSALT_BRIGHTNESS_DEFAULT = 0x80 +}; + +class LightSaltController +{ +public: + LightSaltController(hid_device* dev_handle, const hid_device_info& info); + ~LightSaltController(); + + std::string GetDeviceLocation(); + std::string GetSerial(); + std::string GetManufacturer(); + std::string GetProduct(); + std::string GetDeviceModel(); + std::string GetDeviceClass(); + std::string GetFirmwareVersion(); + int GetDeviceType(); + + void SetColors(RGBColor* colors, int sets, int rows, int columns); + void ApplyColors(int sets); + void SaveColors(int sets); + void SetMode(int mode, int direction, int speed); + void SetFilter(RGBColor color); + void SetBrightness(uint8_t brightness); + +private: + hid_device* dev; + + std::string device_location; + std::string serial; + std::string manufacturer; + std::string product; + std::string device_model; + std::string device_class; + std::string firmware_version; + int device_type; + + void QueryDeviceModel(); + void QueryDeviceClass(); + void SetDeviceType(); +}; diff --git a/Controllers/LightSaltController/LightSaltControllerDetect.cpp b/Controllers/LightSaltController/LightSaltControllerDetect.cpp new file mode 100644 index 00000000..45154ff5 --- /dev/null +++ b/Controllers/LightSaltController/LightSaltControllerDetect.cpp @@ -0,0 +1,52 @@ +/*---------------------------------------------------------*\ +| LightSaltControllerDetect.cpp | +| | +| Detector for LightSalt Peripherals | +| | +| James Buren (braewoods) 23 Jul 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#include +#include "Detector.h" +#include "LightSaltController.h" +#include "RGBController_LightSaltKeyboard.h" +#include "RGBController_LightSaltKeypad.h" + +#define LIGHTSALT_VID 0x0483 +#define LIGHTSALT_PID 0x5750 + +void DetectLightSaltControllers(hid_device_info* info, const std::string &) +{ + hid_device* dev = hid_open_path(info->path); + + if(dev) + { + LightSaltController* controller = new LightSaltController(dev, *info); + RGBController* rgb_controller = nullptr; + + switch(controller->GetDeviceType()) + { + case LIGHTSALT_TYPE_KEYBOARD: + rgb_controller = new RGBController_LightSaltKeyboard(controller); + break; + + case LIGHTSALT_TYPE_KEYPAD: + rgb_controller = new RGBController_LightSaltKeypad(controller); + break; + + default: + delete controller; + break; + } + + if(rgb_controller != nullptr) + { + ResourceManager::get()->RegisterRGBController(rgb_controller); + } + } +} /* DetectLightSaltControllers() */ + +REGISTER_HID_DETECTOR_IPU("LightSalt Peripherals", DetectLightSaltControllers, LIGHTSALT_VID, LIGHTSALT_PID, 1, 1, 0); diff --git a/Controllers/LightSaltController/RGBController_LightSalt.cpp b/Controllers/LightSaltController/RGBController_LightSalt.cpp new file mode 100644 index 00000000..c30d747a --- /dev/null +++ b/Controllers/LightSaltController/RGBController_LightSalt.cpp @@ -0,0 +1,452 @@ +/*---------------------------------------------------------*\ +| RGBController_LightSalt.cpp | +| | +| RGBController for LightSalt Peripherals | +| | +| James Buren (braewoods) 23 Jul 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#include +#include "RGBControllerKeyNames.h" +#include "RGBController_LightSalt.h" + +static RGBColor DeflectColor(bool deflection, RGBColor color) +{ + if(deflection) + { + int old_red = RGBGetRValue(color); + int old_grn = RGBGetGValue(color); + int old_blu = RGBGetBValue(color); + int new_red = old_red + ((255 - old_red) * 50 / 100); + int new_grn = old_grn + ((255 - old_grn) * 50 / 100); + int new_blu = old_blu + ((255 - old_blu) * 50 / 100); + return ToRGBColor(new_red, new_grn, new_blu); + } + else + { + return color; + } +} + +RGBController_LightSalt::~RGBController_LightSalt() +{ + /*---------------------------------------------------------*\ + | Delete the matrix map | + \*---------------------------------------------------------*/ + for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++) + { + if(zones[zone_index].matrix_map != nullptr) + { + delete zones[zone_index].matrix_map; + } + } + + delete controller; +} + +void RGBController_LightSalt::SetupData(LightSaltController* controller_ptr) +{ + controller = controller_ptr; + name = "LightSalt " + table.device.name; + vendor = "LightSalt"; + type = table.device.type; + description = "LightSalt " + table.device.name + " (" + controller->GetDeviceModel() + ")"; + location = controller->GetDeviceLocation(); + serial = controller->GetSerial(); + version = controller->GetFirmwareVersion(); +} + +void RGBController_LightSalt::SetupModes() +{ + { + mode mode; + mode.name = "Custom"; + mode.value = LIGHTSALT_MODE_CUSTOM; + mode.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_PER_LED; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Reactive Point"; + mode.value = LIGHTSALT_MODE_POINT; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Reactive Area"; + mode.value = LIGHTSALT_MODE_AREA; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Reactive Collapse"; + mode.value = LIGHTSALT_MODE_COLLAPSE; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Reactive Expand"; + mode.value = LIGHTSALT_MODE_EXPAND; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Reactive Explode"; + mode.value = LIGHTSALT_MODE_EXPLODE; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Reactive Dart"; + mode.value = LIGHTSALT_MODE_DART; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Reactive Flame"; + mode.value = LIGHTSALT_MODE_FLAME; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Reactive Laser"; + mode.value = LIGHTSALT_MODE_LASER; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Breathing"; + mode.value = LIGHTSALT_MODE_BREATHING; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.direction = MODE_DIRECTION_HORIZONTAL; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Tricolor Radar"; + mode.value = LIGHTSALT_MODE_TRICOLOR_RADAR; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.direction = MODE_DIRECTION_LEFT; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Wheel 1"; + mode.value = LIGHTSALT_MODE_WHEEL_1; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.direction = MODE_DIRECTION_LEFT; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Wheel 2"; + mode.value = LIGHTSALT_MODE_WHEEL_2; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.direction = MODE_DIRECTION_LEFT; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Wave 1"; + mode.value = LIGHTSALT_MODE_WAVE_1; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.direction = MODE_DIRECTION_LEFT; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Wave 2"; + mode.value = LIGHTSALT_MODE_WAVE_2; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.direction = MODE_DIRECTION_UP; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Wave 3"; + mode.value = LIGHTSALT_MODE_WAVE_3; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.direction = MODE_DIRECTION_UP; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Rainbow 1"; + mode.value = LIGHTSALT_MODE_RAINBOW_1; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.direction = MODE_DIRECTION_HORIZONTAL; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } + + { + mode mode; + mode.name = "Rainbow 2"; + mode.value = LIGHTSALT_MODE_RAINBOW_2; + mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE; + mode.speed_min = LIGHTSALT_SPEED_MINIMUM; + mode.speed_max = LIGHTSALT_SPEED_MAXIMUM; + mode.speed = LIGHTSALT_SPEED_DEFAULT; + mode.direction = MODE_DIRECTION_LEFT; + mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM; + mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM; + mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT; + mode.color_mode = MODE_COLORS_NONE; + modes.push_back(mode); + } +} + +void RGBController_LightSalt::SetupZones() +{ + { + zone zone; + zone.name = table.device.name; + zone.type = ZONE_TYPE_MATRIX; + zone.leds_min = table.led.count; + zone.leds_max = table.led.count; + zone.leds_count = table.led.count; + zone.matrix_map = new matrix_map_type; + zone.matrix_map->height = table.map.height; + zone.matrix_map->width = table.map.width; + zone.matrix_map->map = table.map.matrix; + zones.push_back(zone); + } + + for(int led_idx = 0; led_idx < table.led.count; led_idx++) + { + led led; + led.name = table.led.names[led_idx]; + leds.push_back(led); + } + + { + zone zone; + zone.name = "Color Filter"; + zone.type = ZONE_TYPE_SINGLE; + zone.leds_min = 1; + zone.leds_max = 1; + zone.leds_count = 1; + zone.matrix_map = NULL; + zones.push_back(zone); + } + + { + led led; + led.name = "Color Filter"; + leds.push_back(led); + } + + SetupColors(); + + colors[colors.size() - 1] = ToRGBColor(0xFF, 0xFF, 0xFF); +} + +void RGBController_LightSalt::ResizeZone(int /*zone*/, int /*new_size*/) +{ + /*---------------------------------------------------------*\ + | This device does not support resizing zones | + \*---------------------------------------------------------*/ +} + +void RGBController_LightSalt::DeviceUpdateColors(bool save) +{ + int sets = table.led.sets; + int rows = table.led.rows; + int columns = table.led.columns; + + RGBColor colors_data[sets][rows][columns]; + memset(colors_data, 0x00, sizeof(colors_data)); + + for(int led_idx = 0; led_idx < table.led.count; led_idx++) + { + int index = table.led.indices[led_idx]; + int deflection = table.led.deflections[led_idx]; + int row = index / columns; + int column = index % columns; + RGBColor color = colors[led_idx]; + + for(int set_idx = 0; set_idx < sets; set_idx++) + { + colors_data[set_idx][row][column] = DeflectColor(deflection & (1 << set_idx), color); + } + } + + controller->SetFilter(colors[colors.size() - 1]); + controller->SetColors((RGBColor*)colors_data, sets, rows, columns); + controller->ApplyColors(sets); + if(save) + { + controller->SaveColors(sets); + } +} + +void RGBController_LightSalt::DeviceUpdateLEDs() +{ + DeviceUpdateColors(false); +} + +void RGBController_LightSalt::UpdateZoneLEDs(int /*zone*/) +{ + DeviceUpdateLEDs(); +} + +void RGBController_LightSalt::UpdateSingleLED(int /*led*/) +{ + DeviceUpdateLEDs(); +} + +void RGBController_LightSalt::DeviceUpdateMode() +{ + const mode& mode = modes[active_mode]; + + controller->SetBrightness(mode.brightness); + std::this_thread::sleep_for(std::chrono::milliseconds(25)); + controller->SetMode(mode.value, mode.direction, mode.speed); +} + +void RGBController_LightSalt::DeviceSaveMode() +{ + DeviceUpdateColors(true); +} diff --git a/Controllers/LightSaltController/RGBController_LightSalt.h b/Controllers/LightSaltController/RGBController_LightSalt.h new file mode 100644 index 00000000..55b8461a --- /dev/null +++ b/Controllers/LightSaltController/RGBController_LightSalt.h @@ -0,0 +1,62 @@ +/*---------------------------------------------------------*\ +| RGBController_LightSalt.h | +| | +| RGBController for LightSalt Peripherals | +| | +| James Buren (braewoods) 23 Jul 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#pragma once + +#include "RGBController.h" +#include "LightSaltController.h" + +class RGBController_LightSalt : public RGBController +{ +public: + ~RGBController_LightSalt(); + + void SetupData(LightSaltController* controller_ptr); + void SetupModes(); + + void SetupZones(); + void ResizeZone(int zone, int new_size); + + void DeviceUpdateColors(bool save); + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void DeviceUpdateMode(); + void DeviceSaveMode(); + +protected: + struct + { + struct + { + std::string name; + int type; + } device; + struct + { + int sets; + int rows; + int columns; + int count; + char const * const * names; + const int* indices; + const int* deflections; + } led; + struct + { + unsigned int height; + unsigned int width; + unsigned int* matrix; + } map; + } table; + LightSaltController* controller; +}; diff --git a/Controllers/LightSaltController/RGBController_LightSaltKeyboard.cpp b/Controllers/LightSaltController/RGBController_LightSaltKeyboard.cpp new file mode 100644 index 00000000..86a68236 --- /dev/null +++ b/Controllers/LightSaltController/RGBController_LightSaltKeyboard.cpp @@ -0,0 +1,207 @@ +/*---------------------------------------------------------*\ +| RGBController_LightSaltKeyboard.cpp | +| | +| RGBController for LightSalt Keyboard | +| | +| James Buren (braewoods) 23 Jul 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#include "RGBControllerKeyNames.h" +#include "RGBController_LightSaltKeyboard.h" + +// 0xFFFFFFFF indicates an unused entry in matrix +#define NA 0xFFFFFFFF + +enum +{ + LED_SETS = 4, + LED_ROWS = 9, + LED_COLUMNS = 10, + LED_COUNT = 83, + MAP_HEIGHT = 6, + MAP_WIDTH = 15, +}; + +static char const * const led_names[LED_COUNT] = +{ + /* Row 1 */ + 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, + + /* Row 2 */ + 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_DELETE, + + /* Row 3 */ + 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_ANSI_BACK_SLASH, + KEY_EN_PRINT_SCREEN, + + /* Row 4 */ + 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_ANSI_ENTER, + + /* Row 5 */ + 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, + + /* Row 6 */ + KEY_EN_LEFT_CONTROL, + KEY_EN_LEFT_WINDOWS, + KEY_EN_LEFT_ALT, + KEY_EN_SPACE, + KEY_EN_SPACE, + KEY_EN_SPACE, + KEY_EN_SPACE, + KEY_EN_SPACE, + KEY_EN_RIGHT_ALT, + KEY_EN_RIGHT_FUNCTION, + KEY_EN_RIGHT_CONTROL, + KEY_EN_LEFT_ARROW, + KEY_EN_DOWN_ARROW, + KEY_EN_RIGHT_ARROW +}; + +static const int led_indices[LED_COUNT] = +{ + /* Row 1 */ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + + /* Row 2 */ + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + + /* Row 3 */ + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + + /* Row 4 */ + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + + /* Row 5 */ + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 73, + + /* Row 6 */ + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 87, 88, 89 +}; + +static const int led_deflections[LED_COUNT] = +{ + /* Row 1 */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + + /* Row 2 */ + 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0x0, 0x0, + + /* Row 3 */ + 0x0, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0xA, 0xA, 0xA, 0x0, + + /* Row 4 */ + 0x0, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0xA, 0xA, 0x0, + + /* Row 5 */ + 0x0, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0xA, 0xA, 0xA, 0x0, 0x0, + + /* Row 6 */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 +}; + +static const unsigned int matrix_map[MAP_HEIGHT][MAP_WIDTH] = +{ + /* Row 1 */ + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, NA, NA }, + + /* Row 2 */ + { 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27 }, + + /* Row 3 */ + { 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42 }, + + /* Row 4 */ + { 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, NA, NA }, + + /* Row 5 */ + { 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, NA, 68, NA }, + + /* Row 6 */ + { 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, NA, 80, 81, 82 } +}; + +RGBController_LightSaltKeyboard::RGBController_LightSaltKeyboard(LightSaltController* controller_ptr) +{ + table.device.name = "Keyboard"; + table.device.type = DEVICE_TYPE_KEYBOARD; + table.led.sets = LED_SETS; + table.led.rows = LED_ROWS; + table.led.columns = LED_COLUMNS; + table.led.count = LED_COUNT; + table.led.names = led_names; + table.led.indices = led_indices; + table.led.deflections = led_deflections; + table.map.height = MAP_HEIGHT; + table.map.width = MAP_WIDTH; + table.map.matrix = (unsigned int *)matrix_map; + + SetupData(controller_ptr); + SetupModes(); + SetupZones(); +} diff --git a/Controllers/LightSaltController/RGBController_LightSaltKeyboard.h b/Controllers/LightSaltController/RGBController_LightSaltKeyboard.h new file mode 100644 index 00000000..9b111cbe --- /dev/null +++ b/Controllers/LightSaltController/RGBController_LightSaltKeyboard.h @@ -0,0 +1,20 @@ +/*---------------------------------------------------------*\ +| RGBController_LightSaltKeyboard.h | +| | +| RGBController for LightSalt Keyboard | +| | +| James Buren (braewoods) 23 Jul 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#pragma once + +#include "RGBController_LightSalt.h" + +class RGBController_LightSaltKeyboard : public RGBController_LightSalt +{ +public: + RGBController_LightSaltKeyboard(LightSaltController* controller_ptr); +}; diff --git a/Controllers/LightSaltController/RGBController_LightSaltKeypad.cpp b/Controllers/LightSaltController/RGBController_LightSaltKeypad.cpp new file mode 100644 index 00000000..dae7f5cb --- /dev/null +++ b/Controllers/LightSaltController/RGBController_LightSaltKeypad.cpp @@ -0,0 +1,131 @@ +/*---------------------------------------------------------*\ +| RGBController_LightSaltKeypad.cpp | +| | +| RGBController for LightSalt Keypad | +| | +| James Buren (braewoods) 23 Jul 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#include "RGBControllerKeyNames.h" +#include "RGBController_LightSaltKeypad.h" + +// 0xFFFFFFFF indicates an unused entry in matrix +#define NA 0xFFFFFFFF + +enum +{ + LED_SETS = 1, + LED_ROWS = 5, + LED_COLUMNS = 10, + LED_COUNT = 18, + MAP_HEIGHT = 5, + MAP_WIDTH = 4 +}; + +static char const * const led_names[LED_COUNT] = +{ + /* Row 1 */ + KEY_EN_TAB, + KEY_EN_NUMPAD_DIVIDE, + KEY_EN_NUMPAD_TIMES, + KEY_EN_BACKSPACE, + + /* Row 2 */ + KEY_EN_NUMPAD_7, + KEY_EN_NUMPAD_8, + KEY_EN_NUMPAD_9, + KEY_EN_NUMPAD_MINUS, + + /* Row 3 */ + KEY_EN_NUMPAD_4, + KEY_EN_NUMPAD_5, + KEY_EN_NUMPAD_6, + KEY_EN_PLUS, + + /* Row 4 */ + KEY_EN_NUMPAD_1, + KEY_EN_NUMPAD_2, + KEY_EN_NUMPAD_3, + + /* Row 5 */ + KEY_EN_NUMPAD_0, + KEY_EN_NUMPAD_PERIOD, + KEY_EN_NUMPAD_ENTER +}; + +static const int led_indices[LED_COUNT] = +{ + /* Row 1 */ + 0, 1, 2, 3, + + /* Row 2 */ + 4, 5, 6, 7, + + /* Row 3 */ + 8, 9, 10, 11, + + /* Row 4 */ + 12, 13, 14, + + /* Row 5 */ + 16, 17, 18 +}; + +static const int led_deflections[LED_COUNT] = +{ + /* Row 1 */ + 0x0, 0x0, 0x0, 0x0, + + /* Row 2 */ + 0x0, 0x0, 0x0, 0x0, + + /* Row 3 */ + 0x0, 0x0, 0x0, 0x0, + + /* Row 4 */ + 0x0, 0x0, 0x0, + + /* Row 5 */ + 0x0, 0x0, 0x0 +}; + +static const unsigned int matrix_map[MAP_HEIGHT][MAP_WIDTH] = +{ + /* Row 1 */ + { 0, 1 , 2, 3}, + + /* Row 2 */ + { 4, 5, 6, 7}, + + /* Row 3 */ + { 8, 9, 10, 11}, + + /* Row 4 */ + {12, 13, 14, NA}, + + /* Row 5 */ + {15, NA, 16, 17} +}; + +RGBController_LightSaltKeypad::RGBController_LightSaltKeypad(LightSaltController* controller_ptr) +{ + table.device.name = "Keypad"; + table.device.type = DEVICE_TYPE_KEYPAD; + table.led.sets = LED_SETS; + table.led.rows = LED_ROWS; + table.led.columns = LED_COLUMNS; + table.led.count = LED_COUNT; + table.led.names = led_names; + table.led.indices = led_indices; + table.led.deflections = led_deflections; + table.map.height = MAP_HEIGHT; + table.map.width = MAP_WIDTH; + table.map.matrix = (unsigned int *)matrix_map; + + SetupData(controller_ptr); + SetupModes(); + SetupZones(); +} diff --git a/Controllers/LightSaltController/RGBController_LightSaltKeypad.h b/Controllers/LightSaltController/RGBController_LightSaltKeypad.h new file mode 100644 index 00000000..73a48aa1 --- /dev/null +++ b/Controllers/LightSaltController/RGBController_LightSaltKeypad.h @@ -0,0 +1,20 @@ +/*---------------------------------------------------------*\ +| RGBController_LightSaltKeypad.h | +| | +| RGBController for LightSalt Keypad | +| | +| James Buren (braewoods) 23 Jul 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#pragma once + +#include "RGBController_LightSalt.h" + +class RGBController_LightSaltKeypad : public RGBController_LightSalt +{ +public: + RGBController_LightSaltKeypad(LightSaltController* controller_ptr); +};