using System;
using System.Diagnostics;
using System.IO;
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 HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Snow")]
[assembly: AssemblyTitle("Snow")]
[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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 Omniscye.SnowEverywhere
{
	[BepInPlugin("Omniscye.SnowEverywhere", "SnowEverywhere", "1.4.1")]
	public class SnowEverywhere : BaseUnityPlugin
	{
		private sealed class SnowController : MonoBehaviour
		{
			internal struct Settings
			{
				public bool Enabled;

				public float FlakesPerSecond;

				public float FallSpeed;

				public float FlakeSize;

				public float WindX;

				public float WindZ;

				public float SpawnBoxHalfExtent;

				public int MaxParticles;

				public bool StickToCamera;

				public bool UseUnscaledTime;
			}

			private ParticleSystem _ps = null;

			private EmissionModule _emission;

			private MainModule _main;

			private ShapeModule _shape;

			private VelocityOverLifetimeModule _vel;

			private ParticleSystemRenderer _rend = null;

			private Camera? _cam;

			private Settings _settings;

			private float _targetLifetime;

			private bool _manualSimulateFallback = false;

			public void Initialize(Settings s, Texture2D? customTexture)
			{
				_settings = s;
				BuildParticleSystem(customTexture);
				RefreshForScene();
				if (s.Enabled)
				{
					Enable();
				}
				else
				{
					Disable();
				}
			}

			public void RefreshForScene()
			{
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				_cam = Camera.main;
				if ((Object)(object)_cam == (Object)null)
				{
					Camera[] array = Object.FindObjectsOfType<Camera>();
					Camera[] array2 = array;
					foreach (Camera val in array2)
					{
						if ((Object)(object)val != (Object)null && ((Behaviour)val).enabled)
						{
							_cam = val;
							break;
						}
					}
				}
				if (_settings.StickToCamera && (Object)(object)_cam != (Object)null)
				{
					Vector3 position = ((Component)_cam).transform.position;
					position.y += 15f;
					((Component)this).transform.position = position;
				}
			}

			private void LateUpdate()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: 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)
				if (_settings.StickToCamera && (Object)(object)_cam != (Object)null)
				{
					Vector3 position = ((Component)_cam).transform.position;
					position.y += 15f;
					((Component)this).transform.position = position;
				}
				if (!_settings.Enabled || (Object)(object)_ps == (Object)null)
				{
					return;
				}
				if (_manualSimulateFallback)
				{
					float num = (_settings.UseUnscaledTime ? Time.unscaledDeltaTime : Time.deltaTime);
					if (_ps.isPlaying)
					{
						_ps.Pause(false);
					}
					_ps.Simulate(num, false, false, false);
				}
				else if (_ps.isStopped || _ps.isPaused)
				{
					_ps.Play();
				}
			}

			private void BuildParticleSystem(Texture2D? customTexture)
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: 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_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_016f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0202: Unknown result type (might be due to invalid IL or missing references)
				//IL_0225: Unknown result type (might be due to invalid IL or missing references)
				//IL_0237: Unknown result type (might be due to invalid IL or missing references)
				//IL_023c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0288: Unknown result type (might be due to invalid IL or missing references)
				//IL_0299: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0319: Unknown result type (might be due to invalid IL or missing references)
				_ps = ((Component)this).gameObject.AddComponent<ParticleSystem>();
				_rend = ((Component)_ps).GetComponent<ParticleSystemRenderer>();
				_rend.alignment = (ParticleSystemRenderSpace)0;
				_rend.renderMode = (ParticleSystemRenderMode)0;
				Shader val = Shader.Find("Particles/Standard Unlit");
				if ((Object)(object)val == (Object)null)
				{
					val = Shader.Find("Legacy Shaders/Particles/Alpha Blended");
				}
				Material val2 = new Material(val);
				((Object)val2).name = "Snow_Menu_Material";
				val2.color = Color.white;
				if ((Object)(object)customTexture != (Object)null)
				{
					val2.mainTexture = (Texture)(object)customTexture;
				}
				val2.SetFloat("_Mode", 2f);
				val2.EnableKeyword("_ALPHABLEND_ON");
				val2.DisableKeyword("_ALPHATEST_ON");
				val2.DisableKeyword("_ALPHAPREMULTIPLY_ON");
				val2.SetInt("_ZWrite", 0);
				val2.SetInt("_SrcBlend", 5);
				val2.SetInt("_DstBlend", 10);
				val2.renderQueue = 3000;
				((Renderer)_rend).material = val2;
				((Renderer)_rend).sortingOrder = 32767;
				TrySetAlwaysSimulate(_ps, _rend);
				_main = _ps.main;
				((MainModule)(ref _main)).loop = true;
				((MainModule)(ref _main)).startColor = MinMaxGradient.op_Implicit(Color.white);
				((MainModule)(ref _main)).startSize = MinMaxCurve.op_Implicit(_settings.FlakeSize);
				_targetLifetime = Mathf.Max(6f, 25f / Mathf.Max(0.05f, _settings.FallSpeed));
				((MainModule)(ref _main)).startLifetime = MinMaxCurve.op_Implicit(_targetLifetime);
				((MainModule)(ref _main)).startSpeed = MinMaxCurve.op_Implicit(0f);
				((MainModule)(ref _main)).maxParticles = _settings.MaxParticles;
				((MainModule)(ref _main)).simulationSpace = (ParticleSystemSimulationSpace)1;
				_emission = _ps.emission;
				((EmissionModule)(ref _emission)).enabled = true;
				((EmissionModule)(ref _emission)).rateOverTime = MinMaxCurve.op_Implicit(_settings.FlakesPerSecond);
				_shape = _ps.shape;
				((ShapeModule)(ref _shape)).enabled = true;
				((ShapeModule)(ref _shape)).shapeType = (ParticleSystemShapeType)5;
				((ShapeModule)(ref _shape)).scale = new Vector3(_settings.SpawnBoxHalfExtent * 2f, 2f, _settings.SpawnBoxHalfExtent * 2f);
				((ShapeModule)(ref _shape)).position = Vector3.zero;
				_vel = _ps.velocityOverLifetime;
				((VelocityOverLifetimeModule)(ref _vel)).enabled = true;
				((VelocityOverLifetimeModule)(ref _vel)).space = (ParticleSystemSimulationSpace)1;
				((VelocityOverLifetimeModule)(ref _vel)).x = MinMaxCurve.op_Implicit(_settings.WindX);
				((VelocityOverLifetimeModule)(ref _vel)).y = MinMaxCurve.op_Implicit(0f - _settings.FallSpeed);
				((VelocityOverLifetimeModule)(ref _vel)).z = MinMaxCurve.op_Implicit(_settings.WindZ);
				_ps.Play();
			}

			private void TrySetAlwaysSimulate(ParticleSystem ps, ParticleSystemRenderer rend)
			{
				if ((Object)(object)rend != (Object)null)
				{
					((Renderer)rend).allowOcclusionWhenDynamic = false;
				}
				PropertyInfo property = typeof(ParticleSystem).GetProperty("cullingMode", BindingFlags.Instance | BindingFlags.Public);
				if (property != null)
				{
					Type propertyType = property.PropertyType;
					object value;
					try
					{
						value = Enum.Parse(propertyType, "AlwaysSimulate");
					}
					catch
					{
						value = Enum.ToObject(propertyType, 2);
					}
					try
					{
						property.SetValue(ps, value, null);
						_manualSimulateFallback = false;
						return;
					}
					catch
					{
					}
				}
				_manualSimulateFallback = true;
			}

			public void Enable()
			{
				_settings.Enabled = true;
				if ((Object)(object)_ps == (Object)null)
				{
					return;
				}
				if (_manualSimulateFallback)
				{
					if (_ps.isPlaying)
					{
						_ps.Pause(false);
					}
				}
				else
				{
					_ps.Play();
				}
			}

			public void Disable()
			{
				_settings.Enabled = false;
				if (!((Object)(object)_ps == (Object)null))
				{
					_ps.Pause();
				}
			}

			public void SetEmissionRate(float r)
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				_settings.FlakesPerSecond = Mathf.Max(0f, r);
				((EmissionModule)(ref _emission)).rateOverTime = MinMaxCurve.op_Implicit(_settings.FlakesPerSecond);
				RecalculateRecommendedMaxParticles();
			}

			public void SetFallSpeed(float s)
			{
				//IL_0029: 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)
				_settings.FallSpeed = Mathf.Max(0.01f, s);
				((VelocityOverLifetimeModule)(ref _vel)).y = MinMaxCurve.op_Implicit(0f - _settings.FallSpeed);
				_targetLifetime = Mathf.Max(6f, 25f / _settings.FallSpeed);
				((MainModule)(ref _main)).startLifetime = MinMaxCurve.op_Implicit(_targetLifetime);
				RecalculateRecommendedMaxParticles();
			}

			public void SetFlakeSize(float s)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				_settings.FlakeSize = Mathf.Clamp(s, 0.005f, 0.25f);
				((MainModule)(ref _main)).startSize = MinMaxCurve.op_Implicit(_settings.FlakeSize);
			}

			public void SetWind(float x, float z)
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				_settings.WindX = x;
				_settings.WindZ = z;
				((VelocityOverLifetimeModule)(ref _vel)).x = MinMaxCurve.op_Implicit(x);
				((VelocityOverLifetimeModule)(ref _vel)).z = MinMaxCurve.op_Implicit(z);
			}

			public void SetSpawnBox(float halfExtent)
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				_settings.SpawnBoxHalfExtent = Mathf.Clamp(halfExtent, 5f, 200f);
				((ShapeModule)(ref _shape)).scale = new Vector3(_settings.SpawnBoxHalfExtent * 2f, 2f, _settings.SpawnBoxHalfExtent * 2f);
			}

			public void SetMaxParticles(int max)
			{
				_settings.MaxParticles = Mathf.Clamp(max, 200, 50000);
				((MainModule)(ref _main)).maxParticles = _settings.MaxParticles;
			}

			public void SetStickToCamera(bool stick)
			{
				_settings.StickToCamera = stick;
			}

			public void SetUseUnscaledTime(bool useUnscaled)
			{
				_settings.UseUnscaledTime = useUnscaled;
			}

			private void RecalculateRecommendedMaxParticles()
			{
				int num = Mathf.CeilToInt(_settings.FlakesPerSecond * _targetLifetime * 1.2f);
				if (num > _settings.MaxParticles)
				{
					_settings.MaxParticles = num;
					((MainModule)(ref _main)).maxParticles = _settings.MaxParticles;
				}
			}
		}

		public const string PluginGuid = "Omniscye.SnowEverywhere";

		public const string PluginName = "SnowEverywhere";

		public const string PluginVersion = "1.4.1";

		private ConfigEntry<bool> _enabled = null;

		private ConfigEntry<float> _flakesPerSecond = null;

		private ConfigEntry<float> _fallSpeed = null;

		private ConfigEntry<float> _flakeSize = null;

		private ConfigEntry<float> _windX = null;

		private ConfigEntry<float> _windZ = null;

		private ConfigEntry<float> _spawnBoxHalfExtent = null;

		private ConfigEntry<int> _maxParticles = null;

		private ConfigEntry<bool> _stickToCamera = null;

		private ConfigEntry<bool> _useUnscaledTime = null;

		private ConfigEntry<bool> _onlyInMenuLobby = null;

		private ConfigEntry<bool> _useCustomTexture = null;

		private ConfigEntry<string> _customTextureName = null;

		private SnowController? _controller;

		private float _filterPollTimer;

		private bool _lastAllowed;

		private bool _loggedSemiFuncNotReady;

		private Texture2D? _snowTex;

		internal static SnowEverywhere Instance { get; private set; }

		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		private void Awake()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_004a: Expected O, but got Unknown
			Instance = this;
			((Component)this).transform.parent = null;
			((Object)this).hideFlags = (HideFlags)61;
			BindConfig();
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
			TryLoadSnowTexture();
			EnsureController();
			SceneManager.sceneLoaded += OnSceneLoaded;
			ApplyMenuFilter(initial: true);
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} loaded — menu/lobby-gated snowfall with custom texture support.");
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
			_filterPollTimer -= (_useUnscaledTime.Value ? Time.unscaledDeltaTime : Time.deltaTime);
			if (_filterPollTimer <= 0f)
			{
				_filterPollTimer = 0.5f;
				ApplyMenuFilter(initial: false);
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if ((Object)(object)_controller == (Object)null)
			{
				EnsureController();
			}
			_controller.RefreshForScene();
			ApplyMenuFilter(initial: true);
			Logger.LogDebug((object)("Snow refreshed for scene '" + ((Scene)(ref scene)).name + "'."));
		}

		private void BindConfig()
		{
			_enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Master toggle for snowfall.");
			_flakesPerSecond = ((BaseUnityPlugin)this).Config.Bind<float>("Snow", "FlakesPerSecond", 150f, "Emission rate (flakes/second).");
			_fallSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("Snow", "FallSpeed", 0.8f, "Downward speed in m/s. Lower = slower.");
			_flakeSize = ((BaseUnityPlugin)this).Config.Bind<float>("Snow", "FlakeSize", 0.06f, "Base particle size in meters.");
			_windX = ((BaseUnityPlugin)this).Config.Bind<float>("Snow", "WindX", 0.15f, "Horizontal drift X.");
			_windZ = ((BaseUnityPlugin)this).Config.Bind<float>("Snow", "WindZ", -0.05f, "Horizontal drift Z.");
			_spawnBoxHalfExtent = ((BaseUnityPlugin)this).Config.Bind<float>("Snow", "SpawnBoxHalfExtent", 25f, "Half-extent of spawn box (XZ).");
			_maxParticles = ((BaseUnityPlugin)this).Config.Bind<int>("Performance", "MaxParticles", 8000, "Max live particles (raise if rate×lifetime is high).");
			_stickToCamera = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "StickToCamera", true, "Anchor emitter to active camera.");
			_useUnscaledTime = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "UseUnscaledTime", true, "Use unscaled time so menus/slowmo don’t freeze snow.");
			_onlyInMenuLobby = ((BaseUnityPlugin)this).Config.Bind<bool>("Scenes", "OnlyInMenuLobby", true, "If true, snow runs only when SemiFunc.MenuLevel() is true.");
			_useCustomTexture = ((BaseUnityPlugin)this).Config.Bind<bool>("Visual", "UseCustomTexture", true, "If true, tries to load a PNG beside the DLL and use it for flake texture.");
			_customTextureName = ((BaseUnityPlugin)this).Config.Bind<string>("Visual", "CustomTextureName", "snow.png", "File name of the texture next to the plugin DLL.");
		}

		private void EnsureController()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (!((Object)(object)_controller != (Object)null))
			{
				GameObject val = new GameObject("SnowEverywhere_Controller");
				Object.DontDestroyOnLoad((Object)(object)val);
				((Object)val).hideFlags = (HideFlags)61;
				_controller = val.AddComponent<SnowController>();
				_controller.Initialize(new SnowController.Settings
				{
					Enabled = _enabled.Value,
					FlakesPerSecond = _flakesPerSecond.Value,
					FallSpeed = _fallSpeed.Value,
					FlakeSize = _flakeSize.Value,
					WindX = _windX.Value,
					WindZ = _windZ.Value,
					SpawnBoxHalfExtent = _spawnBoxHalfExtent.Value,
					MaxParticles = _maxParticles.Value,
					StickToCamera = _stickToCamera.Value,
					UseUnscaledTime = _useUnscaledTime.Value
				}, _snowTex);
				_enabled.SettingChanged += delegate
				{
					ApplyMenuFilter(initial: false);
				};
				_flakesPerSecond.SettingChanged += delegate
				{
					_controller.SetEmissionRate(_flakesPerSecond.Value);
				};
				_fallSpeed.SettingChanged += delegate
				{
					_controller.SetFallSpeed(_fallSpeed.Value);
				};
				_flakeSize.SettingChanged += delegate
				{
					_controller.SetFlakeSize(_flakeSize.Value);
				};
				_windX.SettingChanged += delegate
				{
					_controller.SetWind(_windX.Value, _windZ.Value);
				};
				_windZ.SettingChanged += delegate
				{
					_controller.SetWind(_windX.Value, _windZ.Value);
				};
				_spawnBoxHalfExtent.SettingChanged += delegate
				{
					_controller.SetSpawnBox(_spawnBoxHalfExtent.Value);
				};
				_maxParticles.SettingChanged += delegate
				{
					_controller.SetMaxParticles(_maxParticles.Value);
				};
				_stickToCamera.SettingChanged += delegate
				{
					_controller.SetStickToCamera(_stickToCamera.Value);
				};
				_useUnscaledTime.SettingChanged += delegate
				{
					_controller.SetUseUnscaledTime(_useUnscaledTime.Value);
				};
			}
		}

		private void ApplyMenuFilter(bool initial)
		{
			if ((Object)(object)_controller == (Object)null)
			{
				return;
			}
			if (!_enabled.Value)
			{
				_controller.Disable();
				return;
			}
			bool flag = true;
			if (_onlyInMenuLobby.Value)
			{
				flag = IsMenuOrLobbyActiveSafe();
			}
			if (initial || flag != _lastAllowed)
			{
				_lastAllowed = flag;
				if (flag)
				{
					_controller.Enable();
					Logger.LogDebug((object)"Snow: ENABLE (menu level detected).");
				}
				else
				{
					_controller.Disable();
					Logger.LogDebug((object)"Snow: DISABLE (not a menu level).");
				}
			}
		}

		private bool IsMenuOrLobbyActiveSafe()
		{
			try
			{
				return SemiFunc.MenuLevel();
			}
			catch (Exception ex)
			{
				if (!_loggedSemiFuncNotReady)
				{
					_loggedSemiFuncNotReady = true;
					Logger.LogDebug((object)("Snow: SemiFunc.MenuLevel() not ready yet (" + ex.GetType().Name + "). Will retry."));
				}
				return false;
			}
		}

		private void TryLoadSnowTexture()
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			_snowTex = null;
			if (!_useCustomTexture.Value)
			{
				return;
			}
			try
			{
				string path = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location) ?? "";
				string text = Path.Combine(path, _customTextureName.Value);
				if (!File.Exists(text))
				{
					Logger.LogDebug((object)("Snow: custom texture not found at '" + text + "'. Using default white material."));
					return;
				}
				byte[] array = File.ReadAllBytes(text);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false, false);
				if (!ImageConversion.LoadImage(val, array, false))
				{
					Logger.LogWarning((object)"Snow: failed to load snow texture (LoadImage returned false).");
					Object.Destroy((Object)(object)val);
					return;
				}
				((Object)val).name = "Snow_Menu_Texture";
				((Texture)val).wrapMode = (TextureWrapMode)1;
				((Texture)val).filterMode = (FilterMode)1;
				_snowTex = val;
				Logger.LogInfo((object)$"Snow: loaded custom flake texture '{_customTextureName.Value}' ({((Texture)val).width}x{((Texture)val).height}).");
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)("Snow: error loading custom texture: " + ex.GetType().Name + ": " + ex.Message));
				_snowTex = null;
			}
		}
	}
}