/// <summary>
/// Adds new layers to the overlay of the passed EffectFrame.
/// </summary>
public virtual void UpdateOverlayLights(EffectFrame frame)
{
var overlayLayers = new Queue <EffectLayer>(Application.Profile.OverlayLayers.Where(l => l.Enabled).Reverse().Select(l => l.Render(_game_state)));
Application.UpdateEffectScripts(overlayLayers);
frame.AddOverlayLayers(overlayLayers.ToArray());
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
foreach (var layer in this.Application.Profile.Layers.Reverse().ToArray())
{
if (layer.Enabled && layer.LogicPass)
{
layers.Enqueue(layer.Render(_game_state));
}
}
layers.Enqueue(new EffectLayer("Color Zones").DrawColorZones((this.Application.Profile as DesktopProfile).lighting_areas.ToArray()));
//Scripts before interactive and shortcut assistant layers
//ProfilesManager.DesktopProfile.UpdateEffectScripts(layers);
if (Global.Configuration.time_based_dimming_enabled)
{
if (
Utils.Time.IsCurrentTimeBetween(Global.Configuration.time_based_dimming_start_hour, Global.Configuration.time_based_dimming_end_hour)
)
{
layers.Clear();
EffectLayer time_based_dim_layer = new EffectLayer("Time Based Dim");
time_based_dim_layer.Fill(Color.Black);
layers.Enqueue(time_based_dim_layer);
}
}
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
GenericApplicationProfile settings = (GenericApplicationProfile)this.Application.Profile;
ObservableCollection <Layer> timeLayers = settings.Layers;
//Scripts
//this.Application.UpdateEffectScripts(layers);
if ((Global.Configuration.NighttimeEnabled &&
Utils.Time.IsCurrentTimeBetween(Global.Configuration.NighttimeStartHour, Global.Configuration.NighttimeStartMinute, Global.Configuration.NighttimeEndHour, Global.Configuration.NighttimeEndMinute)) ||
settings._simulateNighttime
)
{
timeLayers = settings.Layers_NightTime;
}
foreach (var layer in timeLayers.Reverse().ToArray())
{
if (layer.Enabled)
{
layers.Enqueue(layer.Render(_game_state));
}
}
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame, GameState new_game_state)
{
if (new_game_state is GameState_PD2)
{
_game_state = new_game_state;
GameState_PD2 gs = (new_game_state as GameState_PD2);
try
{
SetPlayerState(gs.Players.LocalPlayer.State);
SetHealth(gs.Players.LocalPlayer.Health.Current);
SetHealthMax(gs.Players.LocalPlayer.Health.Max);
SetArmor(gs.Players.LocalPlayer.Armor.Current);
SetArmorMax(gs.Players.LocalPlayer.Armor.Max);
SetClip(gs.Players.LocalPlayer.Weapons.SelectedWeapon.Current_Clip);
SetClipMax(gs.Players.LocalPlayer.Weapons.SelectedWeapon.Max_Clip);
SetSuspicion(gs.Players.LocalPlayer.SuspicionAmount);
SetLevelPhase(gs.Level.Phase);
SetDownTime(gs.Players.LocalPlayer.DownTime);
SetSwanSong(gs.Players.LocalPlayer.IsSwanSong);
SetFlashbangAmount(gs.Players.LocalPlayer.FlashAmount);
SetNoReturnTimeleft(gs.Level.NoReturnTime);
SetGameState(gs.Game.State);
UpdateLights(frame);
}
catch (Exception e)
{
Global.logger.LogLine("Exception during OnNewGameState. Error: " + e, Logging_Level.Error);
Global.logger.LogLine(gs.ToString(), Logging_Level.None);
}
}
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
GenericApplicationSettings settings = (GenericApplicationSettings)this.Profile.Settings;
ObservableCollection <Layer> timeLayers = settings.Layers;
//Scripts
this.Profile.UpdateEffectScripts(layers);
if (HasProfile())
{
if ((Global.Configuration.nighttime_enabled &&
Utils.Time.IsCurrentTimeBetween(Global.Configuration.nighttime_start_hour, Global.Configuration.nighttime_start_minute, Global.Configuration.nighttime_end_hour, Global.Configuration.nighttime_end_minute)) ||
settings._simulateNighttime
)
{
timeLayers = settings.Layers_NightTime;
}
}
foreach (var layer in timeLayers.Reverse().ToArray())
{
if (layer.Enabled && layer.LogicPass)
{
layers.Enqueue(layer.Render(_game_state));
}
}
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
DishonoredProfile settings = (DishonoredProfile)this.Application.Profile;
Process[] process_search = Process.GetProcessesByName("Dishonored");
if (process_search.Length != 0)
{
using (MemoryReader memread = new MemoryReader(process_search[0]))
{
(_game_state as GameState_Dishonored).Player.MaximumHealth = memread.ReadInt(pointers.MaximumHealth.baseAddress, pointers.MaximumHealth.pointers);
(_game_state as GameState_Dishonored).Player.CurrentHealth = memread.ReadInt(pointers.CurrentHealth.baseAddress, pointers.CurrentHealth.pointers);
(_game_state as GameState_Dishonored).Player.MaximumMana = memread.ReadInt(pointers.MaximumMana.baseAddress, pointers.MaximumMana.pointers);
(_game_state as GameState_Dishonored).Player.CurrentMana = memread.ReadInt(pointers.CurrentMana.baseAddress, pointers.CurrentMana.pointers);
(_game_state as GameState_Dishonored).Player.ManaPots = memread.ReadInt(pointers.ManaPots.baseAddress, pointers.ManaPots.pointers);
(_game_state as GameState_Dishonored).Player.HealthPots = memread.ReadInt(pointers.HealthPots.baseAddress, pointers.HealthPots.pointers);
}
}
foreach (var layer in this.Application.Profile.Layers.Reverse().ToArray())
{
if (layer.Enabled && layer.LogicPass)
{
layers.Enqueue(layer.Render(_game_state));
}
}
//Scripts
this.Application.UpdateEffectScripts(layers);
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
Borderlands2Profile settings = (Borderlands2Profile)this.Application.Profile;
Process[] process_search = Process.GetProcessesByName("Borderlands2");
if (process_search.Length != 0)
{
using (MemoryReader memread = new MemoryReader(process_search[0]))
{
(_game_state as GameState_Borderlands2).Player.MaximumHealth = memread.ReadFloat(pointers.Health_maximum.baseAddress, pointers.Health_maximum.pointers);
(_game_state as GameState_Borderlands2).Player.CurrentHealth = memread.ReadFloat(pointers.Health_current.baseAddress, pointers.Health_current.pointers);
(_game_state as GameState_Borderlands2).Player.MaximumShield = memread.ReadFloat(pointers.Shield_maximum.baseAddress, pointers.Shield_maximum.pointers);
(_game_state as GameState_Borderlands2).Player.CurrentShield = memread.ReadFloat(pointers.Shield_current.baseAddress, pointers.Shield_current.pointers);
}
}
foreach (var layer in this.Application.Profile.Layers.Reverse().ToArray())
{
if (layer.Enabled && layer.LogicPass)
{
layers.Enqueue(layer.Render(_game_state));
}
}
//Scripts
this.Application.UpdateEffectScripts(layers);
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
TERSettings settings = (TERSettings)this.Profile.Settings;
foreach (var layer in settings.Layers.Reverse().ToArray())
{
if (layer.Enabled && layer.LogicPass)
{
layers.Enqueue(layer.Render(_game_state));
}
}
//Scripts
this.Profile.UpdateEffectScripts(layers, _game_state);
//ColorZones
layers.Enqueue(new EffectLayer("TER - Color Zones").DrawColorZones((this.Profile.Settings as TERSettings).lighting_areas.ToArray()));
frame.AddLayers(layers.ToArray());
System.Diagnostics.Debug.WriteLine("\n=======================================");
System.Diagnostics.Debug.WriteLine("UpdateLights() - 1");
System.Diagnostics.Debug.WriteLine("=======================================\n");
}
public override sealed void UpdateLights(EffectFrame frame)
{
UpdateWrapperLights(frame);
Queue <EffectLayer> layers = new Queue <EffectLayer>();
if (this.Profile != null)
{
foreach (var layer in this.Profile.Settings.Layers.Reverse().ToArray())
{
if (layer.Enabled && layer.LogicPass)
{
layers.Enqueue(layer.Render(_game_state));
}
}
//No need to repeat the code around this everytime this is inherited
this.UpdateExtraLights(layers);
//Scripts
this.Profile.UpdateEffectScripts(layers, _game_state);
}
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame, GameState new_game_state)
{
if (new_game_state is GameState_GTA5)
{
_game_state = new_game_state;
GameState_GTA5 newgs = (new_game_state as GameState_GTA5);
try
{
curr_state = newgs.CurrentState;
statecol = newgs.StateColor;
have_cops = newgs.HasCops;
left_siren_color = newgs.LeftSirenColor;
right_siren_color = newgs.RightSirenColor;
if (have_cops && special_mode != newgs.Command_Data.custom_mode)
{
siren_keyframe++;
}
special_mode = newgs.Command_Data.custom_mode;
}
catch (Exception e)
{
Global.logger.LogLine("Exception during OnNewGameState. Error: " + e, Logging_Level.Error);
Global.logger.LogLine(newgs.ToString(), Logging_Level.None);
}
UpdateLights(frame);
}
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
PD2Settings settings = (PD2Settings)this.Profile.Settings;
foreach (var layer in settings.Layers.Reverse().ToArray())
{
if (layer.Enabled && layer.LogicPass)
{
layers.Enqueue(layer.Render(_game_state));
}
}
//Scripts
this.Profile.UpdateEffectScripts(layers, _game_state);
//ColorZones
layers.Enqueue(new EffectLayer("PD2 - Color Zones").DrawColorZones((this.Profile.Settings as PD2Settings).lighting_areas.ToArray()));
frame.AddLayers(layers.ToArray());
System.Diagnostics.Debug.WriteLine("PD2 -- UpdateLights() - 1");
StackTrace stackTrace = new StackTrace();
System.Diagnostics.Debug.WriteLine(stackTrace.GetFrame(1).GetMethod().Name);
}
public override void UpdateLights(EffectFrame frame)
{
//if (Global.Configuration.volume_overlay_settings.enabled)
//{
if (defaultDevice == null)
{
defaultDevice = devEnum.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console);
}
Queue <EffectLayer> layers = new Queue <EffectLayer>();
if (Global.Configuration.volume_overlay_settings.dim_background)
{
layers.Enqueue(new EffectLayer("Overlay - Volume Base", Global.Configuration.volume_overlay_settings.dim_color));
}
EffectLayer volume_bar = new EffectLayer("Overlay - Volume Bar");
float currentVolume = defaultDevice.AudioEndpointVolume.MasterVolumeLevelScalar;
ColorSpectrum volume_spec = new ColorSpectrum(Global.Configuration.volume_overlay_settings.low_color, Global.Configuration.volume_overlay_settings.high_color);
volume_spec.SetColorAt(0.75f, Global.Configuration.volume_overlay_settings.med_color);
volume_bar.PercentEffect(volume_spec, Global.Configuration.volume_overlay_settings.sequence, currentVolume, 1.0f);
layers.Enqueue(volume_bar);
frame.AddOverlayLayers(layers.ToArray());
//}
}
public virtual void UpdateOverlayLights(EffectFrame frame)
{
if (Disposed)
{
return;
}
Config.Event.UpdateOverlayLights(frame);
}
public override void UpdateLights(EffectFrame frame, IGameState new_game_state)
{
if (new_game_state is GameState_Dota2)
{
_game_state = new_game_state;
UpdateLights(frame);
}
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
long time = Utils.Time.GetMillisecondsSinceEpoch();
if (Global.Configuration.skype_overlay_settings.mm_enabled)
{
if (_missed_messages_count > 0)
{
EffectLayer skype_missed_messages = new EffectLayer("Overlay - Skype Missed Messages");
ColorSpectrum mm_spec = new ColorSpectrum(Global.Configuration.skype_overlay_settings.mm_color_primary, Global.Configuration.skype_overlay_settings.mm_color_secondary, Global.Configuration.skype_overlay_settings.mm_color_primary);
Color color = Color.Orange;
if (Global.Configuration.skype_overlay_settings.mm_blink)
{
color = mm_spec.GetColorAt((time % 2000L) / 2000.0f);
}
else
{
color = mm_spec.GetColorAt(0);
}
skype_missed_messages.Set(Global.Configuration.skype_overlay_settings.mm_sequence, color);
layers.Enqueue(skype_missed_messages);
}
}
if (Global.Configuration.skype_overlay_settings.call_enabled)
{
if (_is_calling)
{
EffectLayer skype_ringing_call = new EffectLayer("Overlay - Skype Ringing Call");
ColorSpectrum mm_spec = new ColorSpectrum(Global.Configuration.skype_overlay_settings.call_color_primary, Global.Configuration.skype_overlay_settings.call_color_secondary, Global.Configuration.skype_overlay_settings.call_color_primary);
Color color = Color.Green;
if (Global.Configuration.skype_overlay_settings.call_blink)
{
color = mm_spec.GetColorAt((time % 2000L) / 2000.0f);
}
else
{
color = mm_spec.GetColorAt(0);
}
skype_ringing_call.Set(Global.Configuration.skype_overlay_settings.call_sequence, color);
layers.Enqueue(skype_ringing_call);
}
}
frame.AddOverlayLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
EffectLayer bitmap_layer = new EffectLayer("Overwatch - Bitmap");
Devices.DeviceKeys[] allkeys = Enum.GetValues(typeof(Devices.DeviceKeys)).Cast <Devices.DeviceKeys>().ToArray();
foreach (var key in allkeys)
{
if (key == Devices.DeviceKeys.LOGO && logo.Length == 4)
{
int a, r, g, b;
b = logo[0];
g = logo[1];
r = logo[2];
a = logo[3];
bitmap_layer.Set(key, GetBoostedColor(Color.FromArgb(a, r, g, b)));
}
else if (key == Devices.DeviceKeys.Peripheral && peripheral.Length == 4)
{
int a, r, g, b;
b = peripheral[0];
g = peripheral[1];
r = peripheral[2];
a = peripheral[3];
bitmap_layer.Set(key, GetBoostedColor(Color.FromArgb(a, r, g, b)));
}
else
{
Devices.Logitech.Logitech_keyboardBitmapKeys logi_key = Devices.Logitech.LogitechDevice.ToLogitechBitmap(key);
if (logi_key != Devices.Logitech.Logitech_keyboardBitmapKeys.UNKNOWN)
{
int a, r, g, b;
b = bitmap[(int)logi_key];
g = bitmap[(int)logi_key + 1];
r = bitmap[(int)logi_key + 2];
a = bitmap[(int)logi_key + 3];
bitmap_layer.Set(key, GetBoostedColor(Color.FromArgb(a, r, g, b)));
}
}
}
layers.Enqueue(bitmap_layer);
//Scripts
Global.Configuration.ApplicationProfiles[profilename].UpdateEffectScripts(layers, _game_state);
frame.AddLayers(layers.ToArray());
}
/// <summary>
/// Adds new layers to the overlay of the passed EffectFrame.
/// </summary>
public virtual void UpdateOverlayLights(EffectFrame frame)
{
try
{
var overlayLayers = new Queue <EffectLayer>(Application.Profile.OverlayLayers.Where(l => l.Enabled).Reverse().Select(l => l.Render(_game_state)));
Application.UpdateEffectScripts(overlayLayers);
frame.AddOverlayLayers(overlayLayers.ToArray());
}
catch (Exception e)
{
Global.logger.Error("Error updating overlay layers: " + e);
}
}
public override void UpdateLights(EffectFrame frame)
{
UpdateWrapperLights(frame);
Queue <EffectLayer> layers = new Queue <EffectLayer>();
//Scripts
if (!String.IsNullOrWhiteSpace(profilename))
{
Global.Configuration.ApplicationProfiles[profilename].UpdateEffectScripts(layers, _game_state);
}
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
ApplicationProfile settings = this.Application.Profile;
foreach (var layer in Application.Profile.Layers.Reverse())
{
if (layer.Enabled && layer.LogicPass)
{
layers.Enqueue(layer.Render(_game_state));
}
}
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame)
{
//Queue<EffectLayer> layers = new Queue<EffectLayer>();
//foreach (var layer in this.Application.Profile.Layers.Reverse().ToArray())
//{
// if (layer.Enabled && layer.LogicPass)
// layers.Enqueue(layer.Render(_game_state));
//}
////Scripts
//this.Application.UpdateEffectScripts(layers);
//frame.AddLayers(layers.ToArray());
base.UpdateLights(frame);
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
if (File.Exists(configFile))
{
if (configContent != null && isGameStateDirty)
{
try
{
var data = GetUsefulData(configContent);
if (data != null)//if this is null, no useful data was found
{
var player = (_game_state as GameState_Witcher3).Player;
player.Toxicity = GetInt(data, "Toxicity");
player.Stamina = GetInt(data, "Stamina");
player.MaximumHealth = GetInt(data, "MaxHealth");
player.CurrentHealth = GetInt(data, "CurrHealth");
if (Enum.TryParse(data.FirstOrDefault(d => d.Contains("ActiveSign")).Split('=').Last().Replace("ST_", ""), out WitcherSign sign))
{
;
}
player.ActiveSign = sign; //tries to parse the sign text into the enum
isGameStateDirty = false;
}
}
catch
{ }
}
}
foreach (var layer in this.Application.Profile.Layers.Reverse().ToArray())
{
if (layer.Enabled)
{
layers.Enqueue(layer.Render(_game_state));
}
}
//Scripts
this.Application.UpdateEffectScripts(layers);
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame)
{
//Update wrapper lighting
UpdateWrapperLights(frame);
Queue <EffectLayer> layers = new Queue <EffectLayer>();
//ColorZones
EffectLayer cz_layer = new EffectLayer("BF3 - Color Zones");
cz_layer.DrawColorZones((Global.Configuration.ApplicationProfiles[profilename].Settings as BF3Settings).lighting_areas.ToArray());
layers.Enqueue(cz_layer);
//Scripts
Global.Configuration.ApplicationProfiles[profilename].UpdateEffectScripts(layers, _game_state);
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame, IGameState new_game_state)
{
if (new_game_state is GameState_PD2)
{
_game_state = new_game_state;
GameState_PD2 gs = (new_game_state as GameState_PD2);
try
{
UpdateLights(frame);
}
catch (Exception e)
{
Global.logger.LogLine("Exception during OnNewGameState. Error: " + e, Logging_Level.Error);
Global.logger.LogLine(gs.ToString(), Logging_Level.None);
}
}
}
public override void UpdateLights(EffectFrame frame, GameState new_state)
{
if (new_state is State_SkypeOverlay)
{
State_SkypeOverlay state = (new_state as State_SkypeOverlay);
try
{
SetMissedMessagesCount(state.Data.MissedMessagesCount);
SetIsCalling(state.Data.IsCalled);
}
catch (Exception e)
{
Global.logger.LogLine("Exception during OnNewGameState. Error: " + e, Logging_Level.Error);
Global.logger.LogLine(state.ToString(), Logging_Level.None);
}
}
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
RocketLeagueProfile settings = (RocketLeagueProfile)this.Application.Profile;
Process[] process_search = Process.GetProcessesByName("RocketLeague");
if (process_search.Length != 0)
{
using (MemoryReader memread = new MemoryReader(process_search[0]))
{
PlayerTeam parsed_team = PlayerTeam.Undefined;
if (Enum.TryParse <PlayerTeam>(memread.ReadInt(pointers.Team.baseAddress, pointers.Team.pointers).ToString(), out parsed_team))
{
(_game_state as GameState_RocketLeague).Player.Team = parsed_team;
}
// Goal explosion preperation
(_game_state as GameState_RocketLeague).Match.YourTeam_LastScore = parsed_team == PlayerTeam.Blue ? (_game_state as GameState_RocketLeague).Match.BlueTeam_Score
: (_game_state as GameState_RocketLeague).Match.OrangeTeam_Score;
(_game_state as GameState_RocketLeague).Match.EnemyTeam_LastScore = parsed_team == PlayerTeam.Orange ? (_game_state as GameState_RocketLeague).Match.BlueTeam_Score
: (_game_state as GameState_RocketLeague).Match.OrangeTeam_Score;
(_game_state as GameState_RocketLeague).Match.OrangeTeam_Score = memread.ReadInt(pointers.Orange_score.baseAddress, pointers.Orange_score.pointers);
(_game_state as GameState_RocketLeague).Match.BlueTeam_Score = memread.ReadInt(pointers.Blue_score.baseAddress, pointers.Blue_score.pointers);
(_game_state as GameState_RocketLeague).Player.BoostAmount = memread.ReadInt(pointers.Boost_amount.baseAddress, pointers.Boost_amount.pointers);
}
}
foreach (var layer in this.Application.Profile.Layers.Reverse().ToArray())
{
if (layer.Enabled && layer.LogicPass)
{
layers.Enqueue(layer.Render(_game_state));
}
}
//Scripts
this.Application.UpdateEffectScripts(layers);
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame)
{
//Update wrapper lighting
UpdateWrapperLights(frame);
Queue <EffectLayer> layers = new Queue <EffectLayer>();
//ColorZones
if (!((Global.Configuration.ApplicationProfiles[profilename].Settings as LoLSettings).disable_cz_on_dark && last_fill_color.Equals(Color.Black)))
{
EffectLayer cz_layer = new EffectLayer("League - Color Zones");
cz_layer.DrawColorZones((Global.Configuration.ApplicationProfiles[profilename].Settings as LoLSettings).lighting_areas.ToArray());
layers.Enqueue(cz_layer);
}
//Scripts
Global.Configuration.ApplicationProfiles[profilename].UpdateEffectScripts(layers, _game_state);
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame, IGameState new_game_state)
{
if (new_game_state is GameState_TER)
{
_game_state = new_game_state;
GameState_TER gs = (new_game_state as GameState_TER);
try
{
UpdateLights(frame);
}
catch (Exception e)
{
Global.logger.LogLine("Exception during OnNewGameState. Error: " + e, Logging_Level.Error);
Global.logger.LogLine(gs.ToString(), Logging_Level.None);
}
}
System.Diagnostics.Debug.WriteLine("\n=======================================");
System.Diagnostics.Debug.WriteLine("UpdateLights() - 2");
System.Diagnostics.Debug.WriteLine("=======================================\n");
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
Dota2Settings settings = (Dota2Settings)this.Profile.Settings;
foreach (var layer in settings.Layers.Reverse().ToArray())
{
if (layer.Enabled && layer.LogicPass)
{
layers.Enqueue(layer.Render(_game_state));
}
}
//Scripts
this.Profile.UpdateEffectScripts(layers, _game_state);
//ColorZones
layers.Enqueue(new EffectLayer("Dota 2 - Color Zones").DrawColorZones((this.Profile.Settings as Dota2Settings).lighting_areas.ToArray()));
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
RocketLeagueSettings settings = (RocketLeagueSettings)this.Profile.Settings;
Process[] process_search = Process.GetProcessesByName("RocketLeague");
if (process_search.Length != 0)
{
using (MemoryReader memread = new MemoryReader(process_search[0]))
{
PlayerTeam parsed_team = PlayerTeam.Undefined;
if (Enum.TryParse <PlayerTeam>(memread.ReadInt(pointers.Team.baseAddress, pointers.Team.pointers).ToString(), out parsed_team))
{
(_game_state as GameState_RocketLeague).Player.Team = parsed_team;
}
(_game_state as GameState_RocketLeague).Match.OrangeTeam_Score = memread.ReadInt(pointers.Orange_score.baseAddress, pointers.Orange_score.pointers);
(_game_state as GameState_RocketLeague).Match.BlueTeam_Score = memread.ReadInt(pointers.Blue_score.baseAddress, pointers.Blue_score.pointers);
(_game_state as GameState_RocketLeague).Player.BoostAmount = memread.ReadFloat(pointers.Boost_amount.baseAddress, pointers.Boost_amount.pointers);
}
}
foreach (var layer in this.Profile.Settings.Layers.Reverse().ToArray())
{
if (layer.Enabled && layer.LogicPass)
{
layers.Enqueue(layer.Render(_game_state));
}
}
//Scripts
this.Profile.UpdateEffectScripts(layers);
//ColorZones
layers.Enqueue(new EffectLayer("Rocket League - Color Zones").DrawColorZones((this.Profile.Settings as RocketLeagueSettings).lighting_areas.ToArray()));
frame.AddLayers(layers.ToArray());
}
public override void UpdateLights(EffectFrame frame)
{
var layers = new Queue <EffectLayer>(Application.Profile.Layers.Where(l => l.Enabled).Reverse().Select(l => l.Render(_game_state)));
//Scripts before interactive and shortcut assistant layers
//ProfilesManager.DesktopProfile.UpdateEffectScripts(layers);
if (Global.Configuration.TimeBasedDimmingEnabled)
{
if (Utils.Time.IsCurrentTimeBetween(Global.Configuration.TimeBasedDimmingStartHour, Global.Configuration.TimeBasedDimmingEndHour))
{
layers.Clear();
EffectLayer time_based_dim_layer = new EffectLayer("Time Based Dim");
time_based_dim_layer.Fill(Color.Black);
layers.Enqueue(time_based_dim_layer);
}
}
frame.AddLayers(layers.ToArray());
}
