diff --git a/Controllers/MSIMysticLightController/MSIMysticLight162Controller.cpp b/Controllers/MSIMysticLightController/MSIMysticLight162Controller.cpp index 0d1c12deb..18b87b720 100644 --- a/Controllers/MSIMysticLightController/MSIMysticLight162Controller.cpp +++ b/Controllers/MSIMysticLightController/MSIMysticLight162Controller.cpp @@ -13,78 +13,7 @@ #include #include - -#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* supported_zones; // pointer to vector of supported zones -}; - -const std::vector 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 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 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 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 - { 0xB926, 3, &zones_set3 }, // MPG B460 TRIDENT AS -}; - - -MSIMysticLight162Controller::MSIMysticLight162Controller - ( - hid_device* handle, - const char *path, - unsigned short pid - ) +MSIMysticLight162Controller::MSIMysticLight162Controller(hid_device* handle, const char *path) { dev = handle; @@ -102,64 +31,6 @@ MSIMysticLight162Controller::MSIMysticLight162Controller | 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; - } - - zone_based_per_led_data.j_rgb_1.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2; - zone_based_per_led_data.j_rgb_1.colorFlags = BITSET(zone_based_per_led_data.j_rgb_1.colorFlags, true, 7u); - zone_based_per_led_data.j_rainbow_1.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2; - zone_based_per_led_data.j_rainbow_1.colorFlags = BITSET(zone_based_per_led_data.j_rainbow_1.colorFlags, true, 7u); - zone_based_per_led_data.on_board_led.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2; - zone_based_per_led_data.on_board_led.colorFlags = BITSET(zone_based_per_led_data.on_board_led.colorFlags, true, 7u); - zone_based_per_led_data.on_board_led_1.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2; - zone_based_per_led_data.on_board_led_1.colorFlags = BITSET(zone_based_per_led_data.on_board_led_1.colorFlags, true, 7u); - zone_based_per_led_data.on_board_led_2.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2; - zone_based_per_led_data.on_board_led_2.colorFlags = BITSET(zone_based_per_led_data.on_board_led_2.colorFlags, true, 7u); - zone_based_per_led_data.on_board_led_3.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2; - zone_based_per_led_data.on_board_led_3.colorFlags = BITSET(zone_based_per_led_data.on_board_led_3.colorFlags, true, 7u); - zone_based_per_led_data.on_board_led_4.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2; - zone_based_per_led_data.on_board_led_4.colorFlags = BITSET(zone_based_per_led_data.on_board_led_4.colorFlags, true, 7u); - zone_based_per_led_data.on_board_led_5.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2; - zone_based_per_led_data.on_board_led_5.colorFlags = BITSET(zone_based_per_led_data.on_board_led_5.colorFlags, true, 7u); - zone_based_per_led_data.on_board_led_6.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2 << 2; - zone_based_per_led_data.on_board_led_6.colorFlags = BITSET(zone_based_per_led_data.on_board_led_6.colorFlags, true, 7u); - zone_based_per_led_data.on_board_led_7.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100; - zone_based_per_led_data.on_board_led_7.colorFlags = BITSET(zone_based_per_led_data.on_board_led_7.colorFlags, true, 7u); - zone_based_per_led_data.on_board_led_8.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2; - zone_based_per_led_data.on_board_led_8.colorFlags = BITSET(zone_based_per_led_data.on_board_led_8.colorFlags, true, 7u); - zone_based_per_led_data.on_board_led_9.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2; - zone_based_per_led_data.on_board_led_9.colorFlags = BITSET(zone_based_per_led_data.on_board_led_9.colorFlags, true, 7u); - zone_based_per_led_data.on_board_led_10.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2; - zone_based_per_led_data.on_board_led_10.colorFlags = BITSET(zone_based_per_led_data.on_board_led_9.colorFlags, true, 7u); - zone_based_per_led_data.j_rgb_2.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2; - zone_based_per_led_data.j_rgb_2.colorFlags = BITSET(zone_based_per_led_data.j_rgb_2.colorFlags, true, 7u); - zone_based_per_led_data.save_data = 0; - - direct_mode = false; } MSIMysticLight162Controller::~MSIMysticLight162Controller() @@ -169,51 +40,23 @@ MSIMysticLight162Controller::~MSIMysticLight162Controller() void MSIMysticLight162Controller::SetMode ( - MSI_ZONE zone, - MSI_MODE mode, - MSI_SPEED speed, - MSI_BRIGHTNESS brightness, - bool rainbow_color + 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) + ZoneData* zoneData = GetZoneData(zone); + if(!zoneData) { 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; - } - } + zoneData->effect = mode; + zoneData->speedAndBrightnessFlags = ( brightness << 2 ) | ( speed & 0x03 ); + zoneData->colorFlags = 0x00;// BitSet(zoneData->colorFlags, !rainbow_color, 7u); + zoneData->padding = 0x00; } std::string MSIMysticLight162Controller::GetDeviceName() @@ -243,145 +86,99 @@ bool MSIMysticLight162Controller::ReadSettings() /*-----------------------------------------------------*\ | Read packet from hardware, return true if successful | \*-----------------------------------------------------*/ - return(hid_get_feature_report(dev, (unsigned char*)&data, sizeof(data)) == sizeof data); + return(hid_get_feature_report(dev, (unsigned char *)&data, sizeof(data)) == sizeof data); } -bool MSIMysticLight162Controller::Update - ( - bool save - ) +bool MSIMysticLight162Controller::Update() { /*-----------------------------------------------------*\ | Send packet to hardware, return true if successful | \*-----------------------------------------------------*/ - if(direct_mode) - { - return (hid_send_feature_report(dev, (unsigned char*)&zone_based_per_led_data, sizeof(zone_based_per_led_data)) == sizeof(zone_based_per_led_data)); - } - else - { - data.save_data = save; - return (hid_send_feature_report(dev, (unsigned char*)&data, sizeof(data)) == sizeof(data)); - } + return(hid_send_feature_report(dev, (unsigned char *)&data, sizeof(data)) == sizeof data); } -void MSIMysticLight162Controller::SetZoneColor +void MSIMysticLight162Controller::SetLEDColor ( - MSI_ZONE zone, - unsigned char red1, - unsigned char grn1, - unsigned char blu1, - unsigned char red2, - unsigned char grn2, - unsigned char blu2 + 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); + ZoneData* zoneData = GetZoneData(zone); - if(zone_data == nullptr) + if(!zoneData) { 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; - } + zoneData->color.R = red1; + zoneData->color.G = grn1; + zoneData->color.B = blu1; - 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; - } - } -} - -void MSIMysticLight162Controller::SetLedColor - ( - MSI_ZONE zone, - unsigned char red, - unsigned char grn, - unsigned char blu - ) -{ - if(zone >= MSI_ZONE_ON_BOARD_LED_0) - { - zone = (MSI_ZONE)((int)zone + 1); - } - - ZoneData *zone_data = GetZoneData(zone_based_per_led_data, zone); - - if(zone_data == nullptr) - { - return; - } - - zone_data->color.R = red; - zone_data->color.G = grn; - zone_data->color.B = blu; - zone_data->color2.R = red; - zone_data->color2.G = grn; - zone_data->color2.B = blu; + zoneData->color2.R = red2; + zoneData->color2.G = grn2; + zoneData->color2.B = blu2; } ZoneData *MSIMysticLight162Controller::GetZoneData ( - FeaturePacket_162& data_packet, + MSI_ZONE zone + ) +{ + switch(zone) + { + case MSI_ZONE_J_RGB_1: + return &data.j_rgb_1; + case MSI_ZONE_J_RGB_2: + return &data.j_rgb_2; + case MSI_ZONE_J_RAINBOW_1: + return &data.j_rainbow_1; + case MSI_ZONE_ON_BOARD_LED_0: + return &data.on_board_led; + case MSI_ZONE_ON_BOARD_LED_1: + return &data.on_board_led_1; + case MSI_ZONE_ON_BOARD_LED_2: + return &data.on_board_led_2; + case MSI_ZONE_ON_BOARD_LED_3: + return &data.on_board_led_3; + case MSI_ZONE_ON_BOARD_LED_4: + return &data.on_board_led_4; + case MSI_ZONE_ON_BOARD_LED_5: + return &data.on_board_led_5; + case MSI_ZONE_ON_BOARD_LED_6: + return &data.on_board_led_6; + case MSI_ZONE_ON_BOARD_LED_7: + return &data.on_board_led_7; + case MSI_ZONE_ON_BOARD_LED_8: + return &data.on_board_led_8; + case MSI_ZONE_ON_BOARD_LED_9: + return &data.on_board_led_9; + case MSI_ZONE_J_CORSAIR: + return &data.j_corsair_1; + } + + return nullptr; +} + +RainbowZoneData *MSIMysticLight162Controller::GetRainbowZoneData + ( 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; + case MSI_ZONE_J_RAINBOW_1: + return (RainbowZoneData *)&data.j_rainbow_1; +// case MSI_ZONE_J_RAINBOW_2: +// return &data.j_rainbow_2; + case MSI_ZONE_J_CORSAIR: + default: + return nullptr; } - - return nullptr; } bool MSIMysticLight162Controller::ReadFwVersion() @@ -428,7 +225,7 @@ bool MSIMysticLight162Controller::ReadFwVersion() /*-----------------------------------------------------*\ | Build firmware string . | \*-----------------------------------------------------*/ - version_APROM = std::to_string((int)highValue).append(".").append(std::to_string((int)lowValue)); + version_APROM = std::to_string(static_cast(highValue)).append(".").append(std::to_string(static_cast(lowValue))); /*-----------------------------------------------------*\ | First read the LDROM | @@ -457,7 +254,7 @@ bool MSIMysticLight162Controller::ReadFwVersion() /*-----------------------------------------------------*\ | Build firmware string . | \*-----------------------------------------------------*/ - version_LDROM = std::to_string((int)highValue).append(".").append(std::to_string((int)lowValue)); + version_LDROM = std::to_string(static_cast(highValue)).append(".").append(std::to_string(static_cast(lowValue))); /*-----------------------------------------------------*\ | If return value is zero it means an HID transfer | @@ -509,30 +306,24 @@ void MSIMysticLight162Controller::ReadName() name.append(" ").append(std::string(wname.begin(), wname.end())); } -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 - ) + MSI_ZONE zone, + MSI_MODE &mode, + MSI_SPEED &speed, + MSI_BRIGHTNESS &brightness, + bool &rainbow_color + ) { /*-----------------------------------------------------*\ | Get data for given zone | \*-----------------------------------------------------*/ - ZoneData *zone_data = GetZoneData(data, zone); + ZoneData *zoneData = GetZoneData(zone); /*-----------------------------------------------------*\ | Return if zone is invalid | \*-----------------------------------------------------*/ - if(zone_data == nullptr) + if (!zoneData) { return; } @@ -540,22 +331,18 @@ void MSIMysticLight162Controller::GetMode /*-----------------------------------------------------*\ | 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); + mode = (MSI_MODE)(zoneData->effect); + speed = (MSI_SPEED)(zoneData->speedAndBrightnessFlags & 0x03); + brightness = (MSI_BRIGHTNESS)((zoneData->speedAndBrightnessFlags >> 2) & 0x1F); + rainbow_color = (zoneData->colorFlags & 0x80) >> 7; } -void MSIMysticLight162Controller::SetDirectMode +unsigned char MSIMysticLight162Controller::BitSet ( - bool mode + unsigned char value, + bool bit, + unsigned int position ) { - direct_mode = mode; -} - -size_t MSIMysticLight162Controller::GetMaxOnboardLeds() -{ - return numof_onboard_leds; + return static_cast(std::bitset<8>(value).set(position, bit).to_ulong()); } diff --git a/Controllers/MSIMysticLightController/MSIMysticLight162Controller.h b/Controllers/MSIMysticLightController/MSIMysticLight162Controller.h index d3e5733d7..e7fe01e2c 100644 --- a/Controllers/MSIMysticLightController/MSIMysticLight162Controller.h +++ b/Controllers/MSIMysticLightController/MSIMysticLight162Controller.h @@ -19,12 +19,7 @@ class MSIMysticLight162Controller { public: - MSIMysticLight162Controller - ( - hid_device* handle, - const char *path, - unsigned short pid - ); + MSIMysticLight162Controller(hid_device* handle, const char *path); ~MSIMysticLight162Controller(); void SetMode @@ -36,19 +31,16 @@ public: 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 + bool &rainbow_color ); - void SetZoneColor + void SetLEDColor ( MSI_ZONE zone, unsigned char red1, @@ -59,55 +51,30 @@ public: unsigned char blu2 ); - void SetLedColor - ( - MSI_ZONE zone, - unsigned char red, - unsigned char grn, - unsigned char blu - ); - - bool Update - ( - bool save - ); + bool Update(); std::string GetDeviceName(); std::string GetDeviceLocation(); std::string GetFWVersion(); std::string GetSerial(); - - void SetDirectMode - ( - bool mode - ); - bool IsDirectModeActive() { return direct_mode; } - size_t GetMaxOnboardLeds(); - const std::vector* - GetSupportedZones() { return supported_zones; } - private: bool ReadSettings(); + void SaveOnUpdate(bool send); bool ReadFwVersion(); void ReadSerial(); void ReadName(); - ZoneData* GetZoneData - ( - FeaturePacket_162& dataPacket, - MSI_ZONE zone - ); + ZoneData* GetZoneData(MSI_ZONE zone); + RainbowZoneData* + GetRainbowZoneData(MSI_ZONE zone); + static unsigned char BitSet(unsigned char value, bool bit, unsigned int position); - hid_device* dev; - std::string name; - std::string location; - std::string version_APROM; - std::string version_LDROM; - std::string chip_id; + hid_device* dev; + std::string name; + std::string location; + std::string version_APROM; + std::string version_LDROM; + std::string chip_id; - FeaturePacket_162 data; - FeaturePacket_162 zone_based_per_led_data; - bool direct_mode; - size_t numof_onboard_leds; - const std::vector* supported_zones; + FeaturePacket_162 data; }; diff --git a/Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp b/Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp index c8ee785f7..03ea9973a 100644 --- a/Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp +++ b/Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp @@ -54,7 +54,7 @@ void DetectMSIMysticLightControllers } else if((packet_length >= sizeof(FeaturePacket_162)) && (packet_length <= (sizeof(FeaturePacket_162) + 1))) { - MSIMysticLight162Controller* controller = new MSIMysticLight162Controller(dev, info->path, info->product_id); + MSIMysticLight162Controller* controller = new MSIMysticLight162Controller(dev, info->path); RGBController_MSIMysticLight162* rgb_controller = new RGBController_MSIMysticLight162(controller); rgb_controller->name = "MSI " + dmi.getMainboard(); ResourceManager::get()->RegisterRGBController(rgb_controller); diff --git a/Controllers/MSIMysticLightController/RGBController_MSIMysticLight162.cpp b/Controllers/MSIMysticLightController/RGBController_MSIMysticLight162.cpp index 48df18eae..44c751044 100644 --- a/Controllers/MSIMysticLightController/RGBController_MSIMysticLight162.cpp +++ b/Controllers/MSIMysticLightController/RGBController_MSIMysticLight162.cpp @@ -9,45 +9,71 @@ #include "RGBController_MSIMysticLight162.h" - struct ZoneDescription { - std::string name; - MSI_ZONE zone_type; + std::string name; + const MSI_ZONE* leds; }; -#define NUMOF_ZONES (sizeof(led_zones) / sizeof(ZoneDescription)) - -const ZoneDescription led_zones[] = +static const MSI_ZONE ZoneList_JRGB1[] = { - 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 } + MSI_ZONE_J_RGB_1, + MSI_ZONE_NONE }; +static const MSI_ZONE ZoneList_JRGB2[] = +{ + MSI_ZONE_J_RGB_2, + MSI_ZONE_NONE +}; -static std::vector zone_description; +static const MSI_ZONE ZoneList_JRainbow1[] = +{ + MSI_ZONE_J_RAINBOW_1, + MSI_ZONE_NONE +}; +static const MSI_ZONE ZoneList_JRainbow2[] = +{ + MSI_ZONE_J_RAINBOW_2, + MSI_ZONE_NONE +}; +static const MSI_ZONE ZoneList_JCorsair[] = +{ + MSI_ZONE_J_CORSAIR, + MSI_ZONE_NONE +}; -/**------------------------------------------------------------------*\ - @name MSI Mystic Light (162 Byte) - @category Motherboard - @type USB - @save :robot: - @direct :white_check_mark: - @effects :white_check_mark: - @detectors DetectMSIMysticLightControllers - @comment -\*-------------------------------------------------------------------*/ +static const MSI_ZONE ZoneList_Onboard[] = +{ + MSI_ZONE_ON_BOARD_LED_0, + MSI_ZONE_ON_BOARD_LED_1, + MSI_ZONE_ON_BOARD_LED_2, + MSI_ZONE_ON_BOARD_LED_3, + MSI_ZONE_ON_BOARD_LED_4, + MSI_ZONE_ON_BOARD_LED_5, + MSI_ZONE_ON_BOARD_LED_6, + MSI_ZONE_ON_BOARD_LED_7, + MSI_ZONE_ON_BOARD_LED_8, + MSI_ZONE_ON_BOARD_LED_9, + MSI_ZONE_ON_BOARD_LED_10, + MSI_ZONE_NONE +}; -RGBController_MSIMysticLight162::RGBController_MSIMysticLight162 - ( - MSIMysticLight162Controller* controller_ptr - ) +#define NUM_ZONES (sizeof(led_zones) / sizeof(led_zones[0])) + +static const ZoneDescription led_zones[] = +{ + ZoneDescription{"JRGB1", ZoneList_JRGB1 }, + ZoneDescription{"JRGB2", ZoneList_JRGB2 }, + ZoneDescription{"JRAINBOW1", ZoneList_JRainbow1 }, + ZoneDescription{"JRAINBOW2", ZoneList_JRainbow2 }, + ZoneDescription{"JCORSAIR", ZoneList_JCorsair }, + ZoneDescription{"Onboard LEDs", ZoneList_Onboard }, +}; + +RGBController_MSIMysticLight162::RGBController_MSIMysticLight162(MSIMysticLight162Controller* controller_ptr) { controller = controller_ptr; @@ -59,212 +85,139 @@ RGBController_MSIMysticLight162::RGBController_MSIMysticLight162 location = controller->GetDeviceLocation(); serial = controller->GetSerial(); - const std::vector* 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) + for(std::size_t zone_idx = 0; zone_idx < NUM_ZONES; zone_idx++) { - const ZoneDescription* zd = zone_description[zone_idx]; - + ZoneDescription zd = led_zones[zone_idx]; + zone new_zone; - new_zone.name = zd->name; + unsigned int led_count = 0; - /*--------------------------------------------------\ - | 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) + while(zd.leds[led_count] != MSI_ZONE_NONE) { - new_zone.leds_max = (int)controller->GetMaxOnboardLeds(); - } - else - { - new_zone.leds_max = 1; + led_count++; } - 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.name = zd.name; + new_zone.type = ZONE_TYPE_LINEAR; + new_zone.leds_min = led_count; + new_zone.leds_max = led_count; + new_zone.leds_count = led_count; 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) + /*---------------------------------------------------------*\ + | Set up LEDs | + \*---------------------------------------------------------*/ + for(std::size_t led_idx = 0; led_idx < new_zone.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 = new_zone.name + " LED "; + if(new_zone.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); + new_led.value = zd.leds[led_idx]; + leds.push_back(new_led); } } } -void RGBController_MSIMysticLight162::ResizeZone - ( - int /*zone*/, - int /*new_size*/ - ) +void RGBController_MSIMysticLight162::ResizeZone(int zone, int new_size) { } +void RGBController_MSIMysticLight162::SetCustomMode() +{ + active_mode = 0; +} + void RGBController_MSIMysticLight162::DeviceUpdateLEDs() { - for(std::size_t zone_idx = 0; zone_idx < zones.size(); ++zone_idx) + for(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); + UpdateLed(zone_idx, led_idx); } } - controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0); + controller->Update(); } -void RGBController_MSIMysticLight162::UpdateZoneLEDs - ( - int zone - ) +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); + controller->Update(); } -void RGBController_MSIMysticLight162::UpdateSingleLED - ( - int led - ) +void RGBController_MSIMysticLight162::UpdateSingleLED(int led) { UpdateLed(leds[led].value, led); - controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0); + controller->Update(); } void RGBController_MSIMysticLight162::DeviceUpdateMode() { - if(modes[active_mode].value == MSI_MODE_DIRECT_DUMMY) - { - controller->SetDirectMode(true); - } - else - { - controller->SetDirectMode(false); - 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 RANDOM_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR; constexpr unsigned int COMMON = RANDOM_ONLY | MODE_FLAG_HAS_PER_LED_COLOR; - SetupMode("Direct", MSI_MODE_DIRECT_DUMMY, MODE_FLAG_HAS_PER_LED_COLOR); - SetupMode("Static", 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("Direct", MSI_MODE_STATIC, MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR); + SetupMode("Off", MSI_MODE_DISABLE, 0); + SetupMode("Breathing", MSI_MODE_BREATHING, COMMON); SetupMode("Flashing", MSI_MODE_FLASHING, COMMON); SetupMode("Double flashing", MSI_MODE_DOUBLE_FLASHING, COMMON); - SetupMode("Lightning", MSI_MODE_LIGHTNING, PER_LED_ONLY); + SetupMode("Lightning", MSI_MODE_LIGHTNING, COMMON); // SetupMode("MSI Marquee", MSI_MODE_MSI_MARQUEE, COMMON); - SetupMode("Meteor", MSI_MODE_METEOR, COMMON); - SetupMode("Stack", MSI_MODE_WATER_DROP, COMMON); + // SetupMode("Meteor", MSI_MODE_METEOR, COMMON); + // SetupMode("Water drop", 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("Color ring", MSI_MODE_COLOR_RING, COMMON); + // SetupMode("Planetary", MSI_MODE_PLANETARY, COMMON); + // SetupMode("Double meteor", MSI_MODE_DOUBLE_METEOR, COMMON); + // SetupMode("Energy", MSI_MODE_ENERGY, COMMON); + // SetupMode("Blink", MSI_MODE_BLINK, COMMON); + // SetupMode("Clock", MSI_MODE_CLOCK, COMMON); + // SetupMode("Color pulse", MSI_MODE_COLOR_PULSE, COMMON); + // SetupMode("Color shift", MSI_MODE_COLOR_SHIFT, COMMON); + // SetupMode("Color wave", MSI_MODE_COLOR_WAVE, COMMON); + // SetupMode("Marquee", MSI_MODE_MARQUEE, COMMON); // SetupMode("Rainbow", MSI_MODE_RAINBOW, COMMON); - SetupMode("Rainbow wave", MSI_MODE_RAINBOW_WAVE, RANDOM_ONLY); - SetupMode("Visor", MSI_MODE_VISOR, COMMON); + // SetupMode("Rainbow wave", MSI_MODE_RAINBOW_WAVE, COMMON); + // 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("Rainbow flashing", MSI_MODE_RAINBOW_FLASHING, COMMON); + // SetupMode("Rainbow double flashing", MSI_MODE_RAINBOW_DOUBLE_FLASHING, COMMON); // SetupMode("Random", MSI_MODE_RANDOM, COMMON); // SetupMode("Fan control", MSI_MODE_FAN_CONTROL, COMMON); // SetupMode("Off 2", MSI_MODE_DISABLE_2, COMMON); @@ -276,44 +229,25 @@ void RGBController_MSIMysticLight162::SetupModes() // SetupMode("Lava", MSI_MODE_LAVA, COMMON); } -void RGBController_MSIMysticLight162::UpdateLed - ( - int zone, - int led - ) +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]); - - if(controller->IsDirectModeActive()) - { - controller->SetLedColor((MSI_ZONE)zones[zone].leds[led].value, red, grn, blu); - } - else - { - 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); - } + bool random = modes[active_mode].color_mode == MODE_COLORS_RANDOM; + unsigned char red = RGBGetRValue(zones[zone].colors[led]); + unsigned char grn = RGBGetGValue(zones[zone].colors[led]); + unsigned char blu = RGBGetBValue(zones[zone].colors[led]); + MSI_MODE mode = (MSI_MODE)(modes[active_mode].value); + MSI_SPEED speed = (MSI_SPEED)(modes[active_mode].speed); + + controller->SetMode((MSI_ZONE)zones[zone].leds[led].value, mode, speed, MSI_BRIGHTNESS_LEVEL_100, random); + controller->SetLEDColor((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 - ) +void RGBController_MSIMysticLight162::SetupMode(const char *name, MSI_MODE mod, unsigned int flags) { mode Mode; - Mode.name = name; - Mode.value = mod; - Mode.flags = flags; - + Mode.name = name; + Mode.value = mod; + Mode.flags = flags; if(flags & MODE_FLAG_HAS_PER_LED_COLOR) { Mode.color_mode = MODE_COLORS_PER_LED; @@ -341,69 +275,5 @@ void RGBController_MSIMysticLight162::SetupMode 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; - } - } -} diff --git a/Controllers/MSIMysticLightController/RGBController_MSIMysticLight162.h b/Controllers/MSIMysticLightController/RGBController_MSIMysticLight162.h index dddd4d54f..ae47697b2 100644 --- a/Controllers/MSIMysticLightController/RGBController_MSIMysticLight162.h +++ b/Controllers/MSIMysticLightController/RGBController_MSIMysticLight162.h @@ -19,30 +19,20 @@ public: ~RGBController_MSIMysticLight162(); void SetupZones(); + void ResizeZone(int zone, int new_size); void DeviceUpdateLEDs(); void UpdateZoneLEDs(int zone); void UpdateSingleLED(int led); + void SetCustomMode(); 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(); + void UpdateLed(int zone, int led); + void SetupMode(const char *name, MSI_MODE mode, unsigned int flags); MSIMysticLight162Controller* controller; };