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 HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering.PostProcessing;
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: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("REPOJP")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("zabuMod")]
[assembly: AssemblyTitle("zabuMod")]
[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 BetterView
{
[BepInPlugin("REPOJP.BetterView", "BetterView", "1.1.0")]
public class BetterViewPlugin : BaseUnityPlugin
{
private struct DistanceSettings
{
internal readonly float FogStart;
internal readonly float FogEnd;
internal readonly float FarClip;
internal DistanceSettings(float fogStart, float fogEnd, float farClip)
{
FogStart = fogStart;
FogEnd = fogEnd;
FarClip = farClip;
}
}
private struct PropLightState
{
internal readonly float OriginalIntensity;
internal readonly float CurrentIntensity;
internal readonly float OriginalRange;
internal PropLightState(float originalIntensity, float currentIntensity, float originalRange)
{
OriginalIntensity = originalIntensity;
CurrentIntensity = currentIntensity;
OriginalRange = originalRange;
}
}
private struct PropEmissionState
{
internal readonly Color OriginalEmission;
internal readonly Color CurrentEmission;
internal PropEmissionState(Color originalEmission, Color currentEmission)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: 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)
OriginalEmission = originalEmission;
CurrentEmission = currentEmission;
}
}
private struct ItemLightState
{
internal readonly float OriginalIntensity;
internal readonly float OriginalRange;
internal readonly float OriginalFresnel;
internal readonly float CurrentIntensity;
internal readonly float CurrentRange;
internal ItemLightState(float originalIntensity, float originalRange, float originalFresnel, float currentIntensity, float currentRange)
{
OriginalIntensity = originalIntensity;
OriginalRange = originalRange;
OriginalFresnel = originalFresnel;
CurrentIntensity = currentIntensity;
CurrentRange = currentRange;
}
}
internal class BetterViewZoomController : MonoBehaviour
{
private const float ZoomHoldSeconds = 0.15f;
private const float ZoomDisplaySeconds = 1.25f;
private const int ZoomPriority = 0;
private const int ZoomDisplayFontSize = 28;
private bool zoomKeyWasDown;
private Canvas zoomDisplayCanvas;
private Text zoomDisplayText;
private float zoomDisplayTimer;
private float zoomBoundsRestoreTimer;
private CameraZoom boundedCameraZoom;
private bool hasOriginalMinimumZoom;
private float originalMinimumZoom;
private void Update()
{
try
{
HandleDebugToggleKey();
UpdateZoomBoundsRestoreTimer();
bool key = Input.GetKey((KeyCode)122);
if (!key && !zoomKeyWasDown)
{
HideZoomRateDisplay();
return;
}
if (!CanApplyNow())
{
ResetZoomStateOnly();
return;
}
if (!key)
{
StartZoomRelease();
return;
}
if (ApplyWheelZoomAdjustment())
{
ShowZoomRateDisplay(cachedZoomRate);
}
UpdateZoomRateDisplayTimer();
CameraZoom instance = CameraZoom.Instance;
if ((Object)(object)instance == (Object)null)
{
RestoreCameraZoomBounds();
zoomKeyWasDown = true;
return;
}
float baseZoom = GetBaseZoom(instance);
float num = Mathf.Clamp(baseZoom / cachedZoomRate, 0.1f, instance.MaximumZoom);
EnsureCameraZoomBounds(instance, num);
instance.OverrideZoomSet(num, 0.15f, cachedZoomSmoothInSpeed, cachedZoomSmoothOutSpeed, ((Component)this).gameObject, 0);
zoomKeyWasDown = true;
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: Zoom Update\n" + ex));
}
}
}
internal void ResetZoomStateOnly()
{
zoomKeyWasDown = false;
zoomBoundsRestoreTimer = 0f;
RestoreCameraZoomBounds();
HideZoomRateDisplay();
}
private void StartZoomRelease()
{
zoomKeyWasDown = false;
HideZoomRateDisplay();
if (hasOriginalMinimumZoom)
{
zoomBoundsRestoreTimer = Mathf.Max(0.25f, 1f / Mathf.Max(cachedZoomSmoothOutSpeed, 0.1f) + 0.2f);
}
}
private void UpdateZoomBoundsRestoreTimer()
{
if (!(zoomBoundsRestoreTimer <= 0f))
{
zoomBoundsRestoreTimer -= Time.deltaTime;
if (zoomBoundsRestoreTimer <= 0f)
{
RestoreCameraZoomBounds();
}
}
}
private bool ApplyWheelZoomAdjustment()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
float y = Input.mouseScrollDelta.y;
if (Mathf.Abs(y) <= 0.001f)
{
return false;
}
int num = Mathf.FloorToInt(cachedZoomRate * 10f + 0.0001f);
num += ((y > 0f) ? 1 : (-1));
num = Mathf.Clamp(num, 10, 100);
float num2 = (float)num / 10f;
if (NearlyEqual(num2, cachedZoomRate))
{
ShowZoomRateDisplay(cachedZoomRate);
return false;
}
cachedZoomRate = num2;
if (cachedSaveWheelZoomToConfig && ZoomRate != null)
{
ZoomRate.Value = num2;
if (configFile != null)
{
configFile.Save();
}
}
return true;
}
private void EnsureCameraZoomBounds(CameraZoom cameraZoom, float targetZoom)
{
if ((Object)(object)cameraZoom == (Object)null)
{
RestoreCameraZoomBounds();
return;
}
if ((Object)(object)boundedCameraZoom != (Object)null && (Object)(object)boundedCameraZoom != (Object)(object)cameraZoom)
{
RestoreCameraZoomBounds();
}
if (!hasOriginalMinimumZoom)
{
boundedCameraZoom = cameraZoom;
originalMinimumZoom = cameraZoom.MinimumZoom;
hasOriginalMinimumZoom = true;
}
float num = Mathf.Max(0.1f, targetZoom - 0.1f);
if (cameraZoom.MinimumZoom > num)
{
cameraZoom.MinimumZoom = num;
}
}
private void RestoreCameraZoomBounds()
{
if (hasOriginalMinimumZoom && (Object)(object)boundedCameraZoom != (Object)null)
{
boundedCameraZoom.MinimumZoom = originalMinimumZoom;
}
zoomBoundsRestoreTimer = 0f;
boundedCameraZoom = null;
hasOriginalMinimumZoom = false;
originalMinimumZoom = 0f;
}
private void EnsureZoomRateDisplay()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Expected O, but got Unknown
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
//IL_0135: Unknown result type (might be due to invalid IL or missing references)
//IL_0183: Unknown result type (might be due to invalid IL or missing references)
//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)zoomDisplayCanvas != (Object)null) || !((Object)(object)zoomDisplayText != (Object)null))
{
GameObject val = new GameObject("BetterViewZoomDisplayCanvas");
val.transform.parent = null;
((Object)val).hideFlags = (HideFlags)61;
Object.DontDestroyOnLoad((Object)(object)val);
zoomDisplayCanvas = val.AddComponent<Canvas>();
zoomDisplayCanvas.renderMode = (RenderMode)0;
zoomDisplayCanvas.sortingOrder = 32767;
CanvasScaler val2 = val.AddComponent<CanvasScaler>();
val2.uiScaleMode = (ScaleMode)1;
val2.referenceResolution = new Vector2(1920f, 1080f);
val2.matchWidthOrHeight = 0.5f;
GameObject val3 = new GameObject("BetterViewZoomDisplayText");
val3.transform.SetParent(val.transform, false);
RectTransform val4 = val3.AddComponent<RectTransform>();
val4.anchorMin = new Vector2(0.5f, 0f);
val4.anchorMax = new Vector2(0.5f, 0f);
val4.pivot = new Vector2(0.5f, 0f);
val4.anchoredPosition = new Vector2(0f, 120f);
val4.sizeDelta = new Vector2(640f, 64f);
zoomDisplayText = val3.AddComponent<Text>();
zoomDisplayText.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
zoomDisplayText.fontSize = 28;
zoomDisplayText.alignment = (TextAnchor)4;
((Graphic)zoomDisplayText).color = Color.white;
((Graphic)zoomDisplayText).raycastTarget = false;
Shadow val5 = val3.AddComponent<Shadow>();
val5.effectColor = new Color(0f, 0f, 0f, 0.85f);
val5.effectDistance = new Vector2(2f, -2f);
((Behaviour)zoomDisplayCanvas).enabled = false;
}
}
private void ShowZoomRateDisplay(float zoomRate)
{
EnsureZoomRateDisplay();
if (!((Object)(object)zoomDisplayCanvas == (Object)null) && !((Object)(object)zoomDisplayText == (Object)null))
{
zoomDisplayText.text = "Zoom x" + zoomRate.ToString("0.0");
zoomDisplayTimer = 1.25f;
((Behaviour)zoomDisplayCanvas).enabled = true;
}
}
private void UpdateZoomRateDisplayTimer()
{
if (!((Object)(object)zoomDisplayCanvas == (Object)null) && ((Behaviour)zoomDisplayCanvas).enabled)
{
zoomDisplayTimer -= Time.deltaTime;
if (zoomDisplayTimer <= 0f)
{
HideZoomRateDisplay();
}
}
}
private void HideZoomRateDisplay()
{
zoomDisplayTimer = 0f;
if ((Object)(object)zoomDisplayCanvas != (Object)null)
{
((Behaviour)zoomDisplayCanvas).enabled = false;
}
}
private static float GetBaseZoom(CameraZoom cameraZoom)
{
if ((Object)(object)cameraZoom != (Object)null && cameraZoom.playerZoomDefault > 0f)
{
return cameraZoom.playerZoomDefault;
}
Camera mainGameplayCamera = GetMainGameplayCamera();
if ((Object)(object)mainGameplayCamera != (Object)null && mainGameplayCamera.fieldOfView > 0f)
{
return mainGameplayCamera.fieldOfView;
}
return 60f;
}
}
[HarmonyPatch(typeof(EnvironmentDirector), "Setup")]
internal static class EnvironmentDirectorSetupPatch
{
private static void Postfix()
{
ApplyViewDistance(force: true);
ApplyVisualSettings(force: true);
ApplyGraphicsSettings(force: true);
ApplyGlowSettings(force: true);
}
}
[HarmonyPatch(typeof(EnvironmentDirector), "Update")]
internal static class EnvironmentDirectorUpdatePatch
{
private static void Postfix()
{
ApplyAmbientBrightness();
}
}
internal static class SpectateCameraStateNormalPatch
{
internal static void Postfix()
{
ApplyViewDistance(force: false);
}
}
[HarmonyPatch(typeof(SpectateCamera), "StopSpectate")]
internal static class SpectateCameraStopPatch
{
private static void Postfix()
{
ApplyViewDistance(force: true);
}
}
[HarmonyPatch(typeof(PostProcessing), "Setup")]
internal static class PostProcessingSetupPatch
{
private static void Postfix(PostProcessing __instance)
{
ApplyVisualSettings(force: true);
}
}
[HarmonyPatch(typeof(PostProcessing), "VignetteOverride")]
internal static class PostProcessingVignetteOverridePatch
{
private static void Prefix(ref float _intensity)
{
if (ShouldDisableVisualEffects())
{
_intensity *= 0f;
}
}
}
[HarmonyPatch(typeof(PostProcessing), "SaturationOverride")]
internal static class PostProcessingSaturationOverridePatch
{
private static void Prefix(PostProcessing __instance, ref float _amount)
{
if (ShouldDisableVisualEffects())
{
float privateFloat = GetPrivateFloat(postColorGradingSaturationField, __instance, _amount);
_amount = privateFloat + (_amount - privateFloat) * 0f;
}
}
}
[HarmonyPatch(typeof(PostProcessing), "ContrastOverride")]
internal static class PostProcessingContrastOverridePatch
{
private static void Prefix(PostProcessing __instance, ref float _amount)
{
if (ShouldDisableVisualEffects())
{
float privateFloat = GetPrivateFloat(postColorGradingContrastField, __instance, _amount);
_amount = privateFloat + (_amount - privateFloat) * 0f;
}
}
}
[HarmonyPatch(typeof(GraphicsManager), "UpdateAll")]
internal static class GraphicsManagerUpdateAllPatch
{
private static void Postfix()
{
ApplyVisualSettings(force: false);
ApplyGraphicsSettings(force: false);
ApplyGlowSettings(force: false);
}
}
[HarmonyPatch(typeof(GraphicsManager), "UpdateMotionBlur")]
internal static class GraphicsManagerUpdateMotionBlurPatch
{
private static void Postfix()
{
if (ShouldDisableVisualEffects())
{
ApplyPostProcessEffectToggles(PostProcessing.Instance);
}
}
}
[HarmonyPatch(typeof(GraphicsManager), "UpdateLensDistortion")]
internal static class GraphicsManagerUpdateLensDistortionPatch
{
private static void Postfix()
{
if (ShouldDisableVisualEffects())
{
ApplyPostProcessEffectToggles(PostProcessing.Instance);
}
}
}
[HarmonyPatch(typeof(GraphicsManager), "UpdateChromaticAberration")]
internal static class GraphicsManagerUpdateChromaticAberrationPatch
{
private static void Postfix()
{
if (ShouldDisableVisualEffects())
{
ApplyPostProcessEffectToggles(PostProcessing.Instance);
}
}
}
[HarmonyPatch(typeof(GraphicsManager), "UpdateGrain")]
internal static class GraphicsManagerUpdateGrainPatch
{
private static void Postfix()
{
if (ShouldDisableVisualEffects())
{
ApplyPostProcessEffectToggles(PostProcessing.Instance);
}
}
}
[HarmonyPatch(typeof(GraphicsManager), "UpdateGlitchLoop")]
internal static class GraphicsManagerUpdateGlitchLoopPatch
{
private static void Postfix()
{
ApplyGraphicsSettings(force: false);
}
}
[HarmonyPatch(typeof(GraphicsManager), "UpdateRenderSize")]
internal static class GraphicsManagerUpdateRenderSizePatch
{
private static void Postfix()
{
ApplyGraphicsSettings(force: false);
}
}
[HarmonyPatch(typeof(VideoOverlay), "Override")]
internal static class VideoOverlayOverridePatch
{
private static bool Prefix(ref float amount)
{
if (!ShouldDisableVisualEffects())
{
return true;
}
amount *= 0f;
return amount > 0.001f;
}
}
[HarmonyPatch(typeof(CameraGlitch), "PlayLong")]
internal static class CameraGlitchPlayLongPatch
{
private static bool Prefix()
{
return AllowCameraGlitch();
}
}
[HarmonyPatch(typeof(CameraGlitch), "PlayShort")]
internal static class CameraGlitchPlayShortPatch
{
private static bool Prefix()
{
return AllowCameraGlitch();
}
}
[HarmonyPatch(typeof(CameraGlitch), "PlayTiny")]
internal static class CameraGlitchPlayTinyPatch
{
private static bool Prefix()
{
return AllowCameraGlitch();
}
}
[HarmonyPatch(typeof(CameraGlitch), "DoNotLookEffectSet")]
internal static class CameraGlitchDoNotLookEffectSetPatch
{
private static bool Prefix()
{
if (!ShouldDisableVisualEffects())
{
return true;
}
return Random.value < 0f;
}
}
[HarmonyPatch(typeof(PropLight), "Awake")]
internal static class PropLightAwakePatch
{
private static void Postfix(PropLight __instance)
{
ApplyPropLightGlow(__instance);
}
}
[HarmonyPatch(typeof(PropLight), "Start")]
internal static class PropLightStartPatch
{
private static void Postfix(PropLight __instance)
{
ApplyPropLightGlow(__instance);
}
}
[HarmonyPatch(typeof(PropLightEmission), "Awake")]
internal static class PropLightEmissionAwakePatch
{
private static void Postfix(PropLightEmission __instance)
{
ApplyPropEmissionGlow(__instance);
}
}
[HarmonyPatch(typeof(ItemLight), "Start")]
internal static class ItemLightStartPatch
{
private static void Postfix(ItemLight __instance)
{
ApplyItemLightGlow(__instance);
}
}
[HarmonyPatch(typeof(LightManager), "Setup")]
internal static class LightManagerSetupPatch
{
private static void Postfix()
{
ApplyGlowSettings(force: true);
}
}
[HarmonyPatch(typeof(RenderTextureMain), "ChangeResolution")]
internal static class RenderTextureMainChangeResolutionPatch
{
private static bool Prefix()
{
return !ShouldDisableVisualEffects();
}
}
[HarmonyPatch(typeof(RenderTextureMain), "ChangeSize")]
internal static class RenderTextureMainChangeSizePatch
{
private static bool Prefix()
{
return !ShouldDisableVisualEffects();
}
}
[HarmonyPatch(typeof(RenderTextureMain), "Shake")]
internal static class RenderTextureMainShakePatch
{
private static bool Prefix()
{
return !ShouldDisableVisualEffects();
}
}
public const string PluginGuid = "REPOJP.BetterView";
public const string PluginName = "BetterView";
public const string PluginVersion = "1.1.0";
private const float FarClipExtraDistance = 1f;
private const float EffectsOffLevelVignetteMultiplier = 0f;
private const float EffectsOffDynamicVignetteMultiplier = 0f;
private const float EffectsOffDynamicSaturationMultiplier = 0f;
private const float EffectsOffDynamicContrastMultiplier = 0f;
private const float EffectsOffLowHealthVignetteMultiplier = 0f;
private const float EffectsOffVideoOverlayMultiplier = 0f;
private const float EffectsOffCameraGlitchChanceMultiplier = 0f;
private const float EffectsOffDoNotLookGlitchChanceMultiplier = 0f;
private const float BrightAmbientBrightnessMultiplier = 10f;
private const float BrightBloomIntensityMultiplier = 0f;
private const float BrightBloomThresholdMultiplier = 5f;
private const float BrightColorTemperatureMultiplier = 0f;
private const float BrightColorFilterBlend = 0f;
private const float FixedGlowBloomMultiplier = 10f;
private const float FixedGlowPropLightMultiplier = 10f;
private const float FixedGlowPropLightEmissionMultiplier = 10f;
private const float FixedGlowItemLightMultiplier = 10f;
private const float GlowBloomIntensityMaxValue = 1.5f;
private const float GlowBloomThresholdMinValue = 1.75f;
private const float GlowLightIntensityMaxMultiplier = 2f;
private const float GlowLightRangeMaxMultiplier = 1.15f;
private const float GlowEmissionMaxMultiplier = 2f;
private const float GlowItemFresnelMaxMultiplier = 2f;
private const float GlowColorMaxValue = 3f;
internal static ManualLogSource Log;
internal static ConfigEntry<bool> EnableMod;
internal static ConfigEntry<float> FogStartDistance;
internal static ConfigEntry<float> ViewDistance;
internal static ConfigEntry<bool> ApplyToSpectateCamera;
internal static ConfigEntry<float> ZoomRate;
internal static ConfigEntry<bool> SaveWheelZoomToConfig;
internal static ConfigEntry<float> ZoomSmoothInSpeed;
internal static ConfigEntry<float> ZoomSmoothOutSpeed;
internal static ConfigEntry<bool> DisableVisualEffects;
internal static ConfigEntry<bool> BrightenView;
internal static ConfigEntry<bool> EnhanceGlowObjects;
internal static ConfigEntry<bool> EnableDebugToggleKey;
private static ConfigFile configFile;
private static Harmony harmony;
private static FieldInfo environmentMainCameraField;
private static FieldInfo environmentDarkAdaptationLerpField;
private static FieldInfo environmentDarkAdaptationCurveField;
private static FieldInfo postColorGradingSaturationField;
private static FieldInfo postColorGradingContrastField;
private static FieldInfo postVignetteColorField;
private static FieldInfo postVignetteIntensityField;
private static FieldInfo postVignetteSmoothnessField;
private static FieldInfo graphicsGlitchLoopField;
private static FieldInfo renderTextureWidthOriginalField;
private static FieldInfo renderTextureHeightOriginalField;
private static FieldInfo renderTextureWidthField;
private static FieldInfo renderTextureHeightField;
private static FieldInfo renderTextureResetTimerField;
private static FieldInfo renderTextureShakeActiveField;
private static FieldInfo renderTextureShakeTimerField;
private static FieldInfo renderTextureSizeResetTimerField;
private static FieldInfo renderTextureOriginalSizeField;
private static FieldInfo propLightOriginalIntensityField;
private static FieldInfo propLightLightComponentField;
private static FieldInfo propEmissionOriginalEmissionField;
private static FieldInfo propEmissionMaterialField;
private static FieldInfo itemLightIntensityOriginalField;
private static FieldInfo itemLightRangeOriginalField;
private static FieldInfo itemLightFresnelScaleOriginalField;
private static bool spectateStateNormalPatched;
private static BetterViewZoomController zoomController;
private static bool cachedEnableMod;
private static float cachedFogStartDistance;
private static float cachedViewDistance;
private static bool cachedApplyToSpectateCamera;
private static float cachedZoomRate;
private static bool cachedSaveWheelZoomToConfig;
private static float cachedZoomSmoothInSpeed;
private static float cachedZoomSmoothOutSpeed;
private static bool cachedDisableVisualEffects;
private static bool cachedBrightenView;
private static bool cachedEnhanceGlowObjects;
private static bool cachedEnableDebugToggleKey;
private static bool debugForceVanillaView;
private static bool hasApplied;
private static bool hasAppliedAmbientBrightness;
private static int appliedCameraId = -1;
private static float appliedFogStart = -1f;
private static float appliedFogEnd = -1f;
private static float appliedFarClip = -1f;
private static readonly Dictionary<PropLight, PropLightState> propLightStates = new Dictionary<PropLight, PropLightState>();
private static readonly Dictionary<PropLightEmission, PropEmissionState> propEmissionStates = new Dictionary<PropLightEmission, PropEmissionState>();
private static readonly Dictionary<ItemLight, ItemLightState> itemLightStates = new Dictionary<ItemLight, ItemLightState>();
private void Awake()
{
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Expected O, but got Unknown
try
{
Log = ((BaseUnityPlugin)this).Logger;
configFile = ((BaseUnityPlugin)this).Config;
((Component)this).transform.parent = null;
((Object)this).hideFlags = (HideFlags)61;
Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
BindConfigEntries();
UpdateCachedConfigValues();
RegisterConfigChangeEvents();
CacheReflectionFields();
harmony = new Harmony("REPOJP.BetterView");
harmony.PatchAll(typeof(EnvironmentDirectorSetupPatch));
harmony.PatchAll(typeof(EnvironmentDirectorUpdatePatch));
harmony.PatchAll(typeof(SpectateCameraStopPatch));
harmony.PatchAll(typeof(PostProcessingSetupPatch));
harmony.PatchAll(typeof(PostProcessingVignetteOverridePatch));
harmony.PatchAll(typeof(PostProcessingSaturationOverridePatch));
harmony.PatchAll(typeof(PostProcessingContrastOverridePatch));
harmony.PatchAll(typeof(GraphicsManagerUpdateAllPatch));
harmony.PatchAll(typeof(GraphicsManagerUpdateMotionBlurPatch));
harmony.PatchAll(typeof(GraphicsManagerUpdateLensDistortionPatch));
harmony.PatchAll(typeof(GraphicsManagerUpdateChromaticAberrationPatch));
harmony.PatchAll(typeof(GraphicsManagerUpdateGrainPatch));
harmony.PatchAll(typeof(GraphicsManagerUpdateGlitchLoopPatch));
harmony.PatchAll(typeof(GraphicsManagerUpdateRenderSizePatch));
harmony.PatchAll(typeof(VideoOverlayOverridePatch));
harmony.PatchAll(typeof(CameraGlitchPlayLongPatch));
harmony.PatchAll(typeof(CameraGlitchPlayShortPatch));
harmony.PatchAll(typeof(CameraGlitchPlayTinyPatch));
harmony.PatchAll(typeof(CameraGlitchDoNotLookEffectSetPatch));
harmony.PatchAll(typeof(RenderTextureMainChangeResolutionPatch));
harmony.PatchAll(typeof(RenderTextureMainChangeSizePatch));
harmony.PatchAll(typeof(RenderTextureMainShakePatch));
harmony.PatchAll(typeof(PropLightAwakePatch));
harmony.PatchAll(typeof(PropLightStartPatch));
harmony.PatchAll(typeof(PropLightEmissionAwakePatch));
harmony.PatchAll(typeof(ItemLightStartPatch));
harmony.PatchAll(typeof(LightManagerSetupPatch));
RefreshSpectatePatch();
CreateZoomController();
Log.LogInfo((object)"Success: BetterView loaded.");
}
catch (Exception ex)
{
((BaseUnityPlugin)this).Logger.LogError((object)("Failure: Awake\n" + ex));
}
}
private void BindConfigEntries()
{
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Expected O, but got Unknown
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Expected O, but got Unknown
//IL_0146: Unknown result type (might be due to invalid IL or missing references)
//IL_0150: 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
EnableMod = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableMod", true, "Enable this mod.このMODを有効化");
FogStartDistance = ((BaseUnityPlugin)this).Config.Bind<float>("General", "FogStartDistance", 100f, new ConfigDescription("Distance where black fog starts.黒いFogが始まる距離", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 500f), Array.Empty<object>()));
ViewDistance = ((BaseUnityPlugin)this).Config.Bind<float>("General", "ViewDistance", 100f, new ConfigDescription("Distance where black fog fully covers the view.黒いFogで完全に見えなくなる距離", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 500f), Array.Empty<object>()));
ApplyToSpectateCamera = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ApplyToSpectateCamera", true, "Apply view distance settings while spectating.観戦中にも描画距離設定を適用");
ZoomRate = ((BaseUnityPlugin)this).Config.Bind<float>("Zoom", "ZoomRate", 5f, new ConfigDescription("Zoom multiplier used while holding Z.Zキー押下中に使用するZoom倍率", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 10f), Array.Empty<object>()));
SaveWheelZoomToConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Zoom", "SaveWheelZoomToConfig", true, "Save mouse wheel zoom adjustments to the config file.マウスホイールで調整したZoom倍率をConfigへ保存");
ZoomSmoothInSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("Zoom", "ZoomSmoothInSpeed", 6f, new ConfigDescription("Smooth zoom in speed.ズームインのヌルッとした補間速度", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 30f), Array.Empty<object>()));
ZoomSmoothOutSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("Zoom", "ZoomSmoothOutSpeed", 5f, new ConfigDescription("Smooth zoom out speed.ズームアウトのヌルッとした補間速度", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 30f), Array.Empty<object>()));
DisableVisualEffects = ((BaseUnityPlugin)this).Config.Bind<bool>("Visual", "DisableVisualEffects", true, "Remove visual effects that reduce visibility while keeping damage feedback.ダメージ時の被弾演出を残して視界を悪くする演出をなくす");
BrightenView = ((BaseUnityPlugin)this).Config.Bind<bool>("Visual", "BrightenView", true, "Apply brightness and color adjustments for a clearer view.明るく見やすくする画面補正を適用");
EnhanceGlowObjects = ((BaseUnityPlugin)this).Config.Bind<bool>("Visual", "EnhanceGlowObjects", true, "Enhance glowing valuables and map objects.発光する貴重品とマップオブジェクトを強化");
EnableDebugToggleKey = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "EnableDebugToggleKey", false, "Enable Shift+F to instantly switch between vanilla view and modded view.Shift+Fでバニラ表示とMOD適用表示を瞬時に切り替え");
}
private static void CacheReflectionFields()
{
environmentMainCameraField = AccessTools.Field(typeof(EnvironmentDirector), "MainCamera");
environmentDarkAdaptationLerpField = AccessTools.Field(typeof(EnvironmentDirector), "DarkAdaptationLerp");
environmentDarkAdaptationCurveField = AccessTools.Field(typeof(EnvironmentDirector), "DarkAdaptationCurve");
postColorGradingSaturationField = AccessTools.Field(typeof(PostProcessing), "colorGradingSaturation");
postColorGradingContrastField = AccessTools.Field(typeof(PostProcessing), "colorGradingContrast");
postVignetteColorField = AccessTools.Field(typeof(PostProcessing), "vignetteColor");
postVignetteIntensityField = AccessTools.Field(typeof(PostProcessing), "vignetteIntensity");
postVignetteSmoothnessField = AccessTools.Field(typeof(PostProcessing), "vignetteSmoothness");
graphicsGlitchLoopField = AccessTools.Field(typeof(GraphicsManager), "glitchLoop");
renderTextureWidthOriginalField = AccessTools.Field(typeof(RenderTextureMain), "textureWidthOriginal");
renderTextureHeightOriginalField = AccessTools.Field(typeof(RenderTextureMain), "textureHeightOriginal");
renderTextureWidthField = AccessTools.Field(typeof(RenderTextureMain), "textureWidth");
renderTextureHeightField = AccessTools.Field(typeof(RenderTextureMain), "textureHeight");
renderTextureResetTimerField = AccessTools.Field(typeof(RenderTextureMain), "textureResetTimer");
renderTextureShakeActiveField = AccessTools.Field(typeof(RenderTextureMain), "shakeActive");
renderTextureShakeTimerField = AccessTools.Field(typeof(RenderTextureMain), "shakeTimer");
renderTextureSizeResetTimerField = AccessTools.Field(typeof(RenderTextureMain), "sizeResetTimer");
renderTextureOriginalSizeField = AccessTools.Field(typeof(RenderTextureMain), "originalSize");
propLightOriginalIntensityField = AccessTools.Field(typeof(PropLight), "originalIntensity");
propLightLightComponentField = AccessTools.Field(typeof(PropLight), "lightComponent");
propEmissionOriginalEmissionField = AccessTools.Field(typeof(PropLightEmission), "originalEmission");
propEmissionMaterialField = AccessTools.Field(typeof(PropLightEmission), "material");
itemLightIntensityOriginalField = AccessTools.Field(typeof(ItemLight), "lightIntensityOriginal");
itemLightRangeOriginalField = AccessTools.Field(typeof(ItemLight), "lightRangeOriginal");
itemLightFresnelScaleOriginalField = AccessTools.Field(typeof(ItemLight), "fresnelScaleOriginal");
}
private static void CreateZoomController()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
if (!((Object)(object)zoomController != (Object)null))
{
GameObject val = new GameObject("BetterViewZoomController");
val.transform.parent = null;
((Object)val).hideFlags = (HideFlags)61;
Object.DontDestroyOnLoad((Object)(object)val);
zoomController = val.AddComponent<BetterViewZoomController>();
}
}
private static void RegisterConfigChangeEvents()
{
EnableMod.SettingChanged += OnConfigChanged;
FogStartDistance.SettingChanged += OnConfigChanged;
ViewDistance.SettingChanged += OnConfigChanged;
ApplyToSpectateCamera.SettingChanged += OnConfigChanged;
ZoomRate.SettingChanged += OnConfigChanged;
SaveWheelZoomToConfig.SettingChanged += OnConfigChanged;
ZoomSmoothInSpeed.SettingChanged += OnConfigChanged;
ZoomSmoothOutSpeed.SettingChanged += OnConfigChanged;
DisableVisualEffects.SettingChanged += OnConfigChanged;
BrightenView.SettingChanged += OnConfigChanged;
EnhanceGlowObjects.SettingChanged += OnConfigChanged;
EnableDebugToggleKey.SettingChanged += OnConfigChanged;
}
private static void OnConfigChanged(object sender, EventArgs e)
{
bool flag = sender == EnableMod || sender == FogStartDistance || sender == ViewDistance || sender == ApplyToSpectateCamera;
bool flag2 = sender == ZoomSmoothInSpeed || sender == ZoomSmoothOutSpeed;
bool flag3 = sender == EnableMod || sender == DisableVisualEffects || sender == BrightenView || sender == EnhanceGlowObjects || sender == EnableDebugToggleKey;
UpdateCachedConfigValues();
if (!cachedEnableDebugToggleKey)
{
debugForceVanillaView = false;
}
if (flag2 && (Object)(object)zoomController != (Object)null)
{
zoomController.ResetZoomStateOnly();
}
if (sender == ApplyToSpectateCamera || sender == EnableMod)
{
RefreshSpectatePatch();
}
if (flag)
{
ApplyViewDistance(force: true);
}
if (flag3)
{
RefreshGameGraphicsSettings();
ApplyVisualSettings(force: true);
ApplyGraphicsSettings(force: true);
ApplyGlowSettings(force: true);
}
}
private static void UpdateCachedConfigValues()
{
cachedEnableMod = EnableMod != null && EnableMod.Value;
cachedFogStartDistance = ((FogStartDistance == null) ? 100f : Mathf.Clamp(FogStartDistance.Value, 0f, 500f));
cachedViewDistance = ((ViewDistance == null) ? 100f : Mathf.Clamp(ViewDistance.Value, 1f, 500f));
cachedApplyToSpectateCamera = ApplyToSpectateCamera != null && ApplyToSpectateCamera.Value;
cachedZoomRate = ((ZoomRate == null) ? 5f : Mathf.Clamp(ZoomRate.Value, 1f, 10f));
cachedSaveWheelZoomToConfig = SaveWheelZoomToConfig == null || SaveWheelZoomToConfig.Value;
cachedZoomSmoothInSpeed = ((ZoomSmoothInSpeed == null) ? 6f : Mathf.Clamp(ZoomSmoothInSpeed.Value, 0.1f, 30f));
cachedZoomSmoothOutSpeed = ((ZoomSmoothOutSpeed == null) ? 5f : Mathf.Clamp(ZoomSmoothOutSpeed.Value, 0.1f, 30f));
cachedDisableVisualEffects = DisableVisualEffects != null && DisableVisualEffects.Value;
cachedBrightenView = BrightenView != null && BrightenView.Value;
cachedEnhanceGlowObjects = EnhanceGlowObjects != null && EnhanceGlowObjects.Value;
cachedEnableDebugToggleKey = EnableDebugToggleKey != null && EnableDebugToggleKey.Value;
if (cachedFogStartDistance >= cachedViewDistance)
{
cachedFogStartDistance = Mathf.Max(0f, cachedViewDistance - 1f);
}
}
private static void RefreshSpectatePatch()
{
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Expected O, but got Unknown
try
{
if (harmony == null)
{
return;
}
MethodInfo methodInfo = AccessTools.Method(typeof(SpectateCamera), "StateNormal", (Type[])null, (Type[])null);
MethodInfo methodInfo2 = AccessTools.Method(typeof(SpectateCameraStateNormalPatch), "Postfix", (Type[])null, (Type[])null);
if (!(methodInfo == null) && !(methodInfo2 == null))
{
if (cachedEnableMod && cachedApplyToSpectateCamera && !spectateStateNormalPatched)
{
harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
spectateStateNormalPatched = true;
}
else if ((!cachedEnableMod || !cachedApplyToSpectateCamera) && spectateStateNormalPatched)
{
harmony.Unpatch((MethodBase)methodInfo, (HarmonyPatchType)2, "REPOJP.BetterView");
spectateStateNormalPatched = false;
}
}
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: RefreshSpectatePatch\n" + ex));
}
}
}
internal static void ApplyViewDistance(bool force)
{
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Invalid comparison between Unknown and I4
try
{
if (!CanApplyNow())
{
RestoreVanillaViewDistance();
return;
}
Camera mainGameplayCamera = GetMainGameplayCamera();
if ((Object)(object)mainGameplayCamera == (Object)null || !((Behaviour)mainGameplayCamera).isActiveAndEnabled)
{
return;
}
DistanceSettings distanceSettings = GetDistanceSettings(mainGameplayCamera);
int instanceID = ((Object)mainGameplayCamera).GetInstanceID();
if (force || !IsAlreadyApplied(instanceID, distanceSettings))
{
if ((int)RenderSettings.fogMode != 1)
{
RenderSettings.fogMode = (FogMode)1;
}
SetRenderFogDistances(distanceSettings.FogStart, distanceSettings.FogEnd);
if (!NearlyEqual(mainGameplayCamera.farClipPlane, distanceSettings.FarClip))
{
mainGameplayCamera.farClipPlane = distanceSettings.FarClip;
}
SaveAppliedState(instanceID, distanceSettings);
}
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: ApplyViewDistance\n" + ex));
}
}
}
private static bool CanApplyNow()
{
if (!cachedEnableMod || debugForceVanillaView)
{
return false;
}
if (!IsGameplayLevel())
{
return false;
}
if (!cachedApplyToSpectateCamera && IsPlayerSpectating())
{
return false;
}
return true;
}
private static DistanceSettings GetDistanceSettings(Camera targetCamera)
{
float num = cachedViewDistance + 1f;
if (num <= targetCamera.nearClipPlane + 0.01f)
{
num = targetCamera.nearClipPlane + 0.01f;
}
return new DistanceSettings(cachedFogStartDistance, cachedViewDistance, num);
}
private static void SetRenderFogDistances(float fogStart, float fogEnd)
{
if (!NearlyEqual(RenderSettings.fogStartDistance, fogStart))
{
RenderSettings.fogStartDistance = fogStart;
}
if (!NearlyEqual(RenderSettings.fogEndDistance, fogEnd))
{
RenderSettings.fogEndDistance = fogEnd;
}
}
private static void SaveAppliedState(int cameraId, DistanceSettings settings)
{
hasApplied = true;
appliedCameraId = cameraId;
appliedFogStart = settings.FogStart;
appliedFogEnd = settings.FogEnd;
appliedFarClip = settings.FarClip;
}
private static bool IsAlreadyApplied(int cameraId, DistanceSettings settings)
{
return hasApplied && appliedCameraId == cameraId && NearlyEqual(appliedFogStart, settings.FogStart) && NearlyEqual(appliedFogEnd, settings.FogEnd) && NearlyEqual(appliedFarClip, settings.FarClip) && NearlyEqual(RenderSettings.fogStartDistance, settings.FogStart) && NearlyEqual(RenderSettings.fogEndDistance, settings.FogEnd);
}
private static void RestoreVanillaViewDistance()
{
try
{
if (!hasApplied)
{
return;
}
if ((Object)(object)LevelGenerator.Instance == (Object)null || (Object)(object)LevelGenerator.Instance.Level == (Object)null)
{
ClearAppliedState();
return;
}
float fogStartDistance = LevelGenerator.Instance.Level.FogStartDistance;
float fogEndDistance = LevelGenerator.Instance.Level.FogEndDistance;
float num = fogEndDistance + 1f;
SetRenderFogDistances(fogStartDistance, fogEndDistance);
Camera mainGameplayCamera = GetMainGameplayCamera();
if ((Object)(object)mainGameplayCamera != (Object)null && ((Behaviour)mainGameplayCamera).isActiveAndEnabled && !NearlyEqual(mainGameplayCamera.farClipPlane, num))
{
mainGameplayCamera.farClipPlane = num;
}
ClearAppliedState();
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: RestoreVanillaViewDistance\n" + ex));
}
}
}
private static void ClearAppliedState()
{
hasApplied = false;
appliedCameraId = -1;
appliedFogStart = -1f;
appliedFogEnd = -1f;
appliedFarClip = -1f;
}
private static Camera GetMainGameplayCamera()
{
try
{
Camera environmentDirectorMainCamera = GetEnvironmentDirectorMainCamera();
if ((Object)(object)environmentDirectorMainCamera != (Object)null)
{
return environmentDirectorMainCamera;
}
if ((Object)(object)GameDirector.instance != (Object)null && (Object)(object)GameDirector.instance.MainCamera != (Object)null)
{
return GameDirector.instance.MainCamera;
}
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: GetMainGameplayCamera\n" + ex));
}
}
return Camera.main;
}
private static Camera GetEnvironmentDirectorMainCamera()
{
try
{
if ((Object)(object)EnvironmentDirector.Instance == (Object)null || environmentMainCameraField == null)
{
return null;
}
object? value = environmentMainCameraField.GetValue(EnvironmentDirector.Instance);
return (Camera)((value is Camera) ? value : null);
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: GetEnvironmentDirectorMainCamera\n" + ex));
}
return null;
}
}
private static bool IsGameplayLevel()
{
try
{
if ((Object)(object)RunManager.instance == (Object)null)
{
return false;
}
if (SemiFunc.RunIsRecording())
{
return false;
}
return SemiFunc.RunIsLevel();
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: IsGameplayLevel\n" + ex));
}
return false;
}
}
private static bool IsPlayerSpectating()
{
try
{
if ((Object)(object)PlayerAvatar.instance != (Object)null)
{
return PlayerAvatar.instance.spectating;
}
return (Object)(object)PlayerController.instance != (Object)null && (Object)(object)PlayerController.instance.playerAvatarScript != (Object)null && PlayerController.instance.playerAvatarScript.spectating;
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: IsPlayerSpectating\n" + ex));
}
return false;
}
}
internal static void ApplyVisualSettings(bool force)
{
try
{
if (cachedEnableMod && !((Object)(object)PostProcessing.Instance == (Object)null) && !((Object)(object)LevelGenerator.Instance == (Object)null) && !((Object)(object)LevelGenerator.Instance.Level == (Object)null) && IsGameplayLevel())
{
ApplyPostProcessingLevelValues(PostProcessing.Instance);
}
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: ApplyVisualSettings\n" + ex));
}
}
}
private static void ApplyPostProcessingLevelValues(PostProcessing postProcessing)
{
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//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_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_0152: Unknown result type (might be due to invalid IL or missing references)
//IL_0157: Unknown result type (might be due to invalid IL or missing references)
//IL_0186: Unknown result type (might be due to invalid IL or missing references)
//IL_0188: Unknown result type (might be due to invalid IL or missing references)
//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)postProcessing == (Object)null || (Object)(object)postProcessing.volume == (Object)null || (Object)(object)postProcessing.volume.profile == (Object)null || (Object)(object)LevelGenerator.Instance == (Object)null || (Object)(object)LevelGenerator.Instance.Level == (Object)null)
{
return;
}
Level level = LevelGenerator.Instance.Level;
ColorGrading val = default(ColorGrading);
if (postProcessing.volume.profile.TryGetSettings<ColorGrading>(ref val))
{
float num = level.ColorTemperature;
Color val2 = level.ColorFilter;
if (ShouldBrightenView())
{
num *= 0f;
val2 = Color.Lerp(Color.white, val2, 0f);
}
((ParameterOverride<float>)(object)val.temperature).value = num;
((ParameterOverride<Color>)(object)val.colorFilter).value = val2;
}
Bloom val3 = default(Bloom);
if (postProcessing.volume.profile.TryGetSettings<Bloom>(ref val3))
{
float num2 = level.BloomIntensity;
float num3 = level.BloomThreshold;
if (ShouldBrightenView())
{
num2 *= 0f;
num3 *= 5f;
}
((ParameterOverride<float>)(object)val3.intensity).value = num2;
((ParameterOverride<float>)(object)val3.threshold).value = num3;
}
Vignette val4 = default(Vignette);
if (postProcessing.volume.profile.TryGetSettings<Vignette>(ref val4))
{
Color vignetteColor = level.VignetteColor;
float num4 = level.VignetteIntensity;
float vignetteSmoothness = level.VignetteSmoothness;
if (ShouldDisableVisualEffects())
{
num4 *= 0f;
}
((ParameterOverride<Color>)(object)val4.color).value = vignetteColor;
((ParameterOverride<float>)(object)val4.intensity).value = num4;
((ParameterOverride<float>)(object)val4.smoothness).value = vignetteSmoothness;
SetPrivateField(postVignetteColorField, postProcessing, vignetteColor);
SetPrivateField(postVignetteIntensityField, postProcessing, num4);
SetPrivateField(postVignetteSmoothnessField, postProcessing, vignetteSmoothness);
}
ApplyPostProcessEffectToggles(postProcessing);
}
private static void ApplyPostProcessEffectToggles(PostProcessing postProcessing)
{
if (!((Object)(object)postProcessing == (Object)null) && !((Object)(object)postProcessing.volume == (Object)null) && !((Object)(object)postProcessing.volume.profile == (Object)null) && ShouldDisableVisualEffects())
{
MotionBlur val = default(MotionBlur);
if (postProcessing.volume.profile.TryGetSettings<MotionBlur>(ref val))
{
((PostProcessEffectSettings)val).active = false;
}
LensDistortion val2 = default(LensDistortion);
if (postProcessing.volume.profile.TryGetSettings<LensDistortion>(ref val2))
{
((PostProcessEffectSettings)val2).active = false;
}
ChromaticAberration val3 = default(ChromaticAberration);
if (postProcessing.volume.profile.TryGetSettings<ChromaticAberration>(ref val3))
{
((PostProcessEffectSettings)val3).active = false;
}
Grain val4 = default(Grain);
if (postProcessing.volume.profile.TryGetSettings<Grain>(ref val4))
{
((PostProcessEffectSettings)val4).active = false;
}
}
}
internal static void ApplyGraphicsSettings(bool force)
{
try
{
if (cachedEnableMod)
{
if (ShouldDisableVisualEffects() && (Object)(object)GraphicsManager.instance != (Object)null && graphicsGlitchLoopField != null)
{
graphicsGlitchLoopField.SetValue(GraphicsManager.instance, false);
}
if (ShouldDisableVisualEffects())
{
ForceLargeRenderResolution();
StopRenderTextureEffects();
}
}
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: ApplyGraphicsSettings\n" + ex));
}
}
}
private static void ForceLargeRenderResolution()
{
RenderTextureMain instance = RenderTextureMain.instance;
if ((Object)(object)instance == (Object)null || (Object)(object)instance.renderTexture == (Object)null)
{
return;
}
float textureWidthLarge = instance.textureWidthLarge;
float textureHeightLarge = instance.textureHeightLarge;
if (!(textureWidthLarge <= 0f) && !(textureHeightLarge <= 0f))
{
SetPrivateField(renderTextureWidthOriginalField, instance, textureWidthLarge);
SetPrivateField(renderTextureHeightOriginalField, instance, textureHeightLarge);
float privateFloat = GetPrivateFloat(renderTextureWidthField, instance, textureWidthLarge);
float privateFloat2 = GetPrivateFloat(renderTextureHeightField, instance, textureHeightLarge);
if (!NearlyEqual(privateFloat, textureWidthLarge) || !NearlyEqual(privateFloat2, textureHeightLarge) || ((Texture)instance.renderTexture).width != (int)textureWidthLarge || ((Texture)instance.renderTexture).height != (int)textureHeightLarge)
{
SetPrivateField(renderTextureResetTimerField, instance, 0f);
instance.ResetResolution();
}
}
}
private static void StopRenderTextureEffects()
{
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
RenderTextureMain instance = RenderTextureMain.instance;
if (!((Object)(object)instance == (Object)null))
{
SetPrivateField(renderTextureShakeActiveField, instance, false);
SetPrivateField(renderTextureShakeTimerField, instance, 0f);
Vector3 privateVector = GetPrivateVector3(renderTextureOriginalSizeField, instance, ((Component)instance).transform.localScale);
((Component)instance).transform.localPosition = Vector3.zero;
((Component)instance).transform.localScale = privateVector;
SetPrivateField(renderTextureSizeResetTimerField, instance, 0f);
}
}
private static void ApplyAmbientBrightness()
{
//IL_005b: 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_0067: Unknown result type (might be due to invalid IL or missing references)
if (!cachedEnableMod || !cachedBrightenView || debugForceVanillaView || !IsGameplayLevel())
{
RestoreAmbientBrightness();
return;
}
if ((Object)(object)LevelGenerator.Instance == (Object)null || (Object)(object)LevelGenerator.Instance.Level == (Object)null)
{
RestoreAmbientBrightness();
return;
}
Color vanillaAmbientLight = GetVanillaAmbientLight();
RenderSettings.ambientLight = MultiplyColorClamped(vanillaAmbientLight, 10f);
hasAppliedAmbientBrightness = true;
}
private static void RestoreAmbientBrightness()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
if (hasAppliedAmbientBrightness && !((Object)(object)LevelGenerator.Instance == (Object)null) && !((Object)(object)LevelGenerator.Instance.Level == (Object)null))
{
RenderSettings.ambientLight = GetVanillaAmbientLight();
hasAppliedAmbientBrightness = false;
}
}
private static Color GetVanillaAmbientLight()
{
//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_0014: 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_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: 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_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
Level level = LevelGenerator.Instance.Level;
Color ambientColor = level.AmbientColor;
Color ambientColorAdaptation = level.AmbientColorAdaptation;
float privateFloat = GetPrivateFloat(environmentDarkAdaptationLerpField, EnvironmentDirector.Instance, 0f);
privateFloat = Mathf.Clamp01(privateFloat);
AnimationCurve val = null;
if (environmentDarkAdaptationCurveField != null && (Object)(object)EnvironmentDirector.Instance != (Object)null)
{
object? value = environmentDarkAdaptationCurveField.GetValue(EnvironmentDirector.Instance);
val = (AnimationCurve)((value is AnimationCurve) ? value : null);
}
float num = ((val == null) ? privateFloat : val.Evaluate(privateFloat));
num = Mathf.Clamp01(num);
return Color.Lerp(ambientColor, ambientColorAdaptation, num);
}
private static void RefreshGameGraphicsSettings()
{
try
{
if ((Object)(object)GraphicsManager.instance != (Object)null)
{
GraphicsManager.instance.UpdateAll();
}
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: RefreshGameGraphicsSettings\n" + ex));
}
}
}
private static bool ShouldDisableVisualEffects()
{
return cachedEnableMod && cachedDisableVisualEffects && !debugForceVanillaView && IsGameplayLevel();
}
private static bool ShouldBrightenView()
{
return cachedEnableMod && cachedBrightenView && !debugForceVanillaView && IsGameplayLevel();
}
private static Color MultiplyColorClamped(Color source, float multiplier)
{
//IL_0001: 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_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: 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_0036: Unknown result type (might be due to invalid IL or missing references)
return new Color(Mathf.Clamp01(source.r * multiplier), Mathf.Clamp01(source.g * multiplier), Mathf.Clamp01(source.b * multiplier), source.a);
}
private static bool ShouldEnhanceGlowObjects()
{
return cachedEnableMod && cachedEnhanceGlowObjects && !debugForceVanillaView && IsGameplayLevel();
}
private static void HandleDebugToggleKey()
{
try
{
if (cachedEnableDebugToggleKey && (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303)) && Input.GetKeyDown((KeyCode)102))
{
debugForceVanillaView = !debugForceVanillaView;
RestoreVanillaViewDistance();
RefreshGameGraphicsSettings();
ApplyViewDistance(force: true);
ApplyVisualSettings(force: true);
ApplyGraphicsSettings(force: true);
ApplyGlowSettings(force: true);
ApplyAmbientBrightness();
if (Log != null)
{
Log.LogInfo((object)("Success: Debug view toggle " + (debugForceVanillaView ? "Vanilla" : "Modded")));
}
}
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: HandleDebugToggleKey\n" + ex));
}
}
}
internal static void ApplyGlowSettings(bool force)
{
try
{
if (!ShouldEnhanceGlowObjects())
{
RestoreGlowSettings();
return;
}
ApplyGlowBloom();
PropLight[] array = Object.FindObjectsOfType<PropLight>();
for (int i = 0; i < array.Length; i++)
{
ApplyPropLightGlow(array[i]);
}
PropLightEmission[] array2 = Object.FindObjectsOfType<PropLightEmission>();
for (int j = 0; j < array2.Length; j++)
{
ApplyPropEmissionGlow(array2[j]);
}
ItemLight[] array3 = Object.FindObjectsOfType<ItemLight>();
for (int k = 0; k < array3.Length; k++)
{
ApplyItemLightGlow(array3[k]);
}
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: ApplyGlowSettings\n" + ex));
}
}
}
private static void ApplyGlowBloom()
{
PostProcessing instance = PostProcessing.Instance;
Bloom val = default(Bloom);
if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.volume == (Object)null) && !((Object)(object)instance.volume.profile == (Object)null) && instance.volume.profile.TryGetSettings<Bloom>(ref val))
{
float num = Mathf.Min(1f, 1.5f);
((PostProcessEffectSettings)val).active = true;
((ParameterOverride<float>)(object)val.intensity).value = Mathf.Max(((ParameterOverride<float>)(object)val.intensity).value, num);
((ParameterOverride<float>)(object)val.threshold).value = Mathf.Max(((ParameterOverride<float>)(object)val.threshold).value, 1.75f);
}
}
private static void ApplyPropLightGlow(PropLight propLight)
{
try
{
if ((Object)(object)propLight == (Object)null)
{
return;
}
Light val = null;
if (propLightLightComponentField != null)
{
object? value = propLightLightComponentField.GetValue(propLight);
val = (Light)((value is Light) ? value : null);
}
if ((Object)(object)val == (Object)null)
{
val = ((Component)propLight).GetComponent<Light>();
}
if (!((Object)(object)val == (Object)null))
{
if (!propLightStates.TryGetValue(propLight, out var value2))
{
value2 = new PropLightState(GetPrivateFloat(propLightOriginalIntensityField, propLight, val.intensity), val.intensity, val.range);
propLightStates[propLight] = value2;
}
float num = Mathf.Min(10f, 2f);
float num2 = Mathf.Min(1.18f, 1.15f);
float num3 = value2.OriginalIntensity * num;
SetPrivateField(propLightOriginalIntensityField, propLight, num3);
if (val.intensity > 0f)
{
val.intensity = Mathf.Max(val.intensity, num3);
}
val.range = value2.OriginalRange * num2;
}
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: ApplyPropLightGlow\n" + ex));
}
}
}
private static void ApplyPropEmissionGlow(PropLightEmission propEmission)
{
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: Unknown result type (might be due to invalid IL or missing references)
//IL_0127: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
try
{
if ((Object)(object)propEmission == (Object)null)
{
return;
}
Material val = null;
if (propEmissionMaterialField != null)
{
object? value = propEmissionMaterialField.GetValue(propEmission);
val = (Material)((value is Material) ? value : null);
}
if ((Object)(object)val == (Object)null)
{
Renderer component = ((Component)propEmission).GetComponent<Renderer>();
if ((Object)(object)component != (Object)null)
{
val = component.material;
}
}
if (!((Object)(object)val == (Object)null) && val.HasProperty("_EmissionColor"))
{
if (!propEmissionStates.TryGetValue(propEmission, out var value2))
{
Color privateColor = GetPrivateColor(propEmissionOriginalEmissionField, propEmission, val.GetColor("_EmissionColor"));
value2 = new PropEmissionState(privateColor, val.GetColor("_EmissionColor"));
propEmissionStates[propEmission] = value2;
}
float multiplier = Mathf.Min(10f, 2f);
Color val2 = MultiplyHdrColorClamped(value2.OriginalEmission, multiplier, 3f);
SetPrivateField(propEmissionOriginalEmissionField, propEmission, val2);
val.EnableKeyword("_EMISSION");
val.SetColor("_EmissionColor", val2);
}
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: ApplyPropEmissionGlow\n" + ex));
}
}
}
private static void ApplyItemLightGlow(ItemLight itemLight)
{
try
{
if (!((Object)(object)itemLight == (Object)null) && !((Object)(object)itemLight.itemLight == (Object)null))
{
if (!itemLightStates.TryGetValue(itemLight, out var value))
{
value = new ItemLightState(GetPrivateFloat(itemLightIntensityOriginalField, itemLight, itemLight.itemLight.intensity), GetPrivateFloat(itemLightRangeOriginalField, itemLight, itemLight.itemLight.range), GetPrivateFloat(itemLightFresnelScaleOriginalField, itemLight, 0f), itemLight.itemLight.intensity, itemLight.itemLight.range);
itemLightStates[itemLight] = value;
}
float num = Mathf.Min(10f, 2f);
float num2 = Mathf.Min(1.18f, 1.15f);
float num3 = Mathf.Min(10f, 2f);
float num4 = value.OriginalIntensity * num;
float num5 = value.OriginalRange * num2;
float num6 = value.OriginalFresnel * num3;
SetPrivateField(itemLightIntensityOriginalField, itemLight, num4);
SetPrivateField(itemLightRangeOriginalField, itemLight, num5);
SetPrivateField(itemLightFresnelScaleOriginalField, itemLight, num6);
if (((Behaviour)itemLight.itemLight).enabled || itemLight.itemLight.intensity > 0f)
{
itemLight.itemLight.intensity = Mathf.Max(itemLight.itemLight.intensity, num4);
itemLight.itemLight.range = Mathf.Max(itemLight.itemLight.range, num5);
}
ApplyItemFresnel(itemLight, num6);
}
}
catch (Exception ex)
{
if (Log != null)
{
Log.LogError((object)("Failure: ApplyItemLightGlow\n" + ex));
}
}
}
private static void ApplyItemFresnel(ItemLight itemLight, float value)
{
if ((Object)(object)itemLight == (Object)null || itemLight.meshRenderers == null)
{
return;
}
foreach (MeshRenderer meshRenderer in itemLight.meshRenderers)
{
if ((Object)(object)meshRenderer != (Object)null && ((Component)meshRenderer).gameObject.activeSelf && (Object)(object)((Renderer)meshRenderer).material != (Object)null && ((Renderer)meshRenderer).material.HasProperty("_FresnelScale"))
{
((Renderer)meshRenderer).material.SetFloat("_FresnelScale", value);
}
}
}
private static void RestoreGlowSettings()
{
//IL_017b: Unknown result type (might be due to invalid IL or missing references)
//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
foreach (KeyValuePair<PropLight, PropLightState> item in new List<KeyValuePair<PropLight, PropLightState>>(propLightStates))
{
if (!((Object)(object)item.Key == (Object)null))
{
Light val = null;
if (propLightLightComponentField != null)
{
object? value = propLightLightComponentField.GetValue(item.Key);
val = (Light)((value is Light) ? value : null);
}
if ((Object)(object)val == (Object)null)
{
val = ((Component)item.Key).GetComponent<Light>();
}
SetPrivateField(propLightOriginalIntensityField, item.Key, item.Value.OriginalIntensity);
if ((Object)(object)val != (Object)null)
{
val.intensity = item.Value.CurrentIntensity;
val.range = item.Value.OriginalRange;
}
}
}
propLightStates.Clear();
foreach (KeyValuePair<PropLightEmission, PropEmissionState> item2 in new List<KeyValuePair<PropLightEmission, PropEmissionState>>(propEmissionStates))
{
if (!((Object)(object)item2.Key == (Object)null))
{
Material val2 = null;
if (propEmissionMaterialField != null)
{
object? value2 = propEmissionMaterialField.GetValue(item2.Key);
val2 = (Material)((value2 is Material) ? value2 : null);
}
SetPrivateField(propEmissionOriginalEmissionField, item2.Key, item2.Value.OriginalEmission);
if ((Object)(object)val2 != (Object)null && val2.HasProperty("_EmissionColor"))
{
val2.SetColor("_EmissionColor", item2.Value.CurrentEmission);
}
}
}
propEmissionStates.Clear();
foreach (KeyValuePair<ItemLight, ItemLightState> item3 in new List<KeyValuePair<ItemLight, ItemLightState>>(itemLightStates))
{
if (!((Object)(object)item3.Key == (Object)null))
{
SetPrivateField(itemLightIntensityOriginalField, item3.Key, item3.Value.OriginalIntensity);
SetPrivateField(itemLightRangeOriginalField, item3.Key, item3.Value.OriginalRange);
SetPrivateField(itemLightFresnelScaleOriginalField, item3.Key, item3.Value.OriginalFresnel);
if ((Object)(object)item3.Key.itemLight != (Object)null)
{
item3.Key.itemLight.intensity = item3.Value.CurrentIntensity;
item3.Key.itemLight.range = item3.Value.CurrentRange;
}
ApplyItemFresnel(item3.Key, item3.Value.OriginalFresnel);
}
}
itemLightStates.Clear();
}
private static Color GetPrivateColor(FieldInfo fieldInfo, object instance, Color fallback)
{
//IL_0016: 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_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: 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)
if (fieldInfo == null || instance == null)
{
return fallback;
}
if (!(fieldInfo.GetValue(instance) is Color result))
{
return fallback;
}
return result;
}
private static Color MultiplyHdrColorClamped(Color source, float multiplier, float maxValue)
{
//IL_0001: 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_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: 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_0048: Unknown result type (might be due to invalid IL or missing references)
return new Color(Mathf.Clamp(source.r * multiplier, 0f, maxValue), Mathf.Clamp(source.g * multiplier, 0f, maxValue), Mathf.Clamp(source.b * multiplier, 0f, maxValue), source.a);
}
private static void SetPrivateField(FieldInfo fieldInfo, object instance, object value)
{
if (!(fieldInfo == null) && instance != null)
{
fieldInfo.SetValue(instance, value);
}
}
private static float GetPrivateFloat(FieldInfo fieldInfo, object instance, float fallback)
{
if (fieldInfo == null || instance == null)
{
return fallback;
}
if (!(fieldInfo.GetValue(instance) is float result))
{
return fallback;
}
return result;
}
private static Vector3 GetPrivateVector3(FieldInfo fieldInfo, object instance, Vector3 fallback)
{
//IL_0016: 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_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: 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)
if (fieldInfo == null || instance == null)
{
return fallback;
}
if (!(fieldInfo.GetValue(instance) is Vector3 result))
{
return fallback;
}
return result;
}
private static bool NearlyEqual(float left, float right)
{
return Mathf.Abs(left - right) <= 0.001f;
}
private static bool AllowCameraGlitch()
{
if (!ShouldDisableVisualEffects())
{
return true;
}
return Random.value < 0f;
}
}
}
