mirror/OpenRGB
1
0 Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-09-13 13:47:02 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
msi_185_debug
OpenRGB/Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.cpp
T

1645 lines
62 KiB
C++
Raw Permalink Blame History

/*---------------------------------------------------------*\
| RGBController_GigabyteRGBFusion2USB.cpp |
| |
| RGBController for Gigabyte Aorus RGB Fusion 2 USB |
| motherboard |
| |
| jackun 08 Jan 2020 |
| megadjc 03 Sep 2026 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <mutex>
#include "GigabyteFusion2USB_Devices.h"
#include "RGBController_GigabyteRGBFusion2USB.h"
#include "ResourceManager.h"
#include "SettingsManager.h"
struct IT5711ZoneCounts
{
uint16_t led10 = 0;
uint16_t led11 = 0;
};
/*---------------------------------------------------------*\
| Sets LED10/11 counts based on firmware series |
\*---------------------------------------------------------*/
static IT5711ZoneCounts GetIT5711ZoneCounts(uint8_t fw_id, uint32_t lid)
{
switch(fw_id)
{
case 0x00:
return {27, 2};
case 0x02:
switch(lid)
{
case 0x013001DF:
return {4, 6};
case 0x015001DF:
return {6, 6};
default:
return {14, 6};
}
case 0x03:
case 0x08:
return {13, 0};
case 0x05:
case 0x0C:
switch(lid)
{
case 0x016001DF:
return {8, 4};
case 0x028001DF:
return {26, 18};
default:
return {16, 4};
}
case 0x06:
case 0x09:
return {12, 0};
default:
return {};
}
}
static void ApplyIT5711ZoneCounts(gb_fusion2_device* layout, uint8_t fw_id, std::vector<gb_fusion2_zone*>& allocated_zones)
{
IT5711ZoneCounts counts = GetIT5711ZoneCounts(fw_id, layout->layout_id);
for(uint8_t zone_idx = 0; zone_idx < GB_FUSION2_ZONES_MAX; ++zone_idx)
{
const gb_fusion2_zone* zone = (*layout->zones)[zone_idx];
if(!zone)
{
continue;
}
uint16_t led_count = 0;
switch(zone->idx)
{
case LED10:
led_count = counts.led10;
break;
case LED11:
led_count = counts.led11;
break;
default:
continue;
}
/*-----------------------------------------------------*\
| A zero count means that no firmware mapping is known |
\*-----------------------------------------------------*/
if(led_count == 0)
{
continue;
}
/*-----------------------------------------------------*\
| Static layouts contain const zone objects, so create |
| a mutable per-instance copy before changing the count |
\*-----------------------------------------------------*/
gb_fusion2_zone* new_zone = new gb_fusion2_zone(*zone);
new_zone->leds_min = led_count;
new_zone->leds_max = led_count;
(*layout->zones)[zone_idx] = new_zone;
allocated_zones.push_back(new_zone);
}
}
/*---------------------------------------------------------*\
| Return the Gen2 scan slot used by a layout header zone |
\*---------------------------------------------------------*/
static int GetGen2HeaderSlot(const gb_fusion2_zone* zone)
{
if(zone == nullptr)
{
return -1;
}
/*-----------------------------------------------------*\
| External ARGB headers are the variable-size zones in |
| the selected controller layout. |
\*-----------------------------------------------------*/
if(zone->leds_min >= zone->leds_max)
{
return -1;
}
switch(zone->idx)
{
case LED4:
case HDR_D_LED2:
return 1;
case HDR_D_LED3:
return 2;
case HDR_D_LED4:
return 3;
default:
return 0;
}
}
/*---------------------------------------------------------*\
| Return the layout zone exposed for a Gen2 scan slot |
\*---------------------------------------------------------*/
static const gb_fusion2_zone* GetGen2HeaderZone(const gb_fusion2_device& layout, int slot, std::size_t available_slots)
{
if(layout.zones == nullptr || slot < 0 || slot >= 4 || static_cast<std::size_t>(slot) >= available_slots)
{
return nullptr;
}
for(uint8_t zone_idx = 0; zone_idx < GB_FUSION2_ZONES_MAX; ++zone_idx)
{
const gb_fusion2_zone* zone = (*layout.zones)[zone_idx];
if(GetGen2HeaderSlot(zone) == slot)
{
return zone;
}
}
return nullptr;
}
/*---------------------------------------------------------*\
| Return the layout zone backed by an ARGB calibration slot |
\*---------------------------------------------------------*/
static const gb_fusion2_zone* GetCalibrationARGBZone(const gb_fusion2_device& layout, int slot)
{
if(layout.zones == nullptr || slot < 0 || slot >= 6)
{
return nullptr;
}
for(uint8_t zone_idx = 0; zone_idx < GB_FUSION2_ZONES_MAX; ++zone_idx)
{
const gb_fusion2_zone* zone = (*layout.zones)[zone_idx];
if(zone == nullptr)
{
continue;
}
if(slot < 4)
{
if(GetGen2HeaderSlot(zone) == slot)
{
return zone;
}
continue;
}
if((slot == 4 && zone->idx == LED10)
|| (slot == 5 && zone->idx == LED11))
{
return zone;
}
}
return nullptr;
}
/*---------------------------------------------------------*\
| Add a boolean device-specific configuration entry |
\*---------------------------------------------------------*/
static void AddDeviceSpecificBool(nlohmann::json& schema, nlohmann::json& config, const char* key, const char* title, const char* description, bool value, int order)
{
schema[key]["title"] = title;
schema[key]["description"] = description;
schema[key]["type"] = "bool";
schema[key]["default"] = false;
schema[key]["order"] = order;
config[key] = value;
}
/*---------------------------------------------------------*\
| Normalize a controller calibration value for the UI |
\*---------------------------------------------------------*/
static std::string NormalizeCalibrationValue(const std::string& value)
{
if(value == "OFF"
|| value == "RGB" || value == "RBG"
|| value == "GRB" || value == "GBR"
|| value == "BRG" || value == "BGR")
{
return value;
}
/*-----------------------------------------------------*\
| Malformed or unavailable controller calibration must |
| never be silently converted to OFF. |
\*-----------------------------------------------------*/
return "INVALID";
}
/*---------------------------------------------------------*\
| Add a calibration device-specific configuration entry |
\*---------------------------------------------------------*/
static void AddCalibrationSetting(nlohmann::json& schema, nlohmann::json& config, const char* key, const char* title, const std::string& value, const std::string& default_value, int order)
{
schema[key]["title"] = title;
schema[key]["description"] = "RGB channel order used by this output. INVALID indicates malformed or unavailable controller calibration and cannot be selected by the user.";
schema[key]["type"] = "string";
schema[key]["default"] = NormalizeCalibrationValue(default_value);
schema[key]["order"] = order;
schema[key]["enum"] = {"OFF", "RGB", "RBG", "GRB", "GBR", "BRG", "BGR", "INVALID"};
config[key] = NormalizeCalibrationValue(value);
}
/**------------------------------------------------------------------*\
@name Gigabyte RGB Fusion 2 USB
@category Motherboard
@type USB
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectGigabyteRGBFusion2USBControllers
@comment The Fusion 2 USB controller applies to most AMD and
Intel mainboards from the X570 and z390 chipsets onwards.
\*-------------------------------------------------------------------*/
RGBController_RGBFusion2USB::RGBController_RGBFusion2USB(RGBFusion2USBController* controller_ptr, std::string detector)
{
controller = controller_ptr;
name = controller->GetDeviceName();
detector_name = detector;
vendor = "Gigabyte";
type = DEVICE_TYPE_MOTHERBOARD;
description = controller->GetDeviceDescription();
version = controller->GetFWVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerial();
product_id = controller->GetProductID();
device_num = controller->GetDeviceNum();
fw_id = controller->GetFWID();
mode Direct;
Direct.name = "Direct";
Direct.value = 0xFFFF;
Direct.flags = MODE_FLAG_HAS_BRIGHTNESS
| MODE_FLAG_HAS_PER_LED_COLOR;
Direct.brightness_min = RGBFUSION2_BRIGHTNESS_MIN;
Direct.brightness_max = RGBFUSION2_BRIGHTNESS_MAX;
Direct.brightness = RGBFUSION2_BRIGHTNESS_MAX;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Static;
Static.name = "Static";
Static.value = EFFECT_STATIC;
Static.flags = MODE_FLAG_HAS_BRIGHTNESS
| MODE_FLAG_HAS_MODE_SPECIFIC_COLOR
| MODE_FLAG_MANUAL_SAVE;
Static.brightness_min = RGBFUSION2_BRIGHTNESS_MIN;
Static.brightness_max = RGBFUSION2_BRIGHTNESS_MAX;
Static.brightness = RGBFUSION2_BRIGHTNESS_MAX;
Static.colors_min = 1;
Static.colors_max = 1;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = EFFECT_PULSE;
Breathing.flags = MODE_FLAG_HAS_BRIGHTNESS
| MODE_FLAG_HAS_SPEED
| MODE_FLAG_HAS_MODE_SPECIFIC_COLOR
| MODE_FLAG_HAS_RANDOM_COLOR
| MODE_FLAG_MANUAL_SAVE;
Breathing.brightness_min = RGBFUSION2_BRIGHTNESS_MIN;
Breathing.brightness_max = 100; // Set 100 max due to controller quirks
Breathing.brightness = Breathing.brightness_max;
Breathing.speed_min = RGBFUSION2_SPEED_MIN;
Breathing.speed_max = RGBFUSION2_SPEED_MAX;
Breathing.speed = RGBFUSION2_SPEED_MID;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode Blinking;
Blinking.name = "Flashing";
Blinking.value = EFFECT_BLINKING;
Blinking.flags = MODE_FLAG_HAS_BRIGHTNESS
| MODE_FLAG_HAS_SPEED
| MODE_FLAG_HAS_MODE_SPECIFIC_COLOR
| MODE_FLAG_HAS_RANDOM_COLOR
| MODE_FLAG_MANUAL_SAVE;
Blinking.brightness_min = RGBFUSION2_BRIGHTNESS_MIN;
Blinking.brightness_max = RGBFUSION2_BRIGHTNESS_MAX;
Blinking.brightness = RGBFUSION2_BRIGHTNESS_MAX;
Blinking.speed_min = RGBFUSION2_SPEED_MIN;
Blinking.speed_max = RGBFUSION2_SPEED_MAX;
Blinking.speed = RGBFUSION2_SPEED_MID;
Blinking.colors_min = 1;
Blinking.colors_max = 1;
Blinking.color_mode = MODE_COLORS_MODE_SPECIFIC;
Blinking.colors.resize(1);
modes.push_back(Blinking);
mode ColorCycle;
ColorCycle.name = "Color Cycle";
ColorCycle.value = EFFECT_COLORCYCLE;
ColorCycle.flags = MODE_FLAG_HAS_BRIGHTNESS
| MODE_FLAG_HAS_SPEED
| MODE_FLAG_MANUAL_SAVE;
ColorCycle.brightness_min = RGBFUSION2_BRIGHTNESS_MIN;
ColorCycle.brightness_max = RGBFUSION2_BRIGHTNESS_MAX;
ColorCycle.brightness = RGBFUSION2_BRIGHTNESS_MAX;
ColorCycle.speed_min = RGBFUSION2_SPEED_MIN;
ColorCycle.speed_max = RGBFUSION2_SPEED_MAX;
ColorCycle.speed = RGBFUSION2_SPEED_MID;
ColorCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(ColorCycle);
mode Flashing;
Flashing.name = "Double Flash";
Flashing.value = EFFECT_DFLASH;
Flashing.flags = MODE_FLAG_HAS_BRIGHTNESS
| MODE_FLAG_HAS_SPEED
| MODE_FLAG_HAS_MODE_SPECIFIC_COLOR
| MODE_FLAG_HAS_RANDOM_COLOR
| MODE_FLAG_MANUAL_SAVE;
Flashing.brightness_min = RGBFUSION2_BRIGHTNESS_MIN;
Flashing.brightness_max = RGBFUSION2_BRIGHTNESS_MAX;
Flashing.brightness = RGBFUSION2_BRIGHTNESS_MAX;
Flashing.speed_min = RGBFUSION2_SPEED_MIN;
Flashing.speed_max = RGBFUSION2_SPEED_MAX;
Flashing.speed = RGBFUSION2_SPEED_MID;
Flashing.colors_min = 1;
Flashing.colors_max = 1;
Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Flashing.colors.resize(1);
modes.push_back(Flashing);
mode Wave;
Wave.name = "Wave";
Wave.value = EFFECT_WAVE;
Wave.flags = MODE_FLAG_HAS_BRIGHTNESS
| MODE_FLAG_HAS_SPEED
| MODE_FLAG_REQUIRES_ENTIRE_DEVICE
| MODE_FLAG_MANUAL_SAVE;
Wave.brightness_min = RGBFUSION2_BRIGHTNESS_MIN;
Wave.brightness_max = RGBFUSION2_BRIGHTNESS_MAX;
Wave.brightness = RGBFUSION2_BRIGHTNESS_MAX;
Wave.speed_min = RGBFUSION2_SPEED_MIN;
Wave.speed_max = RGBFUSION2_SPEED_MAX;
Wave.speed = RGBFUSION2_SPEED_MID;
Wave.colors_min = 0;
Wave.colors_max = 0;
Wave.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave);
mode Random;
Random.name = "Random";
Random.value = EFFECT_RANDOM;
Random.flags = MODE_FLAG_HAS_BRIGHTNESS
| MODE_FLAG_MANUAL_SAVE;
Random.brightness_min = RGBFUSION2_BRIGHTNESS_MIN;
Random.brightness_max = RGBFUSION2_BRIGHTNESS_MAX;
Random.brightness = RGBFUSION2_BRIGHTNESS_MAX;
Random.colors_min = 0;
Random.colors_max = 0;
Random.color_mode = MODE_COLORS_NONE;
modes.push_back(Random);
mode Wave1;
Wave1.name = "Wave 1";
Wave1.value = EFFECT_WAVE1;
Wave1.flags = MODE_FLAG_HAS_BRIGHTNESS
| MODE_FLAG_REQUIRES_ENTIRE_DEVICE
| MODE_FLAG_MANUAL_SAVE;
Wave1.brightness_min = RGBFUSION2_BRIGHTNESS_MIN;
Wave1.brightness_max = RGBFUSION2_BRIGHTNESS_MAX;
Wave1.brightness = RGBFUSION2_BRIGHTNESS_MAX;
Wave1.colors_min = 0;
Wave1.colors_max = 0;
Wave1.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave1);
mode Wave2;
Wave2.name = "Wave 2";
Wave2.value = EFFECT_WAVE2;
Wave2.flags = MODE_FLAG_HAS_BRIGHTNESS
| MODE_FLAG_REQUIRES_ENTIRE_DEVICE
| MODE_FLAG_MANUAL_SAVE;
Wave2.brightness_min = RGBFUSION2_BRIGHTNESS_MIN;
Wave2.brightness_max = RGBFUSION2_BRIGHTNESS_MAX;
Wave2.brightness = RGBFUSION2_BRIGHTNESS_MAX;
Wave2.colors_min = 0;
Wave2.colors_max = 0;
Wave2.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave2);
mode Wave3;
Wave3.name = "Wave 3";
Wave3.value = EFFECT_WAVE3;
Wave3.flags = MODE_FLAG_HAS_BRIGHTNESS
| MODE_FLAG_REQUIRES_ENTIRE_DEVICE
| MODE_FLAG_MANUAL_SAVE;
Wave3.brightness_min = RGBFUSION2_BRIGHTNESS_MIN;
Wave3.brightness_max = RGBFUSION2_BRIGHTNESS_MAX;
Wave3.brightness = RGBFUSION2_BRIGHTNESS_MAX;
Wave3.colors_min = 0;
Wave3.colors_max = 0;
Wave3.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave3);
mode Wave4;
Wave4.name = "Wave 4";
Wave4.value = EFFECT_WAVE4;
Wave4.flags = MODE_FLAG_HAS_BRIGHTNESS
| MODE_FLAG_REQUIRES_ENTIRE_DEVICE
| MODE_FLAG_MANUAL_SAVE;
Wave4.brightness_min = RGBFUSION2_BRIGHTNESS_MIN;
Wave4.brightness_max = RGBFUSION2_BRIGHTNESS_MAX;
Wave4.brightness = RGBFUSION2_BRIGHTNESS_MAX;
Wave4.colors_min = 0;
Wave4.colors_max = 0;
Wave4.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave4);
if(!controller->SupportsSetPersistentLighting())
{
for(unsigned int mode_idx = 0; mode_idx < modes.size(); mode_idx++)
{
modes[mode_idx].flags &= ~MODE_FLAG_MANUAL_SAVE;
}
}
Init_Controller();
SetupZones();
}
RGBController_RGBFusion2USB::~RGBController_RGBFusion2USB()
{
// Free any zones we allocated for the per-instance layout
for(gb_fusion2_zone* z : allocated_zones)
{
delete z;
}
allocated_zones.clear();
Shutdown();
if(persist_lighting_on_exit && active_mode >= 0
&& active_mode < static_cast<int>(modes.size())
&& (modes[active_mode].flags & MODE_FLAG_MANUAL_SAVE))
{
DeviceSaveMode();
}
delete controller;
}
/*---------------------------------------------------------*\
| Initialize controller layout and device-specific settings |
\*---------------------------------------------------------*/
void RGBController_RGBFusion2USB::Init_Controller()
{
const gb_fusion2_device* src_layout = gb_fusion2_device_list[device_index];
/*---------------------------------------------------------*\
| Select controller-specific generic fallback layout |
\*---------------------------------------------------------*/
if(device_num == 1)
{
switch(product_id)
{
break;
case 0x5711:
src_layout = gb_fusion2_device_list[device_index + 4];
break;
default:
src_layout = gb_fusion2_device_list[device_index + 1];
break;
}
}
else
{
switch(product_id)
{
case 0x8950:
src_layout = gb_fusion2_device_list[device_index + 2];
break;
case 0x5711:
src_layout = gb_fusion2_device_list[device_index + 3];
break;
case 0xa100:
src_layout = gb_fusion2_device_list[device_index + 5];
break;
default:
break;
}
}
/*---------------------------------------------------------------------*\
| When no match found the first entry (generic_device) will be used |
| otherwise look up channel map based on device name |
\*---------------------------------------------------------------------*/
/*-----------------------------------------------------------------*\
| Loop through all known devices to look for a name match |
| NB: Can be switched to device IDs lookup when acpi table |
| is able to be probed accurately |
\*-----------------------------------------------------------------*/
for(unsigned int i = 0; i < GB_FUSION2_DEVICE_COUNT; i++)
{
if(gb_fusion2_device_list[i]->name == name &&
gb_fusion2_device_list[i]->device_num == device_num)
{
/*---------------------------------------------------------*\
| Set device ID |
\*---------------------------------------------------------*/
device_index = i;
src_layout = gb_fusion2_device_list[i];
break;
}
}
/*---------------------------------------------------------------------*\
| Creates per instance copy of layouts. |
\*---------------------------------------------------------------------*/
instance_layout.zones = &instance_zones;
instance_layout.layout_id = src_layout->layout_id;
instance_layout.device_num = src_layout->device_num;
instance_layout.name = src_layout->name;
for(uint8_t zi = 0; zi < GB_FUSION2_ZONES_MAX; ++zi)
{
(*instance_layout.zones)[zi] = (*src_layout->zones)[zi];
}
/*---------------------------------------------------------*\
| Apply physical onboard ARGB LED counts for IT5711 |
\*---------------------------------------------------------*/
if(product_id == 0x5711)
{
ApplyIT5711ZoneCounts(&instance_layout, fw_id, allocated_zones);
}
/*---------------------------------------------------------*\
| Device-specific settings depend on the resolved layout. |
\*---------------------------------------------------------*/
InitDeviceSpecificConfiguration();
ApplyDeviceSpecificConfiguration(false);
/*---------------------------------------------------------------------*\
| Culls the mode support based on layout_id. |
\*---------------------------------------------------------------------*/
uint32_t effect_mask = instance_layout.layout_id & GB_EFF_CORE_MASK;
modes.erase(std::remove_if(modes.begin(), modes.end(),
[effect_mask](const mode& m)
{
if(m.value == 0xFFFF /* Direct */) { return false; }
if(m.value == EFFECT_STATIC) { return false; }
uint32_t bit = 0u;
switch(m.value)
{
case EFFECT_PULSE: bit = GB_EFF_BREATH; break;
case EFFECT_COLORCYCLE: bit = GB_EFF_CYCLE; break;
case EFFECT_BLINKING: bit = GB_EFF_FLASH; break;
case EFFECT_RANDOM: bit = GB_EFF_RANDOM; break;
case EFFECT_WAVE: bit = GB_EFF_WAVE; break;
case EFFECT_DFLASH: bit = GB_EFF_DFLASH; break;
case EFFECT_WAVE1: bit = GB_EFF_WAVE1; break;
case EFFECT_WAVE2: bit = GB_EFF_WAVE2; break;
case EFFECT_WAVE3: bit = GB_EFF_WAVE1; break;
case EFFECT_WAVE4: bit = GB_EFF_WAVE2; break;
default: bit = 0u; break;
}
return (bit == 0u) || ((effect_mask & bit) == 0u);
}),
modes.end());
}
/*---------------------------------------------------------*\
| Build device-specific configuration schema and defaults |
\*---------------------------------------------------------*/
void RGBController_RGBFusion2USB::InitDeviceSpecificConfiguration()
{
nlohmann::json configuration_json;
configuration_json["schema"] = nlohmann::json::object();
configuration_json["configuration"] = nlohmann::json::object();
nlohmann::json& schema = configuration_json["schema"];
nlohmann::json& config = configuration_json["configuration"];
/*---------------------------------------------------------*\
| Remove obsolete detector-wide settings. Device-specific |
| settings now live in Configuration.json. |
\*---------------------------------------------------------*/
static std::mutex legacy_cleanup_mutex;
static bool legacy_cleanup_done = false;
{
std::lock_guard<std::mutex> lock(legacy_cleanup_mutex);
if(!legacy_cleanup_done)
{
SettingsManager* settings_manager = ResourceManager::get()->GetSettingsManager();
nlohmann::json stored_settings = settings_manager->GetSettings(detector_name);
if(stored_settings.is_object())
{
bool settings_changed = false;
for(const char* section :
{"Gigabyte-Gen2-ARGB", "PersistLightingOnExit", "Calibration",
"MotherboardLayouts", "CustomLayout", "CustomLayout0", "CustomLayout1"})
{
if(stored_settings.contains(section))
{
stored_settings.erase(section);
settings_changed = true;
}
}
if(settings_changed)
{
settings_manager->SetSettings(detector_name, stored_settings);
settings_manager->SaveSettings();
}
}
legacy_cleanup_done = true;
}
}
/*---------------------------------------------------------*\
| Gen2 ARGB header settings |
\*---------------------------------------------------------*/
if(controller->SupportsGen2())
{
static const char* config_keys[4] =
{
"gen2_d_led1",
"gen2_d_led2",
"gen2_d_led3",
"gen2_d_led4"
};
std::size_t available_slots = controller->ExportGen2Strips().size();
for(int slot = 0; slot < 4; ++slot)
{
const gb_fusion2_zone* header_zone =
GetGen2HeaderZone(instance_layout, slot, available_slots);
if(header_zone == nullptr)
{
continue;
}
std::string title = "Gen2 ARGB - " + header_zone->name;
AddDeviceSpecificBool(schema, config, config_keys[slot], title.c_str(),
"Automatically detect Gen2 ARGB devices on this header",
false, 10 + slot);
}
}
/*---------------------------------------------------------*\
| Persistent lighting on controller teardown |
\*---------------------------------------------------------*/
if(controller->SupportsSetPersistentLighting())
{
AddDeviceSpecificBool(schema, config, "persist_lighting_on_exit", "Persist Lighting on Exit",
"Save the current hardware lighting state to flash when OpenRGB closes",
false, 20);
}
/*---------------------------------------------------------*\
| RGB calibration |
\*---------------------------------------------------------*/
if(device_num == 0 || product_id != 0xa100)
{
EncodedCalibration hw_cal = controller->GetCalibration(false);
AddDeviceSpecificBool(schema, config, "calibration_enabled", "Override RGB Calibration",
"Apply the selected RGB channel orders to the controller calibration. Disabling this setting does not restore an earlier calibration.",
false, 30);
static const char* calibration_keys[6] =
{
"calibration_d_led1",
"calibration_d_led2",
"calibration_d_led3",
"calibration_d_led4",
"calibration_onboard1_argb",
"calibration_onboard2_argb"
};
int calibration_slots = product_id == 0x5711 ? 6 : 2;
for(int slot = 0; slot < calibration_slots; ++slot)
{
const gb_fusion2_zone* calibration_zone =
GetCalibrationARGBZone(instance_layout, slot);
if(calibration_zone == nullptr)
{
continue;
}
std::string title = calibration_zone->name + " Color Order";
AddCalibrationSetting(schema, config, calibration_keys[slot], title.c_str(),
hw_cal.dled[slot], hw_cal.dled[slot],
31 + slot);
}
AddCalibrationSetting(schema, config, "calibration_mainboard", "LED_C(x) Color Order",
hw_cal.mainboard, hw_cal.mainboard, 37);
}
if(!schema.empty())
{
flags |= CONTROLLER_FLAG_MANUALLY_CONFIGURABLE_DEVICE_SPECIFIC;
}
configuration = configuration_json.dump();
}
/*---------------------------------------------------------*\
| Apply device-specific configuration |
\*---------------------------------------------------------*/
void RGBController_RGBFusion2USB::ApplyDeviceSpecificConfiguration(bool setup_zones)
{
nlohmann::json configuration_json;
try
{
configuration_json = nlohmann::json::parse(configuration);
}
catch(...)
{
return;
}
if(!configuration_json.contains("configuration") || !configuration_json["configuration"].is_object())
{
return;
}
const nlohmann::json& config = configuration_json["configuration"];
bool gen2_changed = false;
/*---------------------------------------------------------*\
| Gen2 ARGB header settings |
\*---------------------------------------------------------*/
if(controller->SupportsGen2())
{
static const char* config_keys[4] =
{
"gen2_d_led1",
"gen2_d_led2",
"gen2_d_led3",
"gen2_d_led4"
};
std::size_t available_slots = controller->ExportGen2Strips().size();
uint8_t enabled_headers = 0;
for(int slot = 0; slot < 4; ++slot)
{
if(GetGen2HeaderZone(instance_layout, slot, available_slots) == nullptr)
{
continue;
}
if(config.value(config_keys[slot], false))
{
enabled_headers |= 1U << slot;
}
}
if(enabled_headers != gen2_enabled_headers)
{
controller->ScanGen2Strips(enabled_headers);
gen2_enabled_headers = enabled_headers;
gen2_changed = true;
}
supports_gen2 = enabled_headers != 0;
}
else
{
supports_gen2 = false;
}
/*---------------------------------------------------------*\
| Persistent lighting on controller teardown |
\*---------------------------------------------------------*/
persist_lighting_on_exit = controller->SupportsSetPersistentLighting()
&& config.value("persist_lighting_on_exit", false);
/*---------------------------------------------------------*\
| RGB calibration |
\*---------------------------------------------------------*/
if(config.value("calibration_enabled", false))
{
/*-----------------------------------------------------*\
| Preserve calibration values for channels that are not |
| exposed by the selected motherboard layout. |
\*-----------------------------------------------------*/
EncodedCalibration desired = controller->GetCalibration(false);
static const char* calibration_keys[6] =
{
"calibration_d_led1",
"calibration_d_led2",
"calibration_d_led3",
"calibration_d_led4",
"calibration_onboard1_argb",
"calibration_onboard2_argb"
};
int calibration_slots = product_id == 0x5711 ? 6 : 2;
for(int slot = 0; slot < calibration_slots; ++slot)
{
if(GetCalibrationARGBZone(instance_layout, slot) == nullptr)
{
continue;
}
if(config.contains(calibration_keys[slot])
&& config[calibration_keys[slot]].is_string())
{
desired.dled[slot] = config[calibration_keys[slot]].get<std::string>();
}
}
if(config.contains("calibration_mainboard")
&& config["calibration_mainboard"].is_string())
{
desired.mainboard = config["calibration_mainboard"].get<std::string>();
}
controller->SetCalibration(desired, false);
}
if(setup_zones && gen2_changed)
{
SetupZones();
}
}
void RGBController_RGBFusion2USB::SetupZones()
{
/*-----------------------------------------------------*\
| Only set LED count on the first run |
\*-----------------------------------------------------*/
bool first_run = false;
if(zones.size() == 0)
{
first_run = true;
}
/*-----------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-----------------------------------------------------*/
leds.clear();
colors.clear();
/*-----------------------------------------------------*\
| Count number of zones to resize zones vector |
\*-----------------------------------------------------*/
unsigned int num_zones;
for(num_zones = 0; num_zones < GB_FUSION2_ZONES_MAX; num_zones++)
{
if(!(*instance_layout.zones)[num_zones])
{
break;
}
}
zones.resize(num_zones);
unsigned int d1 = 0, d2 = 0, d3 = 0, d4 = 0, d5 = 0, d6 =0;
/*-----------------------------------------------------*\
| Retrieve the latest Gen2 scan results |
\*-----------------------------------------------------*/
std::vector<Gen2StripInfo> strips;
if(supports_gen2)
{
strips = controller->ExportGen2Strips();
}
/*-----------------------------------------------------*\
| Set up zones |
\*-----------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
const gb_fusion2_zone* zone_at_idx = (*instance_layout.zones)[zone_idx];
if(!zone_at_idx)
{
continue;
}
bool fixed_zone = (zone_at_idx->leds_min == 1 && zone_at_idx->leds_max == 1);
const Gen2StripInfo* gen2_info = nullptr;
int gen2_slot = GetGen2HeaderSlot(zone_at_idx);
/*-------------------------------------------------*\
| Locate the Gen2 result corresponding to this zone |
\*-------------------------------------------------*/
if(supports_gen2 && !fixed_zone && gen2_slot >= 0)
{
unsigned int slot = static_cast<unsigned int>(gen2_slot);
if(slot < strips.size() && strips[slot].totalLeds > 0)
{
gen2_info = &strips[slot];
}
}
/*-------------------------------------------------*\
| Automatically detected Gen2 ARGB zone |
\*-------------------------------------------------*/
if(gen2_info != nullptr)
{
bool preserve_segments = false;
/*---------------------------------------------*\
| A saved segment configuration may only rename |
| or subdivide each detected physical strip. |
\*---------------------------------------------*/
if(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SEGMENTS)
{
bool valid_segments = true;
std::size_t segment_idx = 0;
for(std::size_t strip_idx = 0; strip_idx < gen2_info->LedsOfStrip.size(); strip_idx++)
{
unsigned int strip_leds = gen2_info->LedsOfStrip[strip_idx];
/*-------------------------------------*\
| Require one group for this strip |
\*-------------------------------------*/
if(segment_idx >= zones[zone_idx].segments.size())
{
valid_segments = false;
break;
}
if(!(zones[zone_idx].segments[segment_idx].flags & SEGMENT_FLAG_GROUP_START))
{
valid_segments = false;
break;
}
segment_idx++;
/*-------------------------------------*\
| Validate subdivisions of this strip |
\*-------------------------------------*/
unsigned int member_leds = 0;
bool found_member = false;
while(segment_idx < zones[zone_idx].segments.size())
{
const segment& member = zones[zone_idx].segments[segment_idx];
if(member.flags & SEGMENT_FLAG_GROUP_START)
{
break;
}
if(!(member.flags & SEGMENT_FLAG_GROUP_MEMBER)
|| member.type != ZONE_TYPE_LINEAR
|| member.leds_count == 0)
{
valid_segments = false;
break;
}
member_leds += member.leds_count;
if(member_leds > strip_leds)
{
valid_segments = false;
break;
}
found_member = true;
segment_idx++;
}
if(!valid_segments)
{
break;
}
if(!found_member || member_leds != strip_leds)
{
valid_segments = false;
break;
}
}
if(segment_idx != zones[zone_idx].segments.size())
{
valid_segments = false;
}
preserve_segments = valid_segments;
}
/*---------------------------------------------*\
| Gen2 scan controls all zone-level geometry |
\*---------------------------------------------*/
zones[zone_idx].name = zone_at_idx->name;
zones[zone_idx].type = ZONE_TYPE_SEGMENTED;
zones[zone_idx].leds_count = gen2_info->totalLeds;
zones[zone_idx].leds_min = zones[zone_idx].leds_count;
zones[zone_idx].leds_max = zones[zone_idx].leds_count;
zones[zone_idx].matrix_map.width = 0;
zones[zone_idx].matrix_map.height = 0;
zones[zone_idx].matrix_map.map.clear();
zones[zone_idx].flags = ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
if(preserve_segments)
{
zones[zone_idx].flags |= ZONE_FLAG_MANUALLY_CONFIGURED_SEGMENTS;
}
else
{
zones[zone_idx].segments.clear();
zones[zone_idx].segments.reserve(gen2_info->LedsOfStrip.size() * 2);
unsigned int start_idx = 0;
for(std::size_t strip_idx = 0; strip_idx < gen2_info->LedsOfStrip.size(); strip_idx++)
{
unsigned int strip_leds = gen2_info->LedsOfStrip[strip_idx];
/*-------------------------------------*\
| Empty marker for a physical strip |
\*-------------------------------------*/
segment group;
group.name = "Strip " + std::to_string(strip_idx + 1);
group.type = ZONE_TYPE_LINEAR;
group.start_idx = 0;
group.leds_count = 0;
group.flags = SEGMENT_FLAG_GROUP_START;
group.matrix_map.width = 0;
group.matrix_map.height = 0;
group.matrix_map.map.clear();
zones[zone_idx].segments.push_back(group);
/*-------------------------------------*\
| Initial member covers the whole strip |
\*-------------------------------------*/
segment member;
member.name = "Strip " + std::to_string(strip_idx + 1);
member.type = ZONE_TYPE_LINEAR;
member.start_idx = start_idx;
member.leds_count = strip_leds;
member.flags = SEGMENT_FLAG_GROUP_MEMBER;
member.matrix_map.width = 0;
member.matrix_map.height = 0;
member.matrix_map.map.clear();
zones[zone_idx].segments.push_back(member);
start_idx += strip_leds;
}
}
}
/*-------------------------------------------------*\
| Fixed motherboard zone |
\*-------------------------------------------------*/
else if(fixed_zone)
{
zones[zone_idx].name = zone_at_idx->name;
zones[zone_idx].type = ZONE_TYPE_SINGLE;
zones[zone_idx].leds_min = zone_at_idx->leds_min;
zones[zone_idx].leds_max = zone_at_idx->leds_max;
zones[zone_idx].leds_count = zone_at_idx->leds_min;
zones[zone_idx].flags = 0;
zones[zone_idx].matrix_map.width = 0;
zones[zone_idx].matrix_map.height = 0;
zones[zone_idx].matrix_map.map.clear();
zones[zone_idx].segments.clear();
}
/*-------------------------------------------------*\
| Manually configurable ARGB zone |
\*-------------------------------------------------*/
else
{
bool reset_manual_zone = first_run || !(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE);
if(reset_manual_zone)
{
zones[zone_idx].flags = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
| ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
| ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
| ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
| ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
zones[zone_idx].name = zone_at_idx->name;
zones[zone_idx].type = ZONE_TYPE_LINEAR;
zones[zone_idx].leds_count = zone_at_idx->leds_min;
zones[zone_idx].matrix_map.width = 0;
zones[zone_idx].matrix_map.height = 0;
zones[zone_idx].matrix_map.map.clear();
zones[zone_idx].segments.clear();
}
zones[zone_idx].leds_min = zone_at_idx->leds_min;
zones[zone_idx].leds_max = zone_at_idx->leds_max;
if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
{
zones[zone_idx].name = zone_at_idx->name;
}
if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
{
zones[zone_idx].leds_count = zone_at_idx->leds_min;
}
if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
{
zones[zone_idx].type = ZONE_TYPE_LINEAR;
}
if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
{
zones[zone_idx].matrix_map.width = 0;
zones[zone_idx].matrix_map.height = 0;
zones[zone_idx].matrix_map.map.clear();
}
if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SEGMENTS))
{
zones[zone_idx].segments.clear();
}
}
/*-------------------------------------------------*\
| Initialize per-zone modes |
\*-------------------------------------------------*/
if(zones[zone_idx].modes.empty())
{
for(std::size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
{
if(!(modes[mode_idx].flags & MODE_FLAG_REQUIRES_ENTIRE_DEVICE))
{
zones[zone_idx].modes.push_back(modes[mode_idx]);
}
}
zones[zone_idx].active_mode = -1;
}
/*-------------------------------------------------*\
| Initialize LEDs |
\*-------------------------------------------------*/
for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
{
led new_led;
new_led.name = zones[zone_idx].name;
new_led.value = zone_at_idx->idx;
if(!fixed_zone)
{
new_led.name.append(", LED " + std::to_string(led_idx + 1));
}
leds.push_back(new_led);
}
/*-------------------------------------------------*\
| Restore the ARGB header LED counts |
\*-------------------------------------------------*/
if(!fixed_zone)
{
switch(zone_at_idx->idx)
{
case LED4:
case HDR_D_LED2:
d2 = zones[zone_idx].leds_count;
break;
case HDR_D_LED3:
d3 = zones[zone_idx].leds_count;
break;
case HDR_D_LED4:
d4 = zones[zone_idx].leds_count;
break;
case LED10:
d5 = zones[zone_idx].leds_count;
break;
case LED11:
d6 = zones[zone_idx].leds_count;
break;
default:
d1 = zones[zone_idx].leds_count;
break;
}
}
}
controller->SetLedCount(d1, d2, d3, d4, d5, d6);
controller->SetStripBuiltinEffectState(-1, false);
SetupColors();
}
void RGBController_RGBFusion2USB::DeviceConfigureZone(int zone_idx)
{
if((size_t)zone_idx < zones.size())
{
SetupZones();
}
}
void RGBController_RGBFusion2USB::DeviceUpdateLEDs()
{
int mode_value = modes[active_mode].value;
bool random = modes[active_mode].color_mode == MODE_COLORS_RANDOM;
uint32_t* color = &null_color;
/*---------------------------------------------------------*\
| Entire-device modes use the special wave sequence |
\*---------------------------------------------------------*/
if(modes[active_mode].flags & MODE_FLAG_REQUIRES_ENTIRE_DEVICE)
{
controller->SetStripBuiltinEffectState(-1, true);
controller->SetLEDEffect(-1, EFFECT_STATIC, 0, 0xFF, false, color);
controller->ApplyEffect();
controller->SetLEDEffect(2, mode_value, modes[active_mode].speed, modes[active_mode].brightness, random, color);
controller->ApplyEffect();
entire_device_effect_active = true;
return;
}
/*---------------------------------------------------------*\
| Tear down the special wave slot before returning to |
| normal per-zone/direct operation |
\*---------------------------------------------------------*/
if(entire_device_effect_active)
{
controller->SetLEDEffect(2, EFFECT_STATIC, 0, 0xFF, false, color);
controller->ApplyEffect();
entire_device_effect_active = false;
}
for(int zone_idx = 0; zone_idx < (int)zones.size(); zone_idx++)
{
mode* selected_mode = &modes[active_mode];
/*---------------------------------------------------------*\
| Use the zone-specific mode when one is selected |
\*---------------------------------------------------------*/
if(zones[zone_idx].active_mode >= 0)
{
selected_mode = &zones[zone_idx].modes[zones[zone_idx].active_mode];
}
mode_value = selected_mode->value;
random = selected_mode->color_mode == MODE_COLORS_RANDOM;
color = &null_color;
if(zones[zone_idx].type == ZONE_TYPE_SINGLE)
{
for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
{
int led_mode_value = mode_value;
uint32_t* led_color = color;
/*---------------------------------------------------------*\
| Motherboard LEDs always use effect mode, so use static for|
| direct mode but get colors from zone |
\*---------------------------------------------------------*/
if(selected_mode->value == 0xFFFF)
{
led_color = &zones[zone_idx].colors[led_idx];
led_mode_value = EFFECT_STATIC;
}
/*---------------------------------------------------------*\
| If the mode uses mode-specific color, get color from mode |
\*---------------------------------------------------------*/
else if(selected_mode->color_mode == MODE_COLORS_MODE_SPECIFIC)
{
led_color = &selected_mode->colors[0];
}
/*---------------------------------------------------------*\
| Apply the mode and color to the zone |
\*---------------------------------------------------------*/
controller->SetLEDEffect(zones[zone_idx].leds[led_idx].value, led_mode_value, selected_mode->speed, selected_mode->brightness, random, led_color);
}
}
/*---------------------------------------------------------*\
| Set strip LEDs |
\*---------------------------------------------------------*/
else
{
if(zones[zone_idx].leds && zones[zone_idx].leds_count)
{
unsigned char hdr = zones[zone_idx].leds->value;
/*---------------------------------------------------------*\
| Direct mode addresses a different register |
\*---------------------------------------------------------*/
if(selected_mode->value == 0xFFFF)
{
controller->SetStripBuiltinEffectState(hdr, false);
controller->SetStripColors(hdr, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
/*---------------------------------------------------------*\
| Effect mode |
\*---------------------------------------------------------*/
else
{
/*---------------------------------------------------------*\
| If mode has mode specific color, load color from mode |
\*---------------------------------------------------------*/
if(selected_mode->color_mode == MODE_COLORS_MODE_SPECIFIC)
{
color = &selected_mode->colors[0];
}
/*---------------------------------------------------------*\
| Apply hardware effects to LED strips |
\*---------------------------------------------------------*/
controller->SetStripBuiltinEffectState(hdr, true);
controller->SetLEDEffect(hdr, mode_value, selected_mode->speed, selected_mode->brightness, random, color);
}
}
}
}
controller->ApplyEffect();
}
void RGBController_RGBFusion2USB::DeviceUpdateZoneLEDs(int zone)
{
int mode_value = modes[active_mode].value;
bool random = modes[active_mode].color_mode == MODE_COLORS_RANDOM;
uint32_t* color = &null_color;
/*---------------------------------------------------------*\
| Entire-device modes cannot be updated one zone at a time |
\*---------------------------------------------------------*/
if(modes[active_mode].flags & MODE_FLAG_REQUIRES_ENTIRE_DEVICE)
{
DeviceUpdateLEDs();
return;
}
mode* selected_mode = &modes[active_mode];
/*---------------------------------------------------------*\
| Use the zone-specific mode when one is selected |
\*---------------------------------------------------------*/
if(zones[zone].active_mode >= 0)
{
selected_mode = &zones[zone].modes[zones[zone].active_mode];
}
mode_value = selected_mode->value;
random = selected_mode->color_mode == MODE_COLORS_RANDOM;
/*---------------------------------------------------------*\
| Set motherboard LEDs |
\*---------------------------------------------------------*/
if(zones[zone].type == ZONE_TYPE_SINGLE)
{
for(std::size_t led_idx = 0; led_idx < zones[zone].leds_count; led_idx++)
{
int led_mode_value = mode_value;
uint32_t* led_color = color;
/*------------------------------------------------------------*\
| Motherboard LEDs always use effect mode, so use static for |
| direct mode but get colors from zone |
\*------------------------------------------------------------*/
if(selected_mode->value == 0xFFFF)
{
led_color = &zones[zone].colors[led_idx];
led_mode_value = EFFECT_STATIC;
}
/*---------------------------------------------------------*\
| If the mode uses mode-specific color, get color from mode |
\*---------------------------------------------------------*/
else if(selected_mode->color_mode == MODE_COLORS_MODE_SPECIFIC)
{
led_color = &selected_mode->colors[0];
}
/*---------------------------------------------------------*\
| Apply the mode and color to the zone |
\*---------------------------------------------------------*/
controller->SetLEDEffect(zones[zone].leds[led_idx].value, led_mode_value, selected_mode->speed, selected_mode->brightness, random, led_color);
controller->ApplyEffect();
}
}
/*---------------------------------------------------------*\
| Set strip LEDs |
\*---------------------------------------------------------*/
else
{
if(zones[zone].leds && zones[zone].leds_count)
{
unsigned char hdr = zones[zone].leds->value;
/*---------------------------------------------------------*\
| Direct mode addresses a different register |
\*---------------------------------------------------------*/
if(selected_mode->value == 0xFFFF)
{
controller->SetStripBuiltinEffectState(hdr, false);
controller->SetStripColors(hdr, zones[zone].colors, zones[zone].leds_count);
}
/*---------------------------------------------------------*\
| Effect mode |
\*---------------------------------------------------------*/
else
{
/*---------------------------------------------------------*\
| If mode has mode specific color, load color from mode |
\*---------------------------------------------------------*/
if(selected_mode->color_mode == MODE_COLORS_MODE_SPECIFIC)
{
color = &selected_mode->colors[0];
}
/*---------------------------------------------------------*\
| Apply built-in effects to LED strips |
\*---------------------------------------------------------*/
controller->SetStripBuiltinEffectState(hdr, true);
controller->SetLEDEffect(hdr, mode_value, selected_mode->speed, selected_mode->brightness, random, color);
controller->ApplyEffect();
}
}
}
}
void RGBController_RGBFusion2USB::DeviceUpdateSingleLED(int led)
{
int mode_value = modes[active_mode].value;
bool random = modes[active_mode].color_mode == MODE_COLORS_RANDOM;
uint32_t* color = &null_color;
/*---------------------------------------------------------*\
| Entire-device modes cannot update an individual LED |
\*---------------------------------------------------------*/
if(modes[active_mode].flags & MODE_FLAG_REQUIRES_ENTIRE_DEVICE)
{
DeviceUpdateLEDs();
return;
}
int zone_idx = GetLED_Zone(led);
if(zone_idx < 0)
{
return;
}
mode* selected_mode = &modes[active_mode];
/*---------------------------------------------------------*\
| Use the zone-specific mode when one is selected |
\*---------------------------------------------------------*/
if(zones[zone_idx].active_mode >= 0)
{
selected_mode = &zones[zone_idx].modes[zones[zone_idx].active_mode];
}
mode_value = selected_mode->value;
random = selected_mode->color_mode == MODE_COLORS_RANDOM;
/*---------------------------------------------------------*\
| Set motherboard LEDs |
\*---------------------------------------------------------*/
if(zones[zone_idx].type == ZONE_TYPE_SINGLE)
{
/*---------------------------------------------------------*\
| Motherboard LEDs always use effect mode, so use static for|
| direct mode but get colors from zone |
\*---------------------------------------------------------*/
if(selected_mode->value == 0xFFFF)
{
color = &colors[led];
mode_value = EFFECT_STATIC;
}
/*---------------------------------------------------------*\
| If the mode uses mode-specific color, get color from mode |
\*---------------------------------------------------------*/
else if(selected_mode->color_mode == MODE_COLORS_MODE_SPECIFIC)
{
color = &selected_mode->colors[0];
}
controller->SetLEDEffect(leds[led].value, mode_value, selected_mode->speed, selected_mode->brightness, random, color);
controller->ApplyEffect();
}
/*---------------------------------------------------------*\
| Set strip LEDs |
\*---------------------------------------------------------*/
else
{
DeviceUpdateZoneLEDs(zone_idx);
}
}
void RGBController_RGBFusion2USB::DeviceUpdateMode()
{
DeviceUpdateLEDs();
}
void RGBController_RGBFusion2USB::DeviceUpdateZoneMode(int zone)
{
DeviceUpdateZoneLEDs(zone);
}
int RGBController_RGBFusion2USB::GetLED_Zone(int led_idx)
{
for(int zone_idx = 0; zone_idx < (int)zones.size(); zone_idx++)
{
int zone_start = zones[zone_idx].start_idx;
int zone_end = zone_start + zones[zone_idx].leds_count - 1;
if((zone_start <= led_idx) && (zone_end >= led_idx))
{
return(zone_idx);
}
}
/*---------------------------------------------------------*\
| If zone is not found, return -1 |
\*---------------------------------------------------------*/
return(-1);
}
void RGBController_RGBFusion2USB::DeviceSaveMode()
{
controller->SetPersistentLightingEnabled(true);
std::this_thread::sleep_for(std::chrono::milliseconds(20));
controller->SaveLightingStateToFlash();
}
void RGBController_RGBFusion2USB::DeviceConfigureDevice()
{
if((flags & CONTROLLER_FLAG_MANUALLY_CONFIGURED_DEVICE_SPECIFIC) == 0)
{
InitDeviceSpecificConfiguration();
ApplyDeviceSpecificConfiguration(true);
}
}
void RGBController_RGBFusion2USB::DeviceUpdateDeviceSpecificConfiguration()
{
/*---------------------------------------------------------*\
| SetDeviceSpecificConfiguration() already holds AccessMutex|
| here, so parse the protected configuration string directly|
\*---------------------------------------------------------*/
ApplyDeviceSpecificConfiguration(true);
}
Reference in new issue View Git Blame Copy Permalink