using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HDLethalCompanyPatch.config;
using HDLethalCompanyPatch.patches;
using HarmonyLib;
using HarmonyLib.Public.Patching;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("HDLethalCompanyPatch")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+0c2865a6b4e7cd81fe2768ea04154499b79595f9")]
[assembly: AssemblyProduct("My first plugin")]
[assembly: AssemblyTitle("HDLethalCompanyPatch")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace HDLethalCompanyPatch
{
public enum FogSettingMethod
{
Sliders,
Presets
}
public enum FogQualitySetting
{
Minimal,
VeryLow,
Low,
Medium,
High,
VeryHigh,
Extreme
}
public enum QualitySetting
{
VeryLow,
Low,
Medium,
High
}
public enum AntiAliasingSetting
{
FAA,
TAA,
SMAA
}
public enum ResolutionSettingMethod
{
ScaleSlider,
Presets,
Custom
}
public enum ResolutionPreset
{
R640x480,
R1280x720,
R1920x1080,
R2560x1440,
R3840x2160
}
public static class HDLCPatchProperties
{
public const string Name = "HDLCPatch";
public const string GUID = "HDLCPatch";
public const string Version = "1.3.0";
public static Assembly HDAssembly;
public static object GraphicsPatchObj;
public static Type GraphicsPatch;
public static MethodInfo RemoveLodFromGameObject;
public static MethodInfo SetShadowQuality;
}
[BepInPlugin("HDLCPatch", "HDLCPatch", "1.3.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class HDLCPatch : BaseUnityPlugin
{
internal static ManualLogSource Logger;
private static Harmony _harmony;
public static ConfigEntry<QualitySetting> ShadowQuality;
public static ConfigEntry<QualitySetting> LODQuality;
public static ConfigEntry<QualitySetting> TextureQuality;
public static ConfigEntry<FogQualitySetting> FogQuality;
public static ConfigEntry<AntiAliasingSetting> AASetting;
public static ConfigEntry<ResolutionSettingMethod> ResolutionMethod;
public static ConfigEntry<ResolutionPreset> ResolutionPresetValue;
public static ConfigEntry<FogSettingMethod> FogQualityMethod;
public static ConfigEntry<float> VolumetricFogBudget;
public static ConfigEntry<float> FogResolutionDepthRatio;
public static ConfigEntry<float> ResolutionScale;
public static ConfigEntry<int> ResolutionWidth;
public static ConfigEntry<int> ResolutionHeight;
public static ConfigEntry<bool> EnableFog;
public static ConfigEntry<bool> EnablePostProcessing;
public static ConfigEntry<bool> EnableFoliage;
public static ConfigEntry<bool> EnableResolutionOverride;
public static ConfigEntry<bool> EnableAntiAliasing;
public static ConfigEntry<bool> DisableFoliageConfig;
public static ConfigEntry<bool> EnableSteamProfileImageFix;
public static Assembly HDLethal;
private void Awake()
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
Logger.LogInfo((object)"Plugin HDLCPatch 1.3.0 is loaded!");
_harmony = new Harmony("HDLCPatch");
PatchHDLC();
SetupConfig();
}
public static void PatchHDLC()
{
Logger.LogInfo((object)"Patching...");
List<MethodBase> obj = (List<MethodBase>)Harmony.GetAllPatchedMethods();
bool flag = false;
bool flag2 = false;
bool flag3 = true;
foreach (MethodBase item in obj)
{
PatchInfo patchInfo = PatchManager.GetPatchInfo(item);
Patch[] prefixes = patchInfo.prefixes;
Patch[] postfixes = patchInfo.postfixes;
Patch[] array = prefixes;
foreach (Patch val in array)
{
if (val.PatchMethod.Name == "RoundPostFix" && (val.owner == "HDLethalCompany" || val.owner == "HDLethalCompanyRemake"))
{
Logger.LogInfo((object)"Attempting to unpatch HDLethalCompany RoundPostFix");
_harmony.Unpatch(item, val.PatchMethod);
HDLethal = val.PatchMethod.Module.Assembly;
flag = true;
}
if (val.PatchMethod.Name == "StartPrefix" && (val.owner == "HDLethalCompany" || val.owner == "HDLethalCompanyRemake"))
{
Logger.LogInfo((object)"Attempting to unpatch HDLethalCompany RoundPostFix");
_harmony.Unpatch(item, val.PatchMethod);
flag2 = true;
}
}
array = postfixes;
foreach (Patch val2 in array)
{
if (val2.PatchMethod.Name == "UpdateScanNodesPostfix" && (val2.owner == "HDLethalCompany" || val2.owner == "HDLethalCompanyRemake"))
{
Logger.LogInfo((object)"Attempting to unpatch HDLethalCompany UpdateScanNodesPostfix");
_harmony.Unpatch(item, val2.PatchMethod);
}
}
}
if (flag)
{
Logger.LogInfo((object)"Unpatch RoundPostfix success!");
}
else
{
Logger.LogFatal((object)"Failed to unpatch RoundPostfix");
}
if (flag2)
{
Logger.LogInfo((object)"Unpatch StartPrefix success!");
}
else
{
Logger.LogFatal((object)"Failed to unpatch StartPrefix");
}
_harmony.PatchAll(typeof(HDLCGraphicsPatch));
try
{
SetupInternalMethods(HDLethal);
}
catch (Exception ex)
{
Logger.LogWarning((object)("Failed to set internal method references \n" + ex.ToString()));
Logger.LogInfo((object)"Attempting to get assembly with a different method...");
try
{
HDLethal = HarmonyGetAssembly("HDLethalCompany");
SetupInternalMethods(HDLethal);
}
catch (Exception ex2)
{
Logger.LogError((object)("Backup method for getting assembly failed! \n" + ex2.ToString()));
Logger.LogInfo((object)"Attempting 3rd method to get internal references...");
try
{
HDLethal = GetAssembly("HDLethalCompany");
SetupInternalMethods(HDLethal);
goto end_IL_0291;
}
catch (Exception ex3)
{
Logger.LogFatal((object)"All methods to get HDLethalCompany internal methods failed!");
Logger.LogError((object)ex3.ToString());
flag3 = false;
goto end_IL_0291;
}
end_IL_0291:;
}
}
if (flag3)
{
Logger.LogInfo((object)"Finished patching process");
}
else
{
Logger.LogFatal((object)"Failed to set internal references to HDLethalCompany methods. Things might not work right!");
}
}
public static Assembly GetAssembly(string assemblyName)
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
if (assembly.GetName().Name.Contains(assemblyName) && !assembly.GetName().Name.Contains("HDLethalCompanyPatch"))
{
Logger.LogInfo((object)("Got assembly: " + assembly.GetName().Name));
return assembly;
}
}
Logger.LogError((object)"Failed to get assembly");
Logger.LogInfo((object)"Currently available assemblies from AppDomain.CurrentDomain: ");
assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly2 in assemblies)
{
Logger.LogInfo((object)(assembly2.GetName().Name ?? ""));
}
return null;
}
public static Assembly HarmonyGetAssembly(string assemblyName)
{
foreach (Assembly item in AccessTools.AllAssemblies())
{
if (item.GetName().Name.Contains(assemblyName) && !item.GetName().Name.Contains("HDLethalCompanyPatch"))
{
Logger.LogInfo((object)("Got assembly: " + item.GetName().Name));
return item;
}
}
Logger.LogError((object)"Failed to get assembly");
Logger.LogInfo((object)"Currently available assemblies from AccessTools: ");
foreach (Assembly item2 in AccessTools.AllAssemblies())
{
Logger.LogInfo((object)(item2.GetName().Name ?? ""));
}
return null;
}
public static void SetupInternalMethods(Assembly assembly)
{
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00d5: Expected O, but got Unknown
Logger.LogInfo((object)"Creating references to internal methods...");
try
{
HDLCPatchProperties.HDAssembly = assembly;
Logger.LogInfo((object)("Got assembly of " + assembly.GetName().Name));
}
catch (Exception ex)
{
Logger.LogError((object)("Failed to get assembly reference\n" + ex.ToString()));
}
try
{
HDLCPatchProperties.GraphicsPatchObj = assembly.CreateInstance("HDLethalCompany.Patch.GraphicsPatch");
}
catch (Exception ex2)
{
Logger.LogError((object)("Failed to get reference to GraphicsPatch\n" + ex2.ToString()));
}
Type type = (HDLCPatchProperties.GraphicsPatch = HDLCPatchProperties.GraphicsPatchObj.GetType());
HDLCPatchProperties.RemoveLodFromGameObject = type.GetMethod("RemoveLodFromGameObject");
HDLCPatchProperties.SetShadowQuality = type.GetMethod("SetShadowQuality");
HDLCGraphicsPatch.HDAssetBundle = (AssetBundle)HDLCPatchProperties.GraphicsPatch.GetField("assetBundle").GetValue(HDLCPatchProperties.GraphicsPatchObj);
Logger.LogInfo((object)"References created!");
}
private void SetupConfig()
{
Logger.LogInfo((object)"Setting up config...");
ResolutionScale = ((BaseUnityPlugin)this).Config.Bind<float>("Resolution", "ResolutionScale", 2.233f, "Resolution Scale Multiplier | 1.000 = 860x520p | 2.233 =~ 1920x1080p | 2.977 = 2560x1440p | 4.465 = 3840x2060p");
EnableFog = ((BaseUnityPlugin)this).Config.Bind<bool>("Fog", "EnableFog", true, "Toggles fog on or off");
FogQualityMethod = ((BaseUnityPlugin)this).Config.Bind<FogSettingMethod>("Fog", "FogQualitySettingMethod", FogSettingMethod.Presets, "Changes the method used to set fog quality.");
FogQuality = ((BaseUnityPlugin)this).Config.Bind<FogQualitySetting>("Fog", "FogQuality", FogQualitySetting.Low, "Adjusts the fog quality. Lower values will reduce GPU load.\n\nFogQualitySettingMethod must be set to Presets.");
FogResolutionDepthRatio = ((BaseUnityPlugin)this).Config.Bind<float>("Fog", "FogResolutionDepthRatio", 0.3f, "Affects fog quality.\n\nFogQualitySettingMethod must be set to Sliders.");
VolumetricFogBudget = ((BaseUnityPlugin)this).Config.Bind<float>("Fog", "VolumetricFogBudget", 0.3f, "Affects fog quality.\n\nFogQualitySettingMethod must be set to Sliders.");
ShadowQuality = ((BaseUnityPlugin)this).Config.Bind<QualitySetting>("Shadows", "ShadowQuality", QualitySetting.High, "Adjusts the shadow resolution. Lower values reduce GPU load");
LODQuality = ((BaseUnityPlugin)this).Config.Bind<QualitySetting>("LOD", "LODQuality", QualitySetting.High, "Adjusts the lod (level of detail) distance. Low values reduce GPU load.");
TextureQuality = ((BaseUnityPlugin)this).Config.Bind<QualitySetting>("TextureSettings", "TextureQuality", QualitySetting.High, "Changes texture resolution");
EnableSteamProfileImageFix = ((BaseUnityPlugin)this).Config.Bind<bool>("TextureSettings", "SteamProfileImageFix", true, "Fixes blurry Steam profile images.");
EnablePostProcessing = ((BaseUnityPlugin)this).Config.Bind<bool>("PostProcessing", "EnablePostProcessing", true, "Turns on a color grading post process effect");
EnableFoliage = ((BaseUnityPlugin)this).Config.Bind<bool>("Foliage", "EnableFoliage", true, "Toggles foliage on or off");
EnableResolutionOverride = ((BaseUnityPlugin)this).Config.Bind<bool>("Resolution", "EnableResolutionOverride", true, "Toggles off or on overriding the vanilla resolution");
EnableAntiAliasing = ((BaseUnityPlugin)this).Config.Bind<bool>("AntiAilasing", "EnableAntiAilasing", false, "Toggles anti-ailasing");
DisableFoliageConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Compatability", "DisableFoliageConfig", false, "Disables foliage setting to prevent an issue with certain mods");
AASetting = ((BaseUnityPlugin)this).Config.Bind<AntiAliasingSetting>("AntiAilasing", "AAMode", AntiAliasingSetting.FAA, "Changes the type of anti-ailasing used");
ResolutionMethod = ((BaseUnityPlugin)this).Config.Bind<ResolutionSettingMethod>("Resolution", "ResolutionMethod", ResolutionSettingMethod.ScaleSlider, "Changes how resolution should be set.");
ResolutionPresetValue = ((BaseUnityPlugin)this).Config.Bind<ResolutionPreset>("Resolution", "ResolutionPreset", ResolutionPreset.R1920x1080, "If ResolutionMethod is set to Preset, this setting will be used.");
ResolutionWidth = ((BaseUnityPlugin)this).Config.Bind<int>("Resolution", "ResolutionWidth", 1920, "If ResolutionMethod is set to Custom, this value will be used for resolution width.");
ResolutionHeight = ((BaseUnityPlugin)this).Config.Bind<int>("Resolution", "ResolutionHeight", 1080, "If ResolutionMethod is set to Custom, this value will be used for resolution height.");
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
for (int i = 0; i < assemblies.Length; i++)
{
if (assemblies[i].FullName.Contains("LethalConfig"))
{
Logger.LogInfo((object)"LethalConfig found. Setting up variables...");
SetupLethalConfig();
break;
}
}
Logger.LogInfo((object)"Config setup complete!");
}
private void SetupLethalConfig()
{
LCHDPatchConfigSettings.Setup();
ResolutionScale.SettingChanged += SettingsChanged;
FogQuality.SettingChanged += SettingsChanged;
EnableFog.SettingChanged += SettingsChanged;
LODQuality.SettingChanged += SettingsChanged;
ShadowQuality.SettingChanged += SettingsChanged;
EnablePostProcessing.SettingChanged += SettingsChanged;
EnableFoliage.SettingChanged += SettingsChanged;
EnableResolutionOverride.SettingChanged += SettingsChanged;
TextureQuality.SettingChanged += SettingsChanged;
EnableSteamProfileImageFix.SettingChanged += SettingsChanged;
EnableAntiAliasing.SettingChanged += SettingsChanged;
AASetting.SettingChanged += SettingsChanged;
ResolutionPresetValue.SettingChanged += SettingsChanged;
ResolutionMethod.SettingChanged += SettingsChanged;
ResolutionHeight.SettingChanged += SettingsChanged;
ResolutionWidth.SettingChanged += SettingsChanged;
FogQualityMethod.SettingChanged += SettingsChanged;
FogResolutionDepthRatio.SettingChanged += SettingsChanged;
VolumetricFogBudget.SettingChanged += SettingsChanged;
Logger.LogInfo((object)"Finished setting variables for Lethal Config and setting up events");
}
private void SettingsChanged(object sender, EventArgs args)
{
Logger.LogInfo((object)"Detected settings change");
HDLCGraphicsPatch.SettingsChanged();
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "HDLethalCompanyPatch";
public const string PLUGIN_NAME = "My first plugin";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace HDLethalCompanyPatch.patches
{
internal class HDLCGraphicsPatch
{
public static bool CanChangeFog = false;
public static LayerMask DefaultCullingMask = LayerMask.op_Implicit(0);
public static AssetBundle HDAssetBundle = null;
public static PlayerControllerB PlayerRef;
public static bool MaskRemoved = false;
public static bool StartCalled = false;
public static int RenderResolutionWidth = 1;
public static int RenderResolutionHeight = 1;
public static Vector2 GameResolution = new Vector2(860f, 520f);
private const int _DefaultFontSize = 30;
public static Vector2 OriginalScale = default(Vector2);
public static bool OriginalScaleSet = false;
public static float FontScale = 1f;
public static int CurrentFontWidth = 0;
public static void SettingsChanged()
{
try
{
HDLCPatch.Logger.LogInfo((object)"Applying settings changes...");
if ((Object)(object)PlayerRef != (Object)null)
{
try
{
SetCameraData(PlayerRef);
}
catch (Exception ex)
{
HDLCPatch.Logger.LogError((object)("Failed to set camera related settings\n" + ex.ToString()));
}
try
{
SetResolution(PlayerRef);
}
catch (Exception ex2)
{
HDLCPatch.Logger.LogError((object)("Failed to set resolution\n" + ex2.ToString()));
}
}
try
{
SetTextureQuality();
}
catch (Exception ex3)
{
HDLCPatch.Logger.LogError((object)("Failed to set texture quality\n" + ex3.ToString()));
}
HDLCPatch.Logger.LogInfo((object)"Settings applied");
}
catch (Exception ex4)
{
HDLCPatch.Logger.LogError((object)"Failed to change settings!");
HDLCPatch.Logger.LogError((object)ex4.ToString());
HDLCPatch.Logger.LogInfo((object)"Attempting to try reset internal methods");
try
{
HDLCPatch.SetupInternalMethods(HDLCPatch.HarmonyGetAssembly("HDLethalCompany"));
HDLCPatch.Logger.LogInfo((object)"Reset may have succeded. Try changing settings again");
}
catch (Exception ex5)
{
HDLCPatch.Logger.LogFatal((object)"Failed to setup internal method references");
HDLCPatch.Logger.LogError((object)ex5.ToString());
}
}
}
public static void SetCameraData(PlayerControllerB player)
{
HDAdditionalCameraData[] array = Resources.FindObjectsOfTypeAll<HDAdditionalCameraData>();
foreach (HDAdditionalCameraData val in array)
{
if (!(((Object)((Component)val).gameObject).name == "MapCamera"))
{
val.customRenderingSettings = true;
SetFogQuality(val);
TogglePostProcessing(val);
SetLODQuality(val);
try
{
HDLCPatchProperties.SetShadowQuality.Invoke(HDLCPatchProperties.GraphicsPatchObj, new object[2] { HDAssetBundle, val });
}
catch (Exception ex)
{
Console.WriteLine("Failed to set shadow quality HDLC reference missing...\n" + ex.ToString());
}
ToggleFoliage(val);
if (!(((Object)((Component)val).gameObject).name == "SecurityCamera") && !(((Object)((Component)val).gameObject).name == "ShipCamera"))
{
SetAntiAliasing(val);
}
}
}
}
public static void ToggleFoliage(HDAdditionalCameraData cam)
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
if (!HDLCPatch.DisableFoliageConfig.Value)
{
if (!HDLCPatch.EnableFoliage.Value)
{
LayerMask val = LayerMask.op_Implicit(((Component)cam).GetComponent<Camera>().cullingMask);
val = LayerMask.op_Implicit(LayerMask.op_Implicit(val) & -1025);
((Component)cam).GetComponent<Camera>().cullingMask = LayerMask.op_Implicit(val);
MaskRemoved = true;
}
else
{
LayerMask val2 = LayerMask.op_Implicit(((Component)cam).GetComponent<Camera>().cullingMask);
val2 = LayerMask.op_Implicit(LayerMask.op_Implicit(val2) | 0x400);
((Component)cam).GetComponent<Camera>().cullingMask = LayerMask.op_Implicit(val2);
MaskRemoved = false;
}
}
}
public static void SetLODQuality(HDAdditionalCameraData camera)
{
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
((BitArray128)(ref camera.renderingPathCustomFrameSettingsOverrideMask.mask))[60u] = true;
((BitArray128)(ref camera.renderingPathCustomFrameSettingsOverrideMask.mask))[61u] = true;
((FrameSettings)(ref camera.renderingPathCustomFrameSettings)).SetEnabled((FrameSettingsField)60, true);
((FrameSettings)(ref camera.renderingPathCustomFrameSettings)).SetEnabled((FrameSettingsField)61, true);
camera.renderingPathCustomFrameSettings.lodBiasMode = (LODBiasMode)2;
switch (HDLCPatch.LODQuality.Value)
{
case QualitySetting.VeryLow:
camera.renderingPathCustomFrameSettings.lodBias = 0.6f;
break;
case QualitySetting.Low:
camera.renderingPathCustomFrameSettings.lodBias = 0.9f;
break;
case QualitySetting.Medium:
camera.renderingPathCustomFrameSettings.lodBias = 1.6f;
break;
case QualitySetting.High:
camera.renderingPathCustomFrameSettings.lodBias = 2.3f;
break;
}
}
public static void SetResolution(PlayerControllerB player)
{
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
int num = 860;
int num2 = 520;
if (HDLCPatch.ResolutionMethod.Value == ResolutionSettingMethod.ScaleSlider)
{
num = (int)Math.Round(860f * HDLCPatch.ResolutionScale.Value, 0);
num2 = (int)Math.Round(520f * HDLCPatch.ResolutionScale.Value, 0);
}
else if (HDLCPatch.ResolutionMethod.Value == ResolutionSettingMethod.Presets)
{
switch (HDLCPatch.ResolutionPresetValue.Value)
{
case ResolutionPreset.R640x480:
num = 640;
num2 = 480;
break;
case ResolutionPreset.R1280x720:
num2 = 720;
num = 1280;
break;
case ResolutionPreset.R1920x1080:
num = 1920;
num2 = 1080;
break;
case ResolutionPreset.R2560x1440:
num = 2560;
num2 = 1440;
break;
case ResolutionPreset.R3840x2160:
num2 = 2160;
num = 3840;
break;
}
}
else if (HDLCPatch.ResolutionMethod.Value == ResolutionSettingMethod.Custom)
{
num = HDLCPatch.ResolutionWidth.Value;
num2 = HDLCPatch.ResolutionHeight.Value;
}
if (!HDLCPatch.EnableResolutionOverride.Value)
{
num2 = 520;
num = 860;
}
RenderResolutionHeight = num2;
RenderResolutionWidth = num;
GameResolution = new Vector2((float)num, (float)num2);
player.gameplayCamera.targetTexture.Release();
((Texture)player.gameplayCamera.targetTexture).width = num;
((Texture)player.gameplayCamera.targetTexture).height = num2;
player.gameplayCamera.targetTexture.Create();
}
public static Vector2 GetNormalizedAspectRatio(int width, int height)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
Vector2 aspectRatio = GetAspectRatio(width, height);
Vector2 val = default(Vector2);
((Vector2)(ref val))..ctor((float)width, (float)height);
return aspectRatio / val;
}
public static Vector2 GetAspectRatio(int width, int height)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
int gCD = GetGCD(width, height);
return new Vector2((float)(width / gCD), (float)(height / gCD));
}
public static int GetGCD(int a, int b)
{
while (a != 0 && b != 0)
{
if (a > b)
{
a %= b;
}
else
{
b %= a;
}
}
return a | b;
}
public static void SetShadowQuality()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_013a: Unknown result type (might be due to invalid IL or missing references)
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_0162: Unknown result type (might be due to invalid IL or missing references)
//IL_0182: Unknown result type (might be due to invalid IL or missing references)
//IL_0196: Unknown result type (might be due to invalid IL or missing references)
//IL_01af: Unknown result type (might be due to invalid IL or missing references)
//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
HDShadowInitParameters hdShadowInitParams = ((HDRenderPipelineAsset)QualitySettings.renderPipeline).currentPlatformRenderPipelineSettings.hdShadowInitParams;
HDLCPatch.Logger.LogInfo((object)("----Shadow Settings----\n" + $"AllowDirectionalMixedCachedShadows: {hdShadowInitParams.allowDirectionalMixedCachedShadows}\n" + $"AreaShadowFilteringQuality: {hdShadowInitParams.areaShadowFilteringQuality}\n" + $"DirectionalShadowsDepthBits: {hdShadowInitParams.directionalShadowsDepthBits}\n" + $"MaxAreaShadowMapResolution: {hdShadowInitParams.maxAreaShadowMapResolution}\n" + $"MaxDirectionalShadowMapResolution: {hdShadowInitParams.maxDirectionalShadowMapResolution}\n" + $"MaxPunctualShadowMapResolution: {hdShadowInitParams.maxPunctualShadowMapResolution}\n" + $"ShadowResolutionDirectional: {hdShadowInitParams.shadowResolutionDirectional}\n" + $"MaxShadowRequests: {hdShadowInitParams.maxShadowRequests}\n" + $"ScreenSpaceShadowBufferFormat: {hdShadowInitParams.screenSpaceShadowBufferFormat}\n" + $"SupportScreenSpaceShadows: {hdShadowInitParams.supportScreenSpaceShadows}\n" + $"ShadowResolutionPunctual: {((ScalableSetting<int>)(object)hdShadowInitParams.shadowResolutionPunctual)[0]},{((ScalableSetting<int>)(object)hdShadowInitParams.shadowResolutionPunctual)[1]},{((ScalableSetting<int>)(object)hdShadowInitParams.shadowResolutionPunctual)[2]},{((ScalableSetting<int>)(object)hdShadowInitParams.shadowResolutionPunctual)[3]}\n" + $"ShadowResolutionArea: {hdShadowInitParams.shadowResolutionArea}\n" + $"CachedPunctualLightShadowAtlas: {hdShadowInitParams.cachedPunctualLightShadowAtlas}\n" + $"CachedAreaLightShadowAtlas: {hdShadowInitParams.cachedAreaLightShadowAtlas}\n" + $"AreaLightShadowAtlas.ShadowAtlasResolution: {hdShadowInitParams.areaLightShadowAtlas.shadowAtlasResolution}\n" + $"AreaLightShadowAtlas.UseDynamicViewportRescale: {hdShadowInitParams.areaLightShadowAtlas.useDynamicViewportRescale}\n" + "-----------------------"));
}
public static void TogglePostProcessing(HDAdditionalCameraData camera)
{
((BitArray128)(ref camera.renderingPathCustomFrameSettingsOverrideMask.mask))[6u] = true;
((FrameSettings)(ref camera.renderingPathCustomFrameSettings)).SetEnabled((FrameSettingsField)6, HDLCPatch.EnablePostProcessing.Value);
}
public static void SetFogQuality(HDAdditionalCameraData camera)
{
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
if (!CanChangeFog)
{
return;
}
((BitArray128)(ref camera.renderingPathCustomFrameSettingsOverrideMask.mask))[28u] = true;
((FrameSettings)(ref camera.renderingPathCustomFrameSettings)).SetEnabled((FrameSettingsField)28, HDLCPatch.EnableFog.Value);
try
{
Volume[] array = Object.FindObjectsByType<Volume>((FindObjectsSortMode)0);
BoolParameter enabled = new BoolParameter(HDLCPatch.EnableFog.Value, false);
Fog val = default(Fog);
for (int i = 0; i < array.Length; i++)
{
if (!array[i].sharedProfile.TryGet<Fog>(ref val))
{
continue;
}
val.enabled = enabled;
((VolumeParameter<int>)(object)((VolumeComponentWithQuality)val).quality).Override(3);
if (HDLCPatch.FogQualityMethod.Value == FogSettingMethod.Presets)
{
switch (HDLCPatch.FogQuality.Value)
{
case FogQualitySetting.Minimal:
val.volumetricFogBudget = 0.01f;
val.resolutionDepthRatio = 0.1f;
break;
case FogQualitySetting.VeryLow:
val.volumetricFogBudget = 0.025f;
val.resolutionDepthRatio = 0.2f;
break;
case FogQualitySetting.Low:
val.volumetricFogBudget = 0.1f;
val.resolutionDepthRatio = 0.45f;
break;
case FogQualitySetting.Medium:
val.volumetricFogBudget = 0.35f;
val.resolutionDepthRatio = 0.6f;
break;
case FogQualitySetting.High:
val.volumetricFogBudget = 0.55f;
val.resolutionDepthRatio = 0.7f;
break;
case FogQualitySetting.Extreme:
val.volumetricFogBudget = 0.75f;
val.resolutionDepthRatio = 0.8f;
break;
}
}
else
{
val.volumetricFogBudget = HDLCPatch.VolumetricFogBudget.Value;
val.resolutionDepthRatio = HDLCPatch.FogResolutionDepthRatio.Value;
}
}
}
catch (Exception ex)
{
HDLCPatch.Logger.LogError((object)("Failed to set fog!\n" + ex.ToString()));
}
}
public static void SetTextureQuality()
{
QualitySettings.globalTextureMipmapLimit = (int)(3 - HDLCPatch.TextureQuality.Value);
}
public static void SetAntiAliasing(HDAdditionalCameraData camera)
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
if (HDLCPatch.EnableAntiAliasing.Value)
{
switch (HDLCPatch.AASetting.Value)
{
case AntiAliasingSetting.FAA:
camera.antialiasing = (AntialiasingMode)1;
break;
case AntiAliasingSetting.TAA:
camera.antialiasing = (AntialiasingMode)2;
break;
case AntiAliasingSetting.SMAA:
camera.antialiasing = (AntialiasingMode)3;
break;
default:
camera.antialiasing = (AntialiasingMode)3;
break;
}
}
else
{
camera.antialiasing = (AntialiasingMode)0;
}
}
[HarmonyPatch(typeof(HUDManager), "GetTextureFromImage")]
[HarmonyPostfix]
public static Texture2D GetTextureFromImagePostfix(Texture2D __result)
{
if (HDLCPatch.EnableSteamProfileImageFix.Value)
{
__result.ignoreMipmapLimit = true;
}
return __result;
}
[HarmonyPatch(typeof(Terminal), "TextPostProcess")]
[HarmonyPostfix]
public static string TextPostProcessPostfix(string __result, Terminal __instance)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
if (!OriginalScaleSet)
{
OriginalScale = new Vector2((float)((Texture)__instance.playerScreenTexHighRes).width, (float)((Texture)__instance.playerScreenTexHighRes).height);
HDLCPatch.Logger.LogInfo((object)("SCALE: " + OriginalScale.x + "|" + OriginalScale.y));
OriginalScaleSet = true;
}
CurrentFontWidth = RenderResolutionWidth;
if (((Texture)__instance.playerScreenTexHighRes).width != CurrentFontWidth)
{
__instance.playerScreenTexHighRes.Release();
((Texture)__instance.playerScreenTexHighRes).height = RenderResolutionHeight;
((Texture)__instance.playerScreenTexHighRes).width = RenderResolutionWidth;
__instance.playerScreenTexHighRes.Create();
}
return __result;
}
[HarmonyPatch(typeof(HUDManager), "UpdateScanNodes")]
[HarmonyPostfix]
public static void UpdateScanNodesPostfix(PlayerControllerB playerScript, HUDManager __instance, Dictionary<RectTransform, ScanNodeProperties> ___scanNodes)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < __instance.scanElements.Length; i++)
{
if (___scanNodes.TryGetValue(__instance.scanElements[i], out var value))
{
Vector3 val = playerScript.gameplayCamera.WorldToViewportPoint(((Component)value).transform.position);
__instance.scanElements[i].anchoredPosition = new Vector2(-450.65f + 901.3f * val.x, -261.575f + 523.15f * val.y);
}
}
}
[HarmonyPatch(typeof(MenuManager), "SetLoadingScreen")]
[HarmonyPrefix]
public static void SetLoadingScreenPrefix()
{
StartCalled = false;
}
[HarmonyPatch(typeof(PlayerControllerB), "Start")]
[HarmonyPrefix]
public static void StartPrefix(PlayerControllerB __instance)
{
if (!StartCalled)
{
CanChangeFog = true;
PlayerRef = __instance;
StartCalled = true;
SettingsChanged();
}
}
[HarmonyPatch(typeof(RoundManager), "GenerateNewFloor")]
[HarmonyPrefix]
public static void RoundPrefix(PlayerControllerB __instance)
{
CanChangeFog = false;
}
[HarmonyPatch(typeof(RoundManager), "GenerateNewFloor")]
[HarmonyPostfix]
public static void RoundPostfix(PlayerControllerB __instance)
{
CanChangeFog = true;
SettingsChanged();
if (HDLCPatch.LODQuality.Value == QualitySetting.VeryLow)
{
HDLCPatch.Logger.LogInfo((object)"Removing catwalk stairs lod");
HDLCPatchProperties.RemoveLodFromGameObject.Invoke(HDLCPatchProperties.GraphicsPatchObj, new object[1] { "CatwalkStairs" });
}
}
}
[HarmonyPatch]
internal class HDLCSetFogQualityPatch
{
private static MethodBase TargetMethod()
{
return AccessTools.Method(AccessTools.TypeByName("HDLethalCompany.Patch.GraphicsPatch"), "SetFogQuality", (Type[])null, (Type[])null);
}
public static void Prefix(object __instance)
{
}
}
}
namespace HDLethalCompanyPatch.config
{
public static class LCHDPatchConfigSettings
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static GenericButtonHandler <>9__21_0;
internal void <Setup>b__21_0()
{
HDLCGraphicsPatch.SettingsChanged();
}
}
public static EnumDropDownConfigItem<QualitySetting> ShadowQualityItem;
public static EnumDropDownConfigItem<QualitySetting> LODQualityItem;
public static EnumDropDownConfigItem<QualitySetting> TextureQualityItem;
public static EnumDropDownConfigItem<FogQualitySetting> FogQualityItem;
public static EnumDropDownConfigItem<AntiAliasingSetting> AASettingItem;
public static EnumDropDownConfigItem<ResolutionSettingMethod> ResolutionMethodItem;
public static EnumDropDownConfigItem<ResolutionPreset> ResolutionPresetItem;
public static EnumDropDownConfigItem<FogSettingMethod> FogSettingMethodItem;
public static FloatSliderConfigItem ResolutionScaleItem;
public static FloatSliderConfigItem VolumetricFogBudgetItem;
public static FloatSliderConfigItem FogResolutionDepthRatioItem;
public static FloatSliderConfigItem FontScaleItem;
public static IntInputFieldConfigItem ResolutionWidthItem;
public static IntInputFieldConfigItem ResolutionHeightItem;
public static BoolCheckBoxConfigItem EnableFogItem;
public static BoolCheckBoxConfigItem EnablePostProcessingItem;
public static BoolCheckBoxConfigItem EnableFoliageItem;
public static BoolCheckBoxConfigItem EnableResolutionOverrideItem;
public static BoolCheckBoxConfigItem EnableAntiAliasingItem;
public static BoolCheckBoxConfigItem DisableFoliageConfigItem;
public static BoolCheckBoxConfigItem EnableSteamProfileImageFixItem;
public static void Setup()
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Expected O, but got Unknown
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Expected O, but got Unknown
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Expected O, but got Unknown
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Expected O, but got Unknown
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Expected O, but got Unknown
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Expected O, but got Unknown
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Expected O, but got Unknown
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Expected O, but got Unknown
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Expected O, but got Unknown
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Expected O, but got Unknown
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Expected O, but got Unknown
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Expected O, but got Unknown
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Expected O, but got Unknown
//IL_0123: Unknown result type (might be due to invalid IL or missing references)
//IL_012d: Expected O, but got Unknown
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
//IL_014d: Expected O, but got Unknown
//IL_0183: Unknown result type (might be due to invalid IL or missing references)
//IL_018d: Expected O, but got Unknown
//IL_0193: Unknown result type (might be due to invalid IL or missing references)
//IL_019d: Expected O, but got Unknown
//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
//IL_01ad: Expected O, but got Unknown
//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
//IL_02b2: Expected O, but got Unknown
//IL_029d: Unknown result type (might be due to invalid IL or missing references)
//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
//IL_02a8: Expected O, but got Unknown
LethalConfigManager.SetModDescription("A patch mod for HDLethalCompany that also includes runtime configs through LethalConfig");
ConfigEntry<float> resolutionScale = HDLCPatch.ResolutionScale;
FloatSliderOptions val = new FloatSliderOptions();
((BaseRangeOptions<float>)val).Max = 4.465f;
((BaseRangeOptions<float>)val).Min = 0.25f;
((BaseOptions)val).RequiresRestart = false;
ResolutionScaleItem = new FloatSliderConfigItem(resolutionScale, val);
EnableFogItem = new BoolCheckBoxConfigItem(HDLCPatch.EnableFog, false);
FogSettingMethodItem = new EnumDropDownConfigItem<FogSettingMethod>(HDLCPatch.FogQualityMethod, false);
FogQualityItem = new EnumDropDownConfigItem<FogQualitySetting>(HDLCPatch.FogQuality, false);
ConfigEntry<float> fogResolutionDepthRatio = HDLCPatch.FogResolutionDepthRatio;
FloatSliderOptions val2 = new FloatSliderOptions();
((BaseRangeOptions<float>)val2).Max = 1f;
((BaseRangeOptions<float>)val2).Min = 0.01f;
((BaseOptions)val2).RequiresRestart = false;
FogResolutionDepthRatioItem = new FloatSliderConfigItem(fogResolutionDepthRatio, val2);
ConfigEntry<float> volumetricFogBudget = HDLCPatch.VolumetricFogBudget;
FloatSliderOptions val3 = new FloatSliderOptions();
((BaseRangeOptions<float>)val3).Min = 0.01f;
((BaseRangeOptions<float>)val3).Max = 1f;
((BaseOptions)val3).RequiresRestart = false;
VolumetricFogBudgetItem = new FloatSliderConfigItem(volumetricFogBudget, val3);
ShadowQualityItem = new EnumDropDownConfigItem<QualitySetting>(HDLCPatch.ShadowQuality, false);
LODQualityItem = new EnumDropDownConfigItem<QualitySetting>(HDLCPatch.LODQuality, false);
EnablePostProcessingItem = new BoolCheckBoxConfigItem(HDLCPatch.EnablePostProcessing, false);
EnableFoliageItem = new BoolCheckBoxConfigItem(HDLCPatch.EnableFoliage, false);
EnableResolutionOverrideItem = new BoolCheckBoxConfigItem(HDLCPatch.EnableResolutionOverride, false);
EnableAntiAliasingItem = new BoolCheckBoxConfigItem(HDLCPatch.EnableAntiAliasing, false);
TextureQualityItem = new EnumDropDownConfigItem<QualitySetting>(HDLCPatch.TextureQuality, false);
DisableFoliageConfigItem = new BoolCheckBoxConfigItem(HDLCPatch.DisableFoliageConfig, true);
AASettingItem = new EnumDropDownConfigItem<AntiAliasingSetting>(HDLCPatch.AASetting, false);
ResolutionMethodItem = new EnumDropDownConfigItem<ResolutionSettingMethod>(HDLCPatch.ResolutionMethod, false);
ResolutionPresetItem = new EnumDropDownConfigItem<ResolutionPreset>(HDLCPatch.ResolutionPresetValue, false);
ResolutionHeightItem = new IntInputFieldConfigItem(HDLCPatch.ResolutionHeight, false);
ResolutionWidthItem = new IntInputFieldConfigItem(HDLCPatch.ResolutionWidth, false);
EnableSteamProfileImageFixItem = new BoolCheckBoxConfigItem(HDLCPatch.EnableSteamProfileImageFix, false);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)EnableResolutionOverrideItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)ResolutionMethodItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)ResolutionScaleItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)ResolutionPresetItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)ResolutionWidthItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)ResolutionHeightItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)FogSettingMethodItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)FogQualityItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)FogResolutionDepthRatioItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)VolumetricFogBudgetItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)ShadowQualityItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)LODQualityItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)TextureQualityItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)EnableSteamProfileImageFixItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)EnablePostProcessingItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)EnableFogItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)EnableFoliageItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)EnableAntiAliasingItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)DisableFoliageConfigItem);
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)AASettingItem);
object obj = <>c.<>9__21_0;
if (obj == null)
{
GenericButtonHandler val4 = delegate
{
HDLCGraphicsPatch.SettingsChanged();
};
<>c.<>9__21_0 = val4;
obj = (object)val4;
}
LethalConfigManager.AddConfigItem((BaseConfigItem)new GenericButtonConfigItem("Commands", "ForceSettingsChange", "Makes a call to HDLC to run a settings change event. \nUse this if internal references failed to set on first change", "Force Change Settings", (GenericButtonHandler)obj));
}
}
}
