using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using MelonLoader;
using OptimizedGraphicsFix;
using OptimizedGraphicsFix.API;
using OptimizedGraphicsFix.Util;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(global::OptimizedGraphicsFix.OptimizedGraphicsFix), "Optimized Graphics Fix", "1.0.0", "Cxntrxl", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 210, 180, 145)]
[assembly: MelonAuthorColor(255, 5, 210, 240)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("OptimizedGraphicsFix")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("OptimizedGraphicsFix")]
[assembly: AssemblyTitle("OptimizedGraphicsFix")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace OptimizedGraphicsFix
{
	public static class ModInfo
	{
		public const string ModName = "Optimized Graphics Fix";

		public const string ModVersion = "1.0.0";

		public const string ModAuthor = "Cxntrxl";

		public const string Description = "API for fixing various base game optimization related bugs in mods";
	}
	public class OptimizedGraphicsFix : MelonMod
	{
		public static bool VerboseLogging;

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			((MelonMod)this).OnSceneWasLoaded(buildIndex, sceneName);
			Lighting.OnSceneWasLoaded();
			OcclusionCulling.OnSceneWasLoaded();
		}

		public static void Log(object msg)
		{
			MelonLogger.Msg(msg);
		}

		public static void Warn(object msg)
		{
			MelonLogger.Warning(msg);
		}

		public static void Error(object msg)
		{
			MelonLogger.Error(msg);
		}

		public static void LogVerbose(object msg)
		{
			if (VerboseLogging)
			{
				Log(msg);
			}
		}

		public static void WarnVerbose(object msg)
		{
			if (VerboseLogging)
			{
				Warn(msg);
			}
		}

		public static void ErrorVerbose(object msg)
		{
			if (VerboseLogging)
			{
				Error(msg);
			}
		}
	}
}
namespace OptimizedGraphicsFix.Util
{
	public static class APIUtils
	{
		public static string GetCallingModName()
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			StackTrace stackTrace = new StackTrace();
			for (int i = 0; i < stackTrace.FrameCount; i++)
			{
				MethodBase method = stackTrace.GetFrame(i).GetMethod();
				if (method?.DeclaringType == null)
				{
					continue;
				}
				Assembly assembly = method.DeclaringType.Assembly;
				if (assembly == executingAssembly)
				{
					continue;
				}
				foreach (MelonMod registeredMelon in MelonTypeBase<MelonMod>.RegisteredMelons)
				{
					if (((MelonBase)registeredMelon).MelonAssembly.Assembly == assembly)
					{
						return ((MelonBase)registeredMelon).Info.Name;
					}
				}
			}
			return "Unknown Caller";
		}
	}
}
namespace OptimizedGraphicsFix.API
{
	public static class Lighting
	{
		private static bool _locked = false;

		private static int _lockPriority = 0;

		private static string _lockedBy = "Not Locked, lol? You shouldn't see this.";

		private static AmbientMode _ambientMode = (AmbientMode)0;

		private static Color _skyColor = new Color(0.35f, 0.428f, 0.584f);

		private static Color _horizonColor = new Color(0.114f, 0.125f, 0.133f);

		private static Color _groundColor = new Color(0.047f, 0.043f, 0.035f);

		public static void Lock(int lockPriority = 1)
		{
			OptimizedGraphicsFix.LogVerbose("[Lighting] " + APIUtils.GetCallingModName() + " Locked with priority " + lockPriority);
			_locked = true;
			_lockPriority = lockPriority;
			_lockedBy = APIUtils.GetCallingModName();
		}

		public static void Unlock(int lockPriority = 1)
		{
			if (_lockPriority > lockPriority && _lockedBy != APIUtils.GetCallingModName())
			{
				OptimizedGraphicsFix.LogVerbose("[Lighting] " + APIUtils.GetCallingModName() + " could not unlock lighting. Requires " + _lockPriority + ", Locked by " + _lockedBy);
			}
			else
			{
				OptimizedGraphicsFix.LogVerbose("[Lighting] " + APIUtils.GetCallingModName() + " unlocked lighting successfully.");
				_locked = false;
				_lockPriority = 0;
			}
		}

