using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using Badgers_Shading_Overhaul.Gui;
using Badgers_Shading_Overhaul.Gui.GUIScriptComponents;
using Badgers_Shading_Overhaul.Properties;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Badgers_Shading_Overhaul")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Badgers_Shading_Overhaul")]
[assembly: AssemblyCopyright("Copyright © 2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("d972bffe-cbf4-4b17-8276-007e986e6195")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Badgers_Shading_Overhaul
{
internal class BVTAssets
{
private AssetBundle GUIAssetBundle;
private Dictionary<string, Mesh> bvtMeshes = new Dictionary<string, Mesh>();
private GameObject BVTCanvas = null;
private GameObject BVTSliderWidget = null;
private GameObject BVTButtonWidget = null;
private GameObject BVTLabelWidget = null;
private GameObject BVTToggleWidget = null;
private GameObject ClockWidget = null;
public bool assetsLoaded = false;
public BVTAssets()
{
LoadAssets();
}
public void LoadAssets()
{
byte[] guiassets = Resources.guiassets;
GUIAssetBundle = AssetBundle.LoadFromMemory(guiassets);
if (!((Object)(object)GUIAssetBundle != (Object)null))
{
return;
}
bLog.Log("Loading GUI Assets", force: true);
string[] allAssetNames = GUIAssetBundle.GetAllAssetNames();
foreach (string text in allAssetNames)
{
GameObject val = GUIAssetBundle.LoadAsset<GameObject>(text);
switch (((Object)val).name)
{
case "Canvas":
BVTCanvas = val;
break;
case "SliderWidget":
BVTSliderWidget = val;
break;
case "ButtonWidget":
BVTButtonWidget = val;
break;
case "LabelWidget":
BVTLabelWidget = val;
break;
case "ToggleWidget":
BVTToggleWidget = val;
break;
}
}
assetsLoaded = true;
GUIAssetBundle.Unload(false);
guiassets = null;
}
public GameObject GetCanvas()
{
if ((Object)(object)BVTCanvas != (Object)null)
{
return BVTCanvas;
}
return null;
}
public GameObject GetSliderWidget()
{
if ((Object)(object)BVTSliderWidget != (Object)null)
{
return BVTSliderWidget;
}
return null;
}
public GameObject GetButtonWidget()
{
if ((Object)(object)BVTButtonWidget != (Object)null)
{
return BVTButtonWidget;
}
return null;
}
public GameObject GetLabelWidget()
{
if ((Object)(object)BVTLabelWidget != (Object)null)
{
return BVTLabelWidget;
}
return null;
}
public GameObject GetToggleWidget()
{
if ((Object)(object)BVTToggleWidget != (Object)null)
{
return BVTToggleWidget;
}
return null;
}
public GameObject GetClockWidget()
{
if ((Object)(object)ClockWidget != (Object)null)
{
return ClockWidget;
}
return null;
}
}
public class CameraPostProcess : MonoBehaviour
{
private RenderTexture rt = null;
private void OnPreRender()
{
Mod.mainCamera.targetTexture = rt;
}
private void OnRenderImage(RenderTexture src, RenderTexture dest)
{
if ((Object)(object)Mod.PostProcessMaterial != (Object)null && Mod.config.CleanShadingOn.Value)
{
Mod.mainCamera.targetTexture = null;
Graphics.Blit((Texture)(object)src, (RenderTexture)null, Mod.PostProcessMaterial);
}
else
{
Graphics.Blit((Texture)(object)src, dest);
}
}
}
internal class Config
{
private ConfigFile cf = new ConfigFile(Mod.ConfigFile, true);
public ConfigEntry<float> AmbientLight;
public ConfigEntry<bool> CleanShadingOn;
public ConfigEntry<KeyCode> ModToggleKey;
public ConfigEntry<bool> DebugInfo;
public ConfigEntry<float> SpecularIntensity;
public ConfigEntry<float> ColorTemp;
public ConfigEntry<float> ColorSaturation;
public Config()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
CleanShadingOn = cf.Bind<bool>("Mod", "Enable Smooth Shading", true, "Enable Smooth Shading");
ModToggleKey = cf.Bind<KeyCode>("Mod", "Key to enable/disable mod", (KeyCode)281, "Mod Toggle Key");
DebugInfo = cf.Bind<bool>("Mod", "Enable debug information", false, "Enable debug information");
SpecularIntensity = cf.Bind<float>("Visual", "Specular Intensity", 0f, "Specular Intensity");
AmbientLight = cf.Bind<float>("Visual", "Ambient Light Modifier", 0.9f, "Ambient Light Modifier");
ColorTemp = cf.Bind<float>("Visual", "Colour Temperature", 0f, "Colour Temperature");
ColorSaturation = cf.Bind<float>("Visual", "Colour Saturation", 1f, "Colour Saturation");
}
}
internal class MouseDragComponent : MonoBehaviour, IDragHandler, IEventSystemHandler, IBeginDragHandler, IEndDragHandler
{
private Vector2 dragStartPosition;
private Vector2 menuPos;
private Vector2 pointerOffset;
public void OnBeginDrag(PointerEventData eventData)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: 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_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: 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_0030: 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)
menuPos = Vector2.op_Implicit(((Transform)((Component)this).GetComponent<RectTransform>()).position);
dragStartPosition = eventData.position;
pointerOffset = dragStartPosition - menuPos;
}
public void OnDrag(PointerEventData eventData)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: 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_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: 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)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
Vector2 position = eventData.position;
Vector2 val = position - dragStartPosition;
menuPos += val;
((Transform)((Component)this).GetComponent<RectTransform>()).position = Vector2.op_Implicit(menuPos + val);
dragStartPosition = position;
}
public void OnEndDrag(PointerEventData eventData)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: 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)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
((Transform)((Component)this).GetComponent<RectTransform>()).position = Vector2.op_Implicit(eventData.position - pointerOffset);
}
}
internal class HarmonyPatches
{
[HarmonyPatch(typeof(Player), "Awake")]
private class Player_Awake
{
private static void Postfix(Player __instance)
{
Mod.UpdateShader();
Mod.AddConsoleCommands();
Mod.CreateUI();
Mod.AddCameraComponents();
Mod.CreatePostProcessShader();
Mod.SetShaderProperties();
}
}
[HarmonyPatch(typeof(EnvMan), "Awake")]
private class EnvMan_Awake
{
[HarmonyPriority(0)]
private static void Postfix(EnvMan __instance)
{
Mod.envMan = __instance;
bLog.Log("Preparing envs");
Mod.dayIntensities.Clear();
Mod.nightIntensities.Clear();
bLog.Log("Existing envs");
foreach (EnvSetup environment in __instance.m_environments)
{
bLog.Log("Preparing env " + environment.m_name);
if (!Mod.dayIntensities.ContainsKey(environment))
{
Mod.dayIntensities.Add(environment, environment.m_lightIntensityDay);
Mod.nightIntensities.Add(environment, environment.m_lightIntensityNight);
}
else
{
bLog.Log("Couldn't add environment " + environment.m_name + " as it has already been added.");
}
}
}
}
[HarmonyPatch(typeof(EnvMan), "SetEnv")]
private class EnvMan_SetEnv
{
private static void Postfix(EnvMan __instance)
{
Mod.UpdateEnvs(__instance);
}
}
private readonly Harmony harmony = new Harmony("Badgers.ShadingOverhaul");
public HarmonyPatches()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
harmony.PatchAll();
}
}
internal class bLog
{
public static bool debugEnabled = Mod.config.DebugInfo.Value;
public static string logLabel = "BSO";
public static void Log(string LogMessage, bool force = false)
{
if (debugEnabled || force)
{
Debug.Log((object)(logLabel + ": " + LogMessage));
}
}
}
[BepInPlugin("Badgers.ShadingOverhaul", "Badgers Shading Overhaul", "0.3.2")]
[BepInProcess("valheim.exe")]
public class Badgers_Shading_Overhaul : BaseUnityPlugin
{
private HarmonyPatches ShadingOverhaul;
private byte[] abBytes;
private AssetBundle ab;
private void Awake()
{
ShadingOverhaul = new HarmonyPatches();
abBytes = Resources.deferredshaders;
ab = AssetBundle.LoadFromMemory(abBytes);
Mod.ReplacementShader = ab.LoadAsset<Shader>("Internal-DeferredShading");
Mod.PostProcessShader = ab.LoadAsset<Shader>("PostProcess");
ab.Unload(false);
abBytes = null;
Mod.OriginalShader = GraphicsSettings.GetCustomShader((BuiltinShaderType)0);
}
private void Update()
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)Player.m_localPlayer == (Object)null) || Mod.DevMode)
{
if (Input.GetKeyDown(Mod.config.ModToggleKey.Value))
{
Mod.UI.ToggleMenu();
}
if (Input.GetKeyDown((KeyCode)27) && Mod.UI.showMenu)
{
Mod.UI.ToggleMenu();
}
}
}
}
internal static class Mod
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static ConsoleEvent <>9__16_0;
internal void <AddConsoleCommands>b__16_0(ConsoleEventArgs args)
{
float value = default(float);
args.TryParameterFloat(1, ref value);
config.AmbientLight.Value = value;
}
}
public static string ConfigPath = Paths.ConfigPath;
public static string PluginPath = Paths.PluginPath;
public static string ConfigFile = Path.Combine(ConfigPath, "BadgersShadingOverhaul.cfg");
public static Config config = new Config();
private static BVTAssets bvtAssets = new BVTAssets();
public static BVTUI UI;
private static List<string> Category = new List<string> { "Mod Config" };
public static Dictionary<EnvSetup, float> dayIntensities = new Dictionary<EnvSetup, float>();
public static Dictionary<EnvSetup, float> nightIntensities = new Dictionary<EnvSetup, float>();
public static Shader ReplacementShader;
public static Shader OriginalShader;
public static Shader PostProcessShader;
public static Material PostProcessMaterial;
public static Camera mainCamera;
public static EnvMan envMan;
public static bool DevMode = false;
public static void AddConsoleCommands()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//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)
//IL_002a: Expected O, but got Unknown
object obj = <>c.<>9__16_0;
if (obj == null)
{
ConsoleEvent val = delegate(ConsoleEventArgs args)
{
float value = default(float);
args.TryParameterFloat(1, ref value);
config.AmbientLight.Value = value;
};
<>c.<>9__16_0 = val;
obj = (object)val;
}
new ConsoleCommand("setambientlight", "Set the ambient light modifier", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false);
}
public static void UpdateEnvs(EnvMan instance)
{
if ((Object)(object)instance != (Object)null && dayIntensities.ContainsKey(instance.m_currentEnv))
{
if (config.CleanShadingOn.Value)
{
instance.m_currentEnv.m_lightIntensityDay = dayIntensities[instance.m_currentEnv] * config.AmbientLight.Value;
instance.m_currentEnv.m_lightIntensityNight = nightIntensities[instance.m_currentEnv] * config.AmbientLight.Value;
}
else
{
instance.m_currentEnv.m_lightIntensityDay = dayIntensities[instance.m_currentEnv];
instance.m_currentEnv.m_lightIntensityNight = nightIntensities[instance.m_currentEnv];
}
}
}
public static void SetShaderProperties()
{
Shader.SetGlobalFloat("_BSOSpecularIntensity", 1f + config.SpecularIntensity.Value * 0.05f);
}
public static void UpdateShader()
{
bLog.Log("Updating Shader");
if (config.CleanShadingOn.Value)
{
bLog.Log("Using New Shader");
GraphicsSettings.SetCustomShader((BuiltinShaderType)0, ReplacementShader);
}
else
{
GraphicsSettings.SetCustomShader((BuiltinShaderType)0, OriginalShader);
}
}
public static void CreateUI()
{
UI = new BVTUI(bvtAssets);
if (!UI.UICreated)
{
return;
}
bLog.Log("Creating UI Panels", force: true);
UI.SetupMainPanel(HandleCanvasDropDown, Category, "Shading Overhaul Configuration");
foreach (string item in Category)
{
string text = item;
string text2 = text;
if (text2 == "Mod Config")
{
CreateModConfig(item);
}
}
}
private static void CreateModConfig(string PanelName)
{
UIPanel uIPanel = UI.CreateUIPanel(PanelName);
if (uIPanel != null)
{
uIPanel.AddToggleWidget("Mod Enabled", config.CleanShadingOn.Value, HandleModToggle);
uIPanel.AddSliderWidget(ref config.SpecularIntensity, -1f, 1f, HandleSpecIntensity);
uIPanel.AddSliderWidget(ref config.AmbientLight, 0f, 2f, HandleAmbientLight);
uIPanel.AddSliderWidget(ref config.ColorTemp, -1f, 1f, HandleColorTemp);
uIPanel.AddSliderWidget(ref config.ColorSaturation, 0f, 2f, HandleColorSaturation);
UI.AddUIPanel(uIPanel, SetActive: true);
}
}
private static void HandleColorSaturation(float value, string title)
{
if ((Object)(object)PostProcessMaterial != (Object)null)
{
PostProcessMaterial.SetFloat("_Saturation", value);
}
}
private static void HandleColorTemp(float value, string title)
{
if ((Object)(object)PostProcessMaterial != (Object)null)
{
PostProcessMaterial.SetFloat("_Temperature", value);
}
}
private static void HandleAmbientLight(float value, string title)
{
config.AmbientLight.Value = value;
UpdateEnvs(envMan);
}
private static void HandleSpecIntensity(float value, string title)
{
config.SpecularIntensity.Value = value;
SetShaderProperties();
}
private static void HandleModToggle(Toggle t)
{
config.CleanShadingOn.Value = t.isOn;
UpdateShader();
}
private static void HandleCanvasDropDown(Dropdown dd)
{
bLog.Log("setting " + Category[dd.value] + " panel active");
UI.SetActiveUIPanel(Category[dd.value]);
}
public static void AddCameraComponents()
{
mainCamera = Utils.GetMainCamera();
if ((Object)(object)mainCamera != (Object)null)
{
((Component)mainCamera).gameObject.AddComponent<CameraPostProcess>();
}
}
public static void CreatePostProcessShader()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
PostProcessMaterial = new Material(PostProcessShader);
((Object)PostProcessMaterial).name = "BSOPostProcessMaterial";
((Object)PostProcessMaterial).hideFlags = (HideFlags)61;
PostProcessMaterial.SetFloat("_Temperature", config.ColorTemp.Value);
PostProcessMaterial.SetFloat("_Saturation", config.ColorSaturation.Value);
}
}
}
namespace Badgers_Shading_Overhaul.Properties
{
[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
[DebuggerNonUserCode]
[CompilerGenerated]
internal class Resources
{
private static ResourceManager resourceMan;
private static CultureInfo resourceCulture;
[EditorBrowsable(EditorBrowsableState.Advanced)]
internal static ResourceManager ResourceManager
{
get
{
if (resourceMan == null)
{
ResourceManager resourceManager = new ResourceManager("Badgers_Shading_Overhaul.Properties.Resources", typeof(Resources).Assembly);
resourceMan = resourceManager;
}
return resourceMan;
}
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
internal static CultureInfo Culture
{
get
{
return resourceCulture;
}
set
{
resourceCulture = value;
}
}
internal static byte[] deferredshaders
{
get
{
object @object = ResourceManager.GetObject("deferredshaders", resourceCulture);
return (byte[])@object;
}
}
internal static byte[] guiassets
{
get
{
object @object = ResourceManager.GetObject("guiassets", resourceCulture);
return (byte[])@object;
}
}
internal Resources()
{
}
}
}
namespace Badgers_Shading_Overhaul.Gui
{
public delegate void DropdownHandler(Dropdown dd);
public enum WidgetType
{
Slider,
Button
}
internal class BVTUI
{
private GameObject BVTCanvas;
private BVTAssets bvtAssets;
private GameObject widgetSpace = null;
private GameObject mainCanvas = null;
private GameObject mainPanel = null;
private Dictionary<string, UIPanel> UIPanels = new Dictionary<string, UIPanel>();
private string ActiveUIPanelName;
public bool showMenu = false;
public bool UICreated = false;
public BVTUI(BVTAssets AssetBundle)
{
bLog.Log("Attempting to create UI");
if (AssetBundle.assetsLoaded)
{
bvtAssets = AssetBundle;
if (CreateUI())
{
AddUIComponents();
}
bLog.Log("UI created");
UICreated = true;
}
else
{
bLog.Log("Unable to create UI due to missing assets");
}
}
private bool CreateUI()
{
mainCanvas = bvtAssets.GetCanvas();
if ((Object)(object)mainCanvas != (Object)null)
{
BVTCanvas = Object.Instantiate<GameObject>(mainCanvas);
widgetSpace = ((Component)((Transform)BVTCanvas.GetComponent<RectTransform>()).Find("Panel/ScrollView/Viewport/Content/WidgetSpace")).gameObject;
widgetSpace.SetActive(false);
BVTCanvas.SetActive(false);
return true;
}
BVTCanvas = null;
return false;
}
public void SetupMainPanel(DropdownHandler dropDownHandler, List<string> Category, string Title)
{
mainPanel.GetComponent<DropdownComponent>().PopulateItems(Category);
mainPanel.GetComponent<DropdownComponent>().ValueChangedHandler(dropDownHandler);
((Component)mainPanel.transform.Find("TitleText")).GetComponent<Text>().text = Title;
}
public UIPanel CreateUIPanel(string Name)
{
if ((Object)(object)widgetSpace != (Object)null)
{
UIPanel uIPanel = new UIPanel(Name, widgetSpace, BVTCanvas, bvtAssets);
if (uIPanel != null)
{
return uIPanel;
}
}
return null;
}
public void AddUIPanel(UIPanel Panel, bool SetActive = false)
{
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
if (SetActive)
{
Panel.panel.SetActive(true);
ActiveUIPanelName = ((Object)Panel.panel).name;
}
Panel.panel.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, Panel.totalHeight / 2f);
UIPanels.Add(Panel.name, Panel);
}
public void SetActiveUIPanel(string PanelName)
{
if (!(PanelName != ActiveUIPanelName))
{
return;
}
foreach (UIPanel value in UIPanels.Values)
{
if (PanelName == value.name)
{
value.panel.SetActive(true);
ActiveUIPanelName = PanelName;
}
else
{
value.panel.SetActive(false);
}
}
}
public void ToggleMenu()
{
if (!((Object)(object)BVTCanvas != (Object)null))
{
return;
}
if (!showMenu)
{
Cursor.lockState = (CursorLockMode)0;
Cursor.visible = true;
if ((Object)(object)Player.m_localPlayer != (Object)null)
{
((Behaviour)((Component)Player.m_localPlayer).GetComponent<PlayerController>()).enabled = false;
((Behaviour)GameCamera.instance).enabled = false;
}
showMenu = true;
BVTCanvas.SetActive(true);
}
else
{
Cursor.lockState = (CursorLockMode)1;
Cursor.visible = false;
if ((Object)(object)Player.m_localPlayer != (Object)null)
{
((Behaviour)((Component)Player.m_localPlayer).GetComponent<PlayerController>()).enabled = true;
((Behaviour)GameCamera.instance).enabled = true;
}
showMenu = false;
BVTCanvas.SetActive(false);
}
}
private void AddUIComponents()
{
mainPanel = ((Component)((Transform)BVTCanvas.GetComponent<RectTransform>()).Find("Panel")).gameObject;
if ((Object)(object)mainPanel != (Object)null)
{
mainPanel.AddComponent<MouseDragComponent>();
mainPanel.AddComponent<DropdownComponent>();
}
}
}
internal class DropdownComponent : MonoBehaviour
{
private Dropdown dropDown;
public void PopulateItems(List<string> Items)
{
dropDown = ((Component)((Transform)((Component)this).GetComponent<RectTransform>()).Find("CatSelector")).GetComponent<Dropdown>();
dropDown.AddOptions(Items);
}
public void ValueChangedHandler(DropdownHandler dropDownHandler)
{
((UnityEvent<int>)(object)dropDown.onValueChanged).AddListener((UnityAction<int>)delegate
{
dropDownHandler(dropDown);
});
}
}
internal class UIPanel
{
public GameObject panel = null;
public string name;
private BVTAssets bvtAssets;
private float lastWidgetHeight;
private float widgetPanelOffset;
private float widgetPanelSpacing = 80f;
public float totalHeight = 0f;
private List<Toggle> Toggles = new List<Toggle>();
public UIPanel(string Name, GameObject SourcePanel, GameObject MainCanvas, BVTAssets Assets)
{
panel = Object.Instantiate<GameObject>(SourcePanel, ((Component)((Transform)MainCanvas.GetComponent<RectTransform>()).Find("Panel/ScrollView/Viewport/Content")).transform);
name = Name;
bvtAssets = Assets;
}
public bool AddSliderWidget(ref ConfigEntry<float> bvtConfigValue, float MinValue, float MaxValue, SliderHandlerMethod sliderHandlerMethod = null, string precision = "0.00")
{
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
GameObject sliderWidget = bvtAssets.GetSliderWidget();
if ((Object)(object)sliderWidget != (Object)null)
{
GameObject val = Object.Instantiate<GameObject>(((Component)((Transform)sliderWidget.GetComponent<RectTransform>()).Find("Widget")).gameObject, panel.transform);
if ((Object)(object)val != (Object)null)
{
Rect rect = val.GetComponent<RectTransform>().rect;
lastWidgetHeight = ((Rect)(ref rect)).height;
val.AddComponent<SliderWidgetController>();
val.transform.localPosition = new Vector3(0f, widgetPanelOffset, 0f);
widgetPanelOffset = lastWidgetHeight + widgetPanelSpacing;
totalHeight += widgetPanelOffset;
SliderWidgetController component = val.GetComponent<SliderWidgetController>();
if ((Object)(object)component != (Object)null)
{
bLog.Log("Widget Controller added");
component.SetParameters(ref bvtConfigValue, MinValue, MaxValue, sliderHandlerMethod, precision);
}
return true;
}
}
return false;
}
public bool AddBUttonWidget(string Text, handlerMethod HandlerMethod)
{
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
GameObject buttonWidget = bvtAssets.GetButtonWidget();
if ((Object)(object)buttonWidget != (Object)null)
{
GameObject val = Object.Instantiate<GameObject>(((Component)((Transform)buttonWidget.GetComponent<RectTransform>()).Find("Widget")).gameObject, panel.transform);
if ((Object)(object)val != (Object)null)
{
val.AddComponent<ButtonWidgetController>();
Rect rect = val.GetComponent<RectTransform>().rect;
lastWidgetHeight = ((Rect)(ref rect)).height;
val.transform.localPosition = new Vector3(0f, widgetPanelOffset, 0f);
widgetPanelOffset = lastWidgetHeight + widgetPanelSpacing;
ButtonWidgetController component = val.GetComponent<ButtonWidgetController>();
if ((Object)(object)component != (Object)null)
{
bLog.Log("Widget controller addded");
component.SetParameters(Text, HandlerMethod);
}
return true;
}
}
return false;
}
public bool AddLabelWidget(string Text)
{
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
GameObject labelWidget = bvtAssets.GetLabelWidget();
if ((Object)(object)labelWidget != (Object)null)
{
GameObject val = Object.Instantiate<GameObject>(((Component)((Transform)labelWidget.GetComponent<RectTransform>()).Find("Widget")).gameObject, panel.transform);
if ((Object)(object)val != (Object)null)
{
val.AddComponent<LabelWidgetController>();
bLog.Log("Added label widget to UI");
Rect rect = val.GetComponent<RectTransform>().rect;
lastWidgetHeight = ((Rect)(ref rect)).height;
val.transform.localPosition = new Vector3(0f, widgetPanelOffset, 0f);
widgetPanelOffset = lastWidgetHeight + widgetPanelSpacing;
LabelWidgetController component = val.GetComponent<LabelWidgetController>();
if ((Object)(object)component != (Object)null)
{
component.SetParameters(Text);
}
return true;
}
}
return false;
}
public bool AddToggleWidget(string Text, bool state, ToggleHandler toggleHandler)
{
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
GameObject toggleWidget = bvtAssets.GetToggleWidget();
if ((Object)(object)toggleWidget != (Object)null)
{
GameObject val = Object.Instantiate<GameObject>(((Component)((Transform)toggleWidget.GetComponent<RectTransform>()).Find("Widget")).gameObject, panel.transform);
if ((Object)(object)val != (Object)null)
{
val.AddComponent<ToggleWidgetController>();
Toggles.Add(((Component)val.transform.Find("Toggle")).GetComponent<Toggle>());
bLog.Log("Added toggle widget to UI");
Rect rect = val.GetComponent<RectTransform>().rect;
lastWidgetHeight = ((Rect)(ref rect)).height;
val.transform.localPosition = new Vector3(0f, widgetPanelOffset, 0f);
widgetPanelOffset = lastWidgetHeight + widgetPanelSpacing;
ToggleWidgetController component = val.GetComponent<ToggleWidgetController>();
if ((Object)(object)component != (Object)null)
{
component.SetParameters(Text, state, toggleHandler);
}
return true;
}
}
return false;
}
public void ClearToggles()
{
foreach (Toggle toggle in Toggles)
{
toggle.isOn = false;
}
}
}
}
namespace Badgers_Shading_Overhaul.Gui.GUIScriptComponents
{
public delegate void handlerMethod();
internal class ButtonWidgetController : MonoBehaviour
{
public void SetParameters(string Text, handlerMethod HandlerMethod)
{
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Expected O, but got Unknown
((Component)((Component)this).transform.Find("Button/Text")).GetComponent<Text>().text = Text;
((UnityEvent)((Component)((Component)this).transform.Find("Button")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
{
HandlerMethod();
});
}
}
internal class LabelWidgetController : MonoBehaviour
{
public void SetParameters(string Text)
{
((Component)((Component)this).transform.Find("Text")).GetComponent<Text>().text = Text;
}
}
public delegate void SliderHandlerMethod(float value, string title);
internal class SliderWidgetController : MonoBehaviour
{
private string titleText;
private Text title;
private Slider slider;
private InputField textInput;
private float sliderValue;
private float sliderMinValue;
private float sliderMaxValue;
private ConfigEntry<float> bvtConfigItem;
private string precision = "0.00";
public void SetParameters(ref ConfigEntry<float> ConfigValue, float MinSliderValue, float MaxSliderValue, SliderHandlerMethod sliderHandlerMethod = null, string Precision = "0.00")
{
bvtConfigItem = ConfigValue;
titleText = ((ConfigEntryBase)ConfigValue).Description.Description + ", Default Value: " + ((ConfigEntryBase)ConfigValue).DefaultValue.ToString();
sliderMinValue = MinSliderValue;
sliderMaxValue = MaxSliderValue;
sliderValue = ConfigValue.Value;
precision = Precision;
title = ((Component)((Component)this).transform.Find("Title")).GetComponent<Text>();
if ((Object)(object)title != (Object)null)
{
title.text = titleText;
}
SetValues(sliderMinValue, sliderMaxValue, sliderValue, sliderHandlerMethod);
}
private void SetValues(float MinValue, float MaxValue, float Value, SliderHandlerMethod m = null)
{
textInput = ((Component)((Component)this).transform.Find("TextInput")).GetComponent<InputField>();
if ((Object)(object)textInput != (Object)null)
{
((UnityEvent<string>)(object)textInput.onEndEdit).AddListener((UnityAction<string>)delegate
{
OnTextInputChanged(textInput);
});
}
slider = ((Component)((Component)this).transform.Find("Slider")).GetComponent<Slider>();
if (!((Object)(object)slider != (Object)null))
{
return;
}
((UnityEvent<float>)(object)slider.onValueChanged).AddListener((UnityAction<float>)delegate
{
OnSliderChanged(slider);
});
if (m != null)
{
((UnityEvent<float>)(object)slider.onValueChanged).AddListener((UnityAction<float>)delegate
{
m(slider.value, ((ConfigEntryBase)bvtConfigItem).Description.Description);
});
}
slider.minValue = MinValue;
slider.maxValue = MaxValue;
slider.value = Value;
textInput.text = Value.ToString(precision);
}
private void OnTextInputChanged(InputField textInput)
{
slider.value = float.Parse(textInput.text);
}
private void OnSliderChanged(Slider slider)
{
sliderValue = slider.value;
textInput.text = sliderValue.ToString(precision);
bvtConfigItem.Value = sliderValue;
}
}
public delegate void ToggleHandler(Toggle t);
internal class ToggleWidgetController : MonoBehaviour
{
public void SetParameters(string Text, bool state, ToggleHandler toggleHandler)
{
((Component)((Component)this).transform.Find("Toggle/Label")).GetComponent<Text>().text = Text;
Toggle tg = ((Component)((Component)this).transform.Find("Toggle")).GetComponent<Toggle>();
tg.isOn = state;
if (toggleHandler != null)
{
((UnityEvent<bool>)(object)((Component)((Component)this).transform.Find("Toggle")).GetComponent<Toggle>().onValueChanged).AddListener((UnityAction<bool>)delegate
{
toggleHandler(tg);
});
}
}
}
}