using System;
using System.Collections;
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 GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.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 NearHorizon
{
internal static class HorizonFarClip
{
private static class ViewCameras
{
[CompilerGenerated]
private sealed class <Local>d__0 : IEnumerable<Camera>, IEnumerable, IEnumerator<Camera>, IEnumerator, IDisposable
{
private int <>1__state;
private Camera <>2__current;
private int <>l__initialThreadId;
private StartOfRound sor;
public StartOfRound <>3__sor;
Camera IEnumerator<Camera>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Local>d__0(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
{
<>1__state = -1;
PlayerControllerB localPlayerController = sor.localPlayerController;
if ((Object)(object)localPlayerController?.gameplayCamera != (Object)null)
{
<>2__current = localPlayerController.gameplayCamera;
<>1__state = 1;
return true;
}
goto IL_005e;
}
case 1:
<>1__state = -1;
goto IL_005e;
case 2:
{
<>1__state = -1;
break;
}
IL_005e:
if ((Object)(object)sor.spectateCamera != (Object)null)
{
<>2__current = sor.spectateCamera;
<>1__state = 2;
return true;
}
break;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<Camera> IEnumerable<Camera>.GetEnumerator()
{
<Local>d__0 <Local>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<Local>d__ = this;
}
else
{
<Local>d__ = new <Local>d__0(0);
}
<Local>d__.sor = <>3__sor;
return <Local>d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<Camera>)this).GetEnumerator();
}
}
[IteratorStateMachine(typeof(<Local>d__0))]
internal static IEnumerable<Camera> Local(StartOfRound sor)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <Local>d__0(-2)
{
<>3__sor = sor
};
}
}
internal static void SyncLocalPlanes()
{
StartOfRound instance = StartOfRound.Instance;
if ((Object)(object)instance == (Object)null)
{
return;
}
float num = Plugin.ResolvedFarClip();
foreach (Camera item in ViewCameras.Local(instance))
{
item.farClipPlane = num;
}
if (Plugin.DebugLogging.Value)
{
Debug.Log((object)$"[NearHorizon] farClipPlane={num}");
}
}
}
[HarmonyPatch(typeof(PlayerControllerB), "Start")]
internal static class NearHooks_PlayerStartFarClip
{
private static void Postfix(PlayerControllerB __instance)
{
if (!((Object)(object)StartOfRound.Instance == (Object)null) && !((Object)(object)__instance != (Object)(object)StartOfRound.Instance.localPlayerController))
{
HorizonFarClip.SyncLocalPlanes();
}
}
}
[HarmonyPatch(typeof(GrabbableObject), "Start")]
[HarmonyPriority(800)]
internal static class NearHooks_GrabbableStartPropShadow
{
private static void Postfix(GrabbableObject __instance)
{
PropShadowTweaks.OnGrabbableStart(__instance);
}
}
[BepInPlugin("mine9289.NearHorizon", "NearHorizon", "1.5.0")]
public class Plugin : BaseUnityPlugin
{
public const string PluginGuid = "mine9289.NearHorizon";
public const string PluginName = "NearHorizon";
public const string PluginVersion = "1.5.0";
internal const float BadClipFallback = 200f;
private Harmony harmony;
public static Plugin Instance { get; private set; }
public static ConfigEntry<float> FarClipPlane { get; private set; }
public static ConfigEntry<bool> DebugLogging { get; private set; }
public static ConfigEntry<bool> StripLampLungShadows { get; private set; }
private void Awake()
{
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Expected O, but got Unknown
Instance = this;
FarClipPlane = ((BaseUnityPlugin)this).Config.Bind<float>("General", "FarClipPlane", 120f, "View distance in units. Vanilla is 400. (between 1 and 10000)");
DebugLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "DebugLogging", false, "Whether to display debug messages.");
StripLampLungShadows = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "StripLampLungShadows", true, "Fancy lamp & lung apparatus: Light shadows off");
CoerceFarClipIfBad();
FarClipPlane.SettingChanged += delegate
{
CoerceFarClipIfBad();
HorizonFarClip.SyncLocalPlanes();
};
StripLampLungShadows.SettingChanged += delegate
{
PropShadowTweaks.OnStripSettingChanged();
};
harmony = new Harmony("mine9289.nearhorizon");
harmony.PatchAll(typeof(Plugin).Assembly);
((BaseUnityPlugin)this).Logger.LogInfo((object)"mine9289 / NearHorizon 1.5.0");
}
internal static void CoerceFarClipIfBad()
{
float value = FarClipPlane.Value;
if (float.IsNaN(value) || value < 1f || value > 10000f)
{
FarClipPlane.Value = 200f;
}
}
internal static float ResolvedFarClip()
{
float value = FarClipPlane.Value;
if (!float.IsNaN(value) && !(value < 1f) && !(value > 10000f))
{
return value;
}
return 200f;
}
}
internal static class PropShadowTweaks
{
private static readonly Dictionary<string, LightShadows> Defaults = new Dictionary<string, LightShadows>();
internal static void OnGrabbableStart(GrabbableObject g)
{
ApplyTo(g);
}
internal static void OnStripSettingChanged()
{
GrabbableObject[] array = Object.FindObjectsByType<GrabbableObject>((FindObjectsSortMode)0);
for (int i = 0; i < array.Length; i++)
{
ApplyTo(array[i]);
}
}
private static void ApplyTo(GrabbableObject g)
{
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
Item itemProperties = g.itemProperties;
if ((Object)(object)itemProperties == (Object)null)
{
return;
}
string name = ((Object)itemProperties).name;
if (name != "FancyLamp" && name != "LungApparatus")
{
return;
}
Light componentInChildren = ((Component)g).GetComponentInChildren<Light>();
if (!((Object)(object)componentInChildren == (Object)null))
{
if (!Defaults.ContainsKey(name))
{
Defaults[name] = componentInChildren.shadows;
}
if (Plugin.StripLampLungShadows.Value)
{
componentInChildren.shadows = (LightShadows)0;
}
else
{
componentInChildren.shadows = Defaults[name];
}
}
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "NearHorizon";
public const string PLUGIN_NAME = "NearHorizon";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
