Jens/LumaOps-Public
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Publish LumaOps source

Browse Source
This commit is contained in:
LumaOps release export
2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Controllers/MSIMysticLightController/MSIMysticLight162Controller/MSIMysticLight162Controller.cpp
+452
View File
@@ -0,0 +1,452 @@
/*---------------------------------------------------------*\
| MSIMysticLight162Controller.cpp |
| |
| Driver for MSI Mystic Light 162-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <algorithm>
#include <array>
#include <bitset>
#include "MSIMysticLight162Controller.h"
#include "StringUtils.h"
#define BITSET(val, bit, pos) ((unsigned char)std::bitset<8>(val).set((pos), (bit)).to_ulong())
struct mystic_light_162_config
{
unsigned short pid; // PID of the board
size_t numof_onboard_leds; // number of onboard leds
const std::vector<MSI_ZONE>* supported_zones; // pointer to vector of supported zones
};
const std::vector<MSI_ZONE> zones_set0 =
{
MSI_ZONE_J_RGB_1,
MSI_ZONE_J_RGB_2,
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_J_CORSAIR,
MSI_ZONE_ON_BOARD_LED_0
};
const std::vector<MSI_ZONE> zones_set1 =
{
MSI_ZONE_J_RGB_1,
MSI_ZONE_J_RGB_2,
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_ON_BOARD_LED_0
};
const std::vector<MSI_ZONE> zones_set2 =
{
MSI_ZONE_J_RGB_1,
MSI_ZONE_J_RGB_2,
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_J_RAINBOW_2,
MSI_ZONE_ON_BOARD_LED_0
};
const std::vector<MSI_ZONE> zones_set3 =
{
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_ON_BOARD_LED_0
};
/*-----------------------------------------------------------------------------------------------------------------------------*\
| Definition of the board sepcific configurations (number of onboard LEDs and supported zones). |
| |
| Only tested boards are listed here (refer to MSIMysticLightControllerDetect.cpp). If more boards |
| are tested the list must be extended here. Otherwise the default settings will be used (7 onboard LEDs, all zones supported). |
| Boards with yet unknown supported zones are configured to support all zones. |
\*-----------------------------------------------------------------------------------------------------------------------------*/
#define NUMOF_CONFIGS (sizeof(board_configs) / sizeof(mystic_light_162_config))
static const mystic_light_162_config board_configs[] =
{
{ 0x1720, 10, &zones_set0 }, // MPG Z390 GAMING EDGE AC
{ 0x7B12, 10, &zones_set0 }, // MEG Z390 ACE
{ 0x7B17, 10, &zones_set0 }, // MPG Z390 GAMING PRO CARBON
{ 0x7B18, 6, &zones_set1 }, // MAG Z390 TOMAHAWK
{ 0x7B50, 6, &zones_set2 }, // MPG Z390M GAMING EDGE AC
{ 0x7B85, 7, &zones_set0 }, // B450 GAMING PRO CARBON
{ 0x7B92, 10, &zones_set0 }, // MEG X399 CREATION
{ 0xB926, 3, &zones_set3 }, // MPG B460 TRIDENT AS
};
MSIMysticLight162Controller::MSIMysticLight162Controller
(
hid_device* handle,
const char* path,
unsigned short pid,
std::string dev_name
)
{
dev = handle;
location = path;
name = dev_name;
if(dev)
{
ReadFwVersion();
ReadSettings();
}
/*-----------------------------------------*\
| Initialize save flag |
\*-----------------------------------------*/
data.save_data = 0;
data.on_board_led.colorFlags = 0x81; // force MS bit of color flags to 1 to have expectd zone control
/*-----------------------------------------*\
| Initialize zone based per LED data |
\*-----------------------------------------*/
const mystic_light_162_config* board_config = nullptr;
for(std::size_t i = 0; i < NUMOF_CONFIGS; ++i)
{
if (board_configs[i].pid == pid)
{
board_config = &board_configs[i];
break;
}
}
if(board_config != nullptr)
{
numof_onboard_leds = board_config->numof_onboard_leds;
supported_zones = board_config->supported_zones;
}
else
{
numof_onboard_leds = 10;
supported_zones = &zones_set0;
}
}
MSIMysticLight162Controller::~MSIMysticLight162Controller()
{
hid_close(dev);
}
void MSIMysticLight162Controller::SetMode
(
MSI_ZONE zone,
MSI_MODE mode,
MSI_SPEED speed,
MSI_BRIGHTNESS brightness,
bool rainbow_color
)
{
ZoneData* zone_data = GetZoneData(data, zone);
if(zone_data == nullptr)
{
return;
}
if (zone <= MSI_ZONE_ON_BOARD_LED_0)
{
zone_data->effect = mode;
zone_data->speedAndBrightnessFlags = (brightness << 2) | (speed & 0x03);
zone_data->colorFlags = BITSET(zone_data->colorFlags, !rainbow_color, 7u);
zone_data->padding = 0x00;
if(mode > MSI_MODE_DOUBLE_FLASHING)
{
zone_data->speedAndBrightnessFlags |= SYNC_SETTING_JRGB;
zone_data->colorFlags |= SYNC_SETTING_ONBOARD;
}
else
{
zone_data->speedAndBrightnessFlags &= ~SYNC_SETTING_JRGB;
zone_data->colorFlags &= ~SYNC_SETTING_ONBOARD;
}
}
if((zone >= MSI_ZONE_ON_BOARD_LED_0) && (mode <= MSI_MODE_DOUBLE_FLASHING))
{
zone_data = GetZoneData(data, (MSI_ZONE)((int)zone + 1));
if(zone_data != nullptr)
{
zone_data->effect = mode;
zone_data->speedAndBrightnessFlags = (brightness << 2) | (speed & 0x03);
zone_data->colorFlags = BITSET(zone_data->colorFlags, !rainbow_color, 7u);
zone_data->padding = 0x00;
}
}
}
std::string MSIMysticLight162Controller::GetDeviceName()
{
return name;
}
std::string MSIMysticLight162Controller::GetFWVersion()
{
std::string firmware_version;
firmware_version = "APROM: " + version_APROM + ", LDROM: " + version_LDROM;
return firmware_version;
}
std::string MSIMysticLight162Controller::GetDeviceLocation()
{
return("HID: " + location);
}
std::string MSIMysticLight162Controller::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
bool MSIMysticLight162Controller::ReadSettings()
{
/*-----------------------------------------------------*\
| Read packet from hardware, return true if successful |
\*-----------------------------------------------------*/
return(hid_get_feature_report(dev, (unsigned char*)&data, sizeof(data)) == sizeof data);
}
bool MSIMysticLight162Controller::Update
(
bool save
)
{
/*-----------------------------------------------------*\
| Send packet to hardware, return true if successful |
\*-----------------------------------------------------*/
data.save_data = save;
return (hid_send_feature_report(dev, (unsigned char*)&data, sizeof(data)) == sizeof(data));
}
void MSIMysticLight162Controller::SetZoneColor
(
MSI_ZONE zone,
unsigned char red1,
unsigned char grn1,
unsigned char blu1,
unsigned char red2,
unsigned char grn2,
unsigned char blu2
)
{
ZoneData* zone_data = GetZoneData(data, zone);
if(zone_data == nullptr)
{
return;
}
if (zone <= MSI_ZONE_ON_BOARD_LED_0)
{
zone_data->color.R = red1;
zone_data->color.G = grn1;
zone_data->color.B = blu1;
zone_data->color2.R = red2;
zone_data->color2.G = grn2;
zone_data->color2.B = blu2;
}
if(zone >= MSI_ZONE_ON_BOARD_LED_0)
{
zone_data = GetZoneData(data, (MSI_ZONE)((int)zone + 1));
if(zone_data != nullptr)
{
zone_data->color.R = red1;
zone_data->color.G = grn1;
zone_data->color.B = blu1;
zone_data->color2.R = red2;
zone_data->color2.G = grn2;
zone_data->color2.B = blu2;
}
}
}
ZoneData *MSIMysticLight162Controller::GetZoneData
(
FeaturePacket_162& data_packet,
MSI_ZONE zone
)
{
switch(zone)
{
case MSI_ZONE_J_RGB_1:
return &data_packet.j_rgb_1;
case MSI_ZONE_J_RGB_2:
return &data_packet.j_rgb_2;
case MSI_ZONE_J_RAINBOW_1:
return &data_packet.j_rainbow_1;
case MSI_ZONE_J_RAINBOW_2:
return &data_packet.on_board_led_10;
case MSI_ZONE_ON_BOARD_LED_0:
return &data_packet.on_board_led;
case MSI_ZONE_ON_BOARD_LED_1:
return &data_packet.on_board_led_1;
case MSI_ZONE_ON_BOARD_LED_2:
return &data_packet.on_board_led_2;
case MSI_ZONE_ON_BOARD_LED_3:
return &data_packet.on_board_led_3;
case MSI_ZONE_ON_BOARD_LED_4:
return &data_packet.on_board_led_4;
case MSI_ZONE_ON_BOARD_LED_5:
return &data_packet.on_board_led_5;
case MSI_ZONE_ON_BOARD_LED_6:
return &data_packet.on_board_led_6;
case MSI_ZONE_ON_BOARD_LED_7:
return &data_packet.on_board_led_7;
case MSI_ZONE_ON_BOARD_LED_8:
return &data_packet.on_board_led_8;
case MSI_ZONE_ON_BOARD_LED_9:
return &data_packet.on_board_led_9;
case MSI_ZONE_ON_BOARD_LED_10:
return &data_packet.on_board_led_10;
case MSI_ZONE_J_CORSAIR:
return &data_packet.j_corsair_1;
default:
break;
}
return nullptr;
}
bool MSIMysticLight162Controller::ReadFwVersion()
{
unsigned char request[64];
unsigned char response[64];
int ret_val = 64;
/*-----------------------------------------------------*\
| First read the APROM |
| Checksum also available at report ID 180, with MSB |
| stored at index 0x08 and LSB at 0x09 |
\*-----------------------------------------------------*/
/*-----------------------------------------------------*\
| Zero out buffers |
\*-----------------------------------------------------*/
memset(request, 0x00, sizeof(request));
memset(response, 0x00, sizeof(response));
/*-----------------------------------------------------*\
| Set up APROM Firmware Version Request packet |
\*-----------------------------------------------------*/
request[0x00] = 0x01;
request[0x01] = 0xB0;
/*-----------------------------------------------------*\
| Fill request from 0x02 to 0x61 with 0xCC |
\*-----------------------------------------------------*/
memset(&request[0x02], 0xCC, sizeof(request) - 2);
/*-----------------------------------------------------*\
| Send request and receive response packets |
\*-----------------------------------------------------*/
ret_val &= hid_write(dev, request, 64);
ret_val &= hid_read(dev, response, 64);
/*-----------------------------------------------------*\
| Extract high and low values from response |
\*-----------------------------------------------------*/
unsigned char highValue = response[2] >> 4;
unsigned char lowValue = response[2] & 0x0F;
/*-----------------------------------------------------*\
| Build firmware string <high>.<low> |
\*-----------------------------------------------------*/
version_APROM = std::to_string((int)highValue).append(".").append(std::to_string((int)lowValue));
/*-----------------------------------------------------*\
| First read the LDROM |
| Checksum also available at report ID 184, with MSB |
| stored at index 0x08 and LSB at 0x09 |
\*-----------------------------------------------------*/
/*-----------------------------------------------------*\
| Set up LDROM Firmware Version Request packet |
\*-----------------------------------------------------*/
request[0x00] = 0x01;
request[0x01] = 0xB6;
/*-----------------------------------------------------*\
| Send request and receive response packets |
\*-----------------------------------------------------*/
ret_val &= hid_write(dev, request, 64);
ret_val &= hid_read(dev, response, 64);
/*-----------------------------------------------------*\
| Extract high and low values from response |
\*-----------------------------------------------------*/
highValue = response[2] >> 4;
lowValue = response[2] & 0x0F;
/*-----------------------------------------------------*\
| Build firmware string <high>.<low> |
\*-----------------------------------------------------*/
version_LDROM = std::to_string((int)highValue).append(".").append(std::to_string((int)lowValue));
/*-----------------------------------------------------*\
| If return value is zero it means an HID transfer |
| failed |
\*-----------------------------------------------------*/
return(ret_val > 0);
}
MSI_MODE MSIMysticLight162Controller::GetMode()
{
return (MSI_MODE)data.on_board_led.effect;
}
void MSIMysticLight162Controller::GetMode
(
MSI_ZONE zone,
MSI_MODE &mode,
MSI_SPEED &speed,
MSI_BRIGHTNESS &brightness,
bool &rainbow_color,
unsigned int &color
)
{
/*-----------------------------------------------------*\
| Get data for given zone |
\*-----------------------------------------------------*/
ZoneData *zone_data = GetZoneData(data, zone);
/*-----------------------------------------------------*\
| Return if zone is invalid |
\*-----------------------------------------------------*/
if(zone_data == nullptr)
{
return;
}
/*-----------------------------------------------------*\
| Update pointers with data |
\*-----------------------------------------------------*/
mode = (MSI_MODE)zone_data->effect;
speed = (MSI_SPEED)(zone_data->speedAndBrightnessFlags & 0x03);
brightness = (MSI_BRIGHTNESS)((zone_data->speedAndBrightnessFlags >> 2) & 0x1F);
rainbow_color = (zone_data->colorFlags & 0x80) == 0 ? true : false;
color = ToRGBColor(zone_data->color.R, zone_data->color.G, zone_data->color.B);
}
size_t MSIMysticLight162Controller::GetMaxOnboardLeds()
{
return numof_onboard_leds;
}
Controllers/MSIMysticLightController/MSIMysticLight162Controller/MSIMysticLight162Controller.h
+98
View File
@@ -0,0 +1,98 @@
/*---------------------------------------------------------*\
| MSIMysticLight162Controller.h |
| |
| Driver for MSI Mystic Light 162-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <cstring>
#include <limits>
#include <hidapi.h>
#include "MSIMysticLightCommon.h"
#include "RGBController.h"
class MSIMysticLight162Controller
{
public:
MSIMysticLight162Controller
(
hid_device* handle,
const char* path,
unsigned short pid,
std::string dev_name
);
~MSIMysticLight162Controller();
void SetMode
(
MSI_ZONE zone,
MSI_MODE mode,
MSI_SPEED speed,
MSI_BRIGHTNESS brightness,
bool rainbow_color
);
MSI_MODE GetMode();
void GetMode
(
MSI_ZONE zone,
MSI_MODE &mode,
MSI_SPEED &speed,
MSI_BRIGHTNESS &brightness,
bool &rainbow_color,
unsigned int &color
);
void SetZoneColor
(
MSI_ZONE zone,
unsigned char red1,
unsigned char grn1,
unsigned char blu1,
unsigned char red2,
unsigned char grn2,
unsigned char blu2
);
bool Update
(
bool save
);
std::string GetDeviceName();
std::string GetDeviceLocation();
std::string GetFWVersion();
std::string GetSerial();
size_t GetMaxOnboardLeds();
const std::vector<MSI_ZONE>*
GetSupportedZones() { return supported_zones; }
private:
hid_device* dev;
std::string name;
std::string location;
std::string version_APROM;
std::string version_LDROM;
FeaturePacket_162 data;
size_t numof_onboard_leds;
const std::vector<MSI_ZONE>* supported_zones;
bool ReadSettings();
bool ReadFwVersion();
ZoneData* GetZoneData
(
FeaturePacket_162& dataPacket,
MSI_ZONE zone
);
};
Controllers/MSIMysticLightController/MSIMysticLight162Controller/RGBController_MSIMysticLight162.cpp
+392
View File
@@ -0,0 +1,392 @@
/*---------------------------------------------------------*\
| RGBController_MSIMysticLight162.cpp |
| |
| RGBController for MSI Mystic Light 162-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_MSIMysticLight162.h"
struct ZoneDescription
{
std::string name;
MSI_ZONE zone_type;
};
#define NUMOF_ZONES (sizeof(led_zones) / sizeof(ZoneDescription))
const ZoneDescription led_zones[] =
{
ZoneDescription{ "JRGB1", MSI_ZONE_J_RGB_1 },
ZoneDescription{ "JRGB2", MSI_ZONE_J_RGB_2 },
ZoneDescription{ "JRAINBOW1", MSI_ZONE_J_RAINBOW_1 },
ZoneDescription{ "JRAINBOW2", MSI_ZONE_J_RAINBOW_2 },
ZoneDescription{ "JCORSAIR", MSI_ZONE_J_CORSAIR },
ZoneDescription{ "Onboard LEDs", MSI_ZONE_ON_BOARD_LED_0 }
};
static std::vector<const ZoneDescription*> zone_description;
/**------------------------------------------------------------------*\
@name MSI Mystic Light (162 Byte)
@category Motherboard
@type USB
@save :robot:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectMSIMysticLightControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_MSIMysticLight162::RGBController_MSIMysticLight162
(
MSIMysticLight162Controller* controller_ptr
)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "MSI";
type = DEVICE_TYPE_MOTHERBOARD;
description = "MSI Mystic Light Device (162-byte)";
version = controller->GetFWVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerial();
const std::vector<MSI_ZONE>* supported_zones = controller->GetSupportedZones();
for(std::size_t i = 0; i < supported_zones->size(); ++i)
{
for(std::size_t j = 0; j < NUMOF_ZONES; ++j)
{
if(led_zones[j].zone_type == (*supported_zones)[i])
{
zone_description.push_back(&led_zones[j]);
break;
}
}
}
SetupModes();
SetupZones();
SetupColors();
active_mode = GetDeviceMode();
GetDeviceConfig();
}
RGBController_MSIMysticLight162::~RGBController_MSIMysticLight162()
{
zone_description.clear();
delete controller;
}
int RGBController_MSIMysticLight162::GetDeviceMode()
{
MSI_MODE mode = controller->GetMode();
for(unsigned int i = 0; i < modes.size(); ++i)
{
if(mode == modes[i].value)
{
return i;
}
}
return 0;
}
void RGBController_MSIMysticLight162::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zone_description.size(); ++zone_idx)
{
const ZoneDescription* zd = zone_description[zone_idx];
zone new_zone;
new_zone.name = zd->name;
/*--------------------------------------------------\
| 162-byte MSI does not have resizable zones, but |
| onboard LED zones have multiple LEDs |
\*-------------------------------------------------*/
if(zd->zone_type == MSI_ZONE_ON_BOARD_LED_0)
{
new_zone.leds_max = (int)controller->GetMaxOnboardLeds();
}
else
{
new_zone.leds_max = 1;
}
new_zone.leds_min = new_zone.leds_max;
new_zone.leds_count = new_zone.leds_max;
/*-------------------------------------------------*\
| Determine zone type based on max number of LEDs |
\*-------------------------------------------------*/
if(new_zone.leds_max == 1)
{
new_zone.type = ZONE_TYPE_SINGLE;
}
else
{
new_zone.type = ZONE_TYPE_LINEAR;
}
new_zone.matrix_map = NULL;
zones.push_back(new_zone);
}
/*---------------------------------------------------------*\
| Set up LEDs |
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zone_description.size(); ++zone_idx)
{
for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; ++led_idx)
{
led new_led;
new_led.name = zones[zone_idx].name + " LED ";
if(zones[zone_idx].leds_count > 1)
{
new_led.name.append(std::to_string(led_idx + 1));
}
new_led.value = (unsigned int)(zone_description[zone_idx]->zone_type + led_idx);
leds.push_back(new_led);
}
}
}
void RGBController_MSIMysticLight162::ResizeZone
(
int /*zone*/,
int /*new_size*/
)
{
}
void RGBController_MSIMysticLight162::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); ++zone_idx)
{
for(int led_idx = zones[zone_idx].leds_count - 1; led_idx >= 0; led_idx--)
{
UpdateLed((int)zone_idx, led_idx);
}
}
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight162::UpdateZoneLEDs
(
int zone
)
{
for(int led_idx = zones[zone].leds_count - 1; led_idx >= 0; led_idx--)
{
UpdateLed(zone, led_idx);
}
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight162::UpdateSingleLED
(
int led
)
{
UpdateLed(leds[led].value, led);
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
}
void RGBController_MSIMysticLight162::DeviceUpdateMode()
{
DeviceUpdateLEDs();
}
void RGBController_MSIMysticLight162::DeviceSaveMode()
{
controller->Update(true);
}
void RGBController_MSIMysticLight162::SetupModes()
{
constexpr unsigned int PER_LED_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
constexpr unsigned int RANDOM_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE;
constexpr unsigned int COMMON = RANDOM_ONLY | MODE_FLAG_HAS_PER_LED_COLOR;
SetupMode("Direct", MSI_MODE_STATIC, MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE);
// SetupMode("Off", MSI_MODE_DISABLE, 0);
SetupMode("Breathing", MSI_MODE_BREATHING, PER_LED_ONLY);
SetupMode("Flashing", MSI_MODE_FLASHING, COMMON);
SetupMode("Double flashing", MSI_MODE_DOUBLE_FLASHING, COMMON);
SetupMode("Lightning", MSI_MODE_LIGHTNING, PER_LED_ONLY);
// SetupMode("MSI Marquee", MSI_MODE_MSI_MARQUEE, COMMON);
SetupMode("Meteor", MSI_MODE_METEOR, COMMON);
SetupMode("Stack", MSI_MODE_WATER_DROP, COMMON);
// SetupMode("MSI Rainbow", MSI_MODE_MSI_RAINBOW, RANDOM_ONLY);
// SetupMode("Pop", MSI_MODE_POP, COMMON);
// SetupMode("Rap", MSI_MODE_RAP, COMMON);
// SetupMode("Jazz", MSI_MODE_JAZZ, COMMON);
// SetupMode("Play", MSI_MODE_PLAY, COMMON);
// SetupMode("Movie", MSI_MODE_MOVIE, COMMON);
SetupMode("Rainbow", MSI_MODE_COLOR_RING, COMMON);
SetupMode("Planetary", MSI_MODE_PLANETARY, RANDOM_ONLY);
SetupMode("Double meteor", MSI_MODE_DOUBLE_METEOR, RANDOM_ONLY);
SetupMode("Energy", MSI_MODE_ENERGY, RANDOM_ONLY);
SetupMode("Blink", MSI_MODE_BLINK, COMMON);
SetupMode("Clock", MSI_MODE_CLOCK, RANDOM_ONLY);
SetupMode("Color pulse", MSI_MODE_COLOR_PULSE, COMMON);
SetupMode("Color shift", MSI_MODE_COLOR_SHIFT, RANDOM_ONLY);
SetupMode("Color wave", MSI_MODE_COLOR_WAVE, COMMON);
SetupMode("Marquee", MSI_MODE_MARQUEE, PER_LED_ONLY);
// SetupMode("Rainbow", MSI_MODE_RAINBOW, COMMON);
SetupMode("Rainbow wave", MSI_MODE_RAINBOW_WAVE, RANDOM_ONLY);
SetupMode("Visor", MSI_MODE_VISOR, COMMON);
// SetupMode("JRainbow", MSI_MODE_JRAINBOW, COMMON);
SetupMode("Rainbow flashing", MSI_MODE_RAINBOW_FLASHING, RANDOM_ONLY);
SetupMode("Rainbow double flashing", MSI_MODE_RAINBOW_DOUBLE_FLASHING, RANDOM_ONLY);
// SetupMode("Random", MSI_MODE_RANDOM, COMMON);
// SetupMode("Fan control", MSI_MODE_FAN_CONTROL, COMMON);
// SetupMode("Off 2", MSI_MODE_DISABLE_2, COMMON);
// SetupMode("Color ring flashing", MSI_MODE_COLOR_RING_FLASHING, COMMON);
// SetupMode("Color ring double flashing", MSI_MODE_COLOR_RING_DOUBLE_FLASHING, COMMON);
// SetupMode("Stack", MSI_MODE_STACK, COMMON);
// SetupMode("Corsair Que", MSI_MODE_CORSAIR_QUE, COMMON);
// SetupMode("Fire", MSI_MODE_FIRE, COMMON);
// SetupMode("Lava", MSI_MODE_LAVA, COMMON);
}
void RGBController_MSIMysticLight162::UpdateLed
(
int zone,
int led
)
{
unsigned char red = RGBGetRValue(zones[zone].colors[led]);
unsigned char grn = RGBGetGValue(zones[zone].colors[led]);
unsigned char blu = RGBGetBValue(zones[zone].colors[led]);
bool random = modes[active_mode].color_mode == MODE_COLORS_RANDOM;
MSI_MODE mode = (MSI_MODE)modes[active_mode].value;
MSI_SPEED speed = (MSI_SPEED)modes[active_mode].speed;
MSI_BRIGHTNESS brightness = (MSI_BRIGHTNESS)modes[active_mode].brightness;
controller->SetMode((MSI_ZONE)zones[zone].leds[led].value, mode, speed, brightness, random);
controller->SetZoneColor((MSI_ZONE)zones[zone].leds[led].value, red, grn, blu, red, grn, blu);
}
void RGBController_MSIMysticLight162::SetupMode
(
const char *name,
MSI_MODE mod,
unsigned int flags
)
{
mode Mode;
Mode.name = name;
Mode.value = mod;
Mode.flags = flags;
if(flags & MODE_FLAG_HAS_PER_LED_COLOR)
{
Mode.color_mode = MODE_COLORS_PER_LED;
}
else
{
Mode.color_mode = MODE_COLORS_RANDOM;
}
if(flags & MODE_FLAG_HAS_SPEED)
{
Mode.speed = MSI_SPEED_MEDIUM;
Mode.speed_max = MSI_SPEED_HIGH;
Mode.speed_min = MSI_SPEED_LOW;
}
else
{
/*---------------------------------------------------------*\
| For modes without speed this needs to be set to avoid |
| bad values in the saved profile which in turn corrupts |
| the brightness calculation when loading the profile |
\*---------------------------------------------------------*/
Mode.speed = 0;
Mode.speed_max = 0;
Mode.speed_min = 0;
}
if(flags & MODE_FLAG_HAS_BRIGHTNESS)
{
Mode.brightness = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_max = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_min = MSI_BRIGHTNESS_OFF;
}
else
{
Mode.brightness = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_max = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_min = MSI_BRIGHTNESS_LEVEL_100;
}
modes.push_back(Mode);
}
void RGBController_MSIMysticLight162::GetDeviceConfig()
{
MSI_MODE mode;
MSI_SPEED speed;
MSI_BRIGHTNESS brightness;
bool rainbow;
unsigned int color;
for(size_t i = 0; i < zone_description.size(); ++i)
{
controller->GetMode(zone_description[i]->zone_type, mode, speed, brightness, rainbow, color);
for(size_t j = 0; j < zones[i].leds_count; ++j)
{
zones[i].colors[j] = color;
}
}
controller->GetMode(zone_description[0]->zone_type, mode, speed, brightness, rainbow, color);
for(size_t i = 0; i < modes.size(); ++i)
{
if(mode == modes[i].value)
{
if(modes[i].flags & MODE_FLAG_HAS_SPEED)
{
modes[i].speed = speed;
}
if(modes[i].flags & MODE_FLAG_HAS_BRIGHTNESS)
{
modes[i].brightness = brightness;
}
if(rainbow)
{
if(modes[i].flags & (MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR))
{
if(rainbow)
{
modes[i].color_mode = MODE_COLORS_RANDOM;
}
else
{
modes[i].color_mode = MODE_COLORS_PER_LED;
}
}
}
break;
}
}
}
Controllers/MSIMysticLightController/MSIMysticLight162Controller/RGBController_MSIMysticLight162.h
+52
View File
@@ -0,0 +1,52 @@
/*---------------------------------------------------------*\
| RGBController_MSIMysticLight162.h |
| |
| RGBController for MSI Mystic Light 162-byte motherboard |
| |
| T-bond 03 Apr 2020 |
| Adam Honse 06 Mar 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <vector>
#include "RGBController.h"
#include "MSIMysticLight162Controller.h"
class RGBController_MSIMysticLight162: public RGBController
{
public:
RGBController_MSIMysticLight162(MSIMysticLight162Controller* controller_ptr);
~RGBController_MSIMysticLight162();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
void SetupModes();
void UpdateLed
(
int zone,
int led
);
void SetupMode
(
const char *name,
MSI_MODE mode,
unsigned int flags
);
int GetDeviceMode();
void GetDeviceConfig();
MSIMysticLight162Controller* controller;
};