		internal static void OnSceneWasLoaded()
		{
			//IL_000c: 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_0022: 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)
			OptimizedGraphicsFix.LogVerbose("[Lighting] Reloaded lighting settings from previous scene.");
			RenderSettings.ambientMode = _ambientMode;
			RenderSettings.ambientLight = _skyColor;
			RenderSettings.ambientEquatorColor = _horizonColor;
			RenderSettings.ambientGroundColor = _groundColor;
		}

		public static void UseBounceLighting(bool useBounce)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			if (_locked)
			{
				OptimizedGraphicsFix.LogVerbose("[Lighting] " + APIUtils.GetCallingModName() + " tried to set bounce lighting, but lighting is currently locked by " + _lockedBy + " with a priority of " + _lockPriority);
			}
			else
			{
				RenderSettings.ambientMode = (AmbientMode)(useBounce ? 1 : 0);
				_ambientMode = (AmbientMode)(useBounce ? 1 : 0);
			}
		}

		public static void SetSkyLightColor(Color? color = null)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			if (_locked)
			{
				OptimizedGraphicsFix.LogVerbose("[Lighting] " + APIUtils.GetCallingModName() + " tried to set Sky Light Color, but lighting is currently locked by " + _lockedBy + " with a priority of " + _lockPriority);
			}
			else
			{
				RenderSettings.ambientSkyColor = (Color)(((??)color) ?? new Color(0.35f, 0.428f, 0.584f));
				_skyColor = (Color)(((??)color) ?? _skyColor);
			}
		}

		public static void SetHorizonLightColor(Color? color = null)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			if (_locked)
			{
				OptimizedGraphicsFix.LogVerbose("[Lighting] " + APIUtils.GetCallingModName() + " tried to set Horizon Light Color, but lighting is currently locked by " + _lockedBy + " with a priority of " + _lockPriority);
			}
			else
			{
				RenderSettings.ambientEquatorColor = (Color)(((??)color) ?? new Color(0.114f, 0.125f, 0.133f));
				_horizonColor = (Color)(((??)color) ?? _horizonColor);
			}
		}

		public static void SetGroundLightColor(Color? color = null)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			if (_locked)
			{
				OptimizedGraphicsFix.LogVerbose("[Lighting] " + APIUtils.GetCallingModName() + " tried to set Ground Light Color, but lighting is currently locked by " + _lockedBy + " with a priority of " + _lockPriority);
			}
			else
			{
				RenderSettings.ambientGroundColor = (Color)(((??)color) ?? new Color(0.047f, 0.043f, 0.035f));
				_groundColor = (Color)(((??)color) ?? _groundColor);
			}
		}
	}
	public static class OcclusionCulling
	{
		private static Dictionary<Camera, bool> _cullingMap = new Dictionary<Camera, bool>();

		private static bool _culling = true;

		public static void DisableCulling()
		{
			foreach (Camera item in (Il2CppArrayBase<Camera>)(object)Camera.allCameras)
			{
				_cullingMap.Add(item, item.useOcclusionCulling);
				item.useOcclusionCulling = false;
			}
			_culling = false;
		}

		public static void EnableCulling()
		{
			if (_culling)
			{
				return;
			}
			foreach (Camera item in (Il2CppArrayBase<Camera>)(object)Camera.allCameras)
			{
				if (_cullingMap.TryGetValue(item, out var value))
				{
					item.useOcclusionCulling = value;
				}
			}
			_cullingMap.Clear();
			_culling = true;
		}

		internal static void OnSceneWasLoaded()
		{
			_cullingMap.Clear();
			if (!_culling)
			{
				DisableCulling();
			}
		}
	}
}