using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using MenuLib;
using MenuLib.MonoBehaviors;
using Microsoft.CodeAnalysis;
using REPOFidelity.Patches;
using REPOFidelity.Shaders;
using REPOFidelity.Upscalers;
using TMPro;
using Unity.Profiling;
using Unity.Profiling.LowLevel.Unsafe;
using UnityEngine;
using UnityEngine.Profiling;
using UnityEngine.Rendering;
using UnityEngine.Rendering.PostProcessing;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("Vippy")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.6.3.0")]
[assembly: AssemblyInformationalVersion("1.6.3+5b124e5e41855e590e49024ae9fec305860b5997")]
[assembly: AssemblyProduct("REPOFidelity")]
[assembly: AssemblyTitle("REPOFidelity")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.6.3.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 REPOFidelity
{
internal static class BuildInfo
{
public const string Version = "1.6.3";
}
internal class CostProbe : MonoBehaviour
{
private class CamTiming
{
public readonly Stopwatch Sw = new Stopwatch();
public double TotalMs;
public int Frames;
}
internal static class ScriptTiming
{
internal class Acc
{
public long Ticks;
public int Calls;
}
private static readonly Dictionary<MethodBase, Acc> _accs = new Dictionary<MethodBase, Acc>();
internal static void Clear()
{
_accs.Clear();
}
internal static void Reset()
{
foreach (Acc value in _accs.Values)
{
value.Ticks = 0L;
value.Calls = 0;
}
}
internal static void Register(MethodInfo m)
{
if (!_accs.ContainsKey(m))
{
_accs[m] = new Acc();
}
}
internal static (long ticks, int calls) Read(MethodInfo m)
{
if (_accs.TryGetValue(m, out Acc value))
{
return (value.Ticks, value.Calls);
}
return (0L, 0);
}
public static void Prefix(out long __state)
{
__state = Stopwatch.GetTimestamp();
}
public static void Postfix(MethodBase __originalMethod, long __state)
{
if (_accs.TryGetValue(__originalMethod, out Acc value))
{
value.Ticks += Stopwatch.GetTimestamp() - __state;
value.Calls++;
}
}
}
private struct Sample
{
public float AvgFps;
public float AvgMs;
public float P1Low;
public float P01Low;
public int FrameCount;
}
private struct RendererBreakdown
{
public int Total;
public int Visible;
public int ShadowCasting;
public int ShadowCastingHidden;
public int NoLODGroup;
}
private struct LightBreakdown
{
public int Active;
public int Shadowing;
public int Directional;
public int PointShadow;
public int SpotShadow;
}
private struct LightInfo
{
public string Name;
public string Type;
public string ShadowMode;
public float Range;
public int Resolution;
public float CostScore;
}
private struct SceneMetrics
{
public RendererBreakdown Renderers;
public LightBreakdown Lights;
public long TotalSceneTris;
public int SkinnedRenderers;
public int TotalParticles;
public int ActiveParticles;
public int ActiveParticleCount;
public int ReflectionProbes;
public int TrailRenderers;
public int LineRenderers;
public int AudioSources;
public int AudioSourcesPlaying;
public int UpdatingBehaviours;
public int LateUpdatingBehaviours;
public int FixedUpdatingBehaviours;
public List<LightInfo> LightDetail;
public List<(string typeName, int count)> TopBehaviourTypes;
}
[CompilerGenerated]
private sealed class <>c__DisplayClass39_0
{
public double tickToMsMod;
public int baselineFrames;
public List<(string name, string cat, double n)> countStats;
public StringBuilder report;
public bool anyCount;
public int cellIdx;
public int totalCells;
public Sample autoSample;
public Sample vanillaSample;
internal (string name, double ms, float callsPerFrame, int calls) <Run>b__3((string name, long ticks, int calls) r)
{
return (r.name, (double)r.ticks * tickToMsMod / (double)baselineFrames, (float)r.calls / (float)baselineFrames, r.calls);
}
internal void <Run>b__9(Sample v)
{
autoSample = v;
}
internal void <Run>b__10(Sample v)
{
vanillaSample = v;
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass39_1
{
public HashSet<string> topSet;
internal bool <Run>b__18(Type t)
{
return topSet.Contains(t.Name);
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass39_2
{
public Sample s;
internal void <Run>b__21(Sample v)
{
s = v;
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass39_3
{
public Sample ps;
internal void <Run>b__22(Sample v)
{
ps = v;
}
}
[CompilerGenerated]
private sealed class <Run>d__39 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public CostProbe <>4__this;
private <>c__DisplayClass39_0 <>8__1;
private <>c__DisplayClass39_2 <>8__2;
private <>c__DisplayClass39_3 <>8__3;
private CursorLockMode <savedLockState>5__2;
private bool <savedVisible>5__3;
private QualityPreset <origPreset>5__4;
private UpscaleMode <origUpscaler>5__5;
private float <origFog>5__6;
private bool <origModEnabled>5__7;
private List<(ProfilerRecorder rec, string name, string cat)> <timeRecs>5__8;
private List<(ProfilerRecorder rec, string name, string cat)> <countRecs>5__9;
private List<(ProfilerRecorder rec, string name, string cat)> <memRecs>5__10;
private double[] <timeTotals>5__11;
private long[] <countTotals>5__12;
private long[] <memTotals>5__13;
private int <gen0Start>5__14;
private int <gen1Start>5__15;
private long <monoStart>5__16;
private float <worstFrameMs>5__17;
private List<float> <frames>5__18;
private float <elapsed>5__19;
private List<(string name, long ticks, int calls)> <modTimingSnapshot>5__20;
private List<(string name, string cat, double ms)> <timeStats>5__21;
private List<(string name, string cat, double bytes)> <memStats>5__22;
private float[] <abMs>5__23;
private float[] <abFps>5__24;
private float[] <abWorst>5__25;
private int[] <abGen1Arr>5__26;
private long[] <abMonoArr>5__27;
private bool[] <abOn>5__28;
private List<(string name, string cat, double bytes)> <perFrameMem>5__29;
private SceneMetrics <scene>5__30;
private List<(string label, double totalMs, double perCallUs, int calls)> <scriptTimings>5__31;
private List<UpscaleMode> <upscalers>5__32;
private QualityPreset[] <presetLadder>5__33;
private float[] <fogPasses>5__34;
private List<(string label, float ms, float shadowD, float lightD, bool isActive)> <sweepResults>5__35;
private Sample <potatoSample>5__36;
private int <s>5__37;
private int <g1Start>5__38;
private long <mStart>5__39;
private float <worst>5__40;
private List<float> <fr>5__41;
private float <el>5__42;
private Harmony <harmony>5__43;
private List<MethodInfo> <patched>5__44;
private List<UpscaleMode>.Enumerator <>7__wrap44;
private UpscaleMode <mode>5__46;
private float[] <>7__wrap46;
private QualityPreset[] <>7__wrap47;
private QualityPreset <p>5__49;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Run>d__39(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || (uint)(num - 12) <= 1u)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<>8__1 = null;
<>8__2 = null;
<>8__3 = null;
<timeRecs>5__8 = null;
<countRecs>5__9 = null;
<memRecs>5__10 = null;
<timeTotals>5__11 = null;
<countTotals>5__12 = null;
<memTotals>5__13 = null;
<frames>5__18 = null;
<modTimingSnapshot>5__20 = null;
<timeStats>5__21 = null;
<memStats>5__22 = null;
<abMs>5__23 = null;
<abFps>5__24 = null;
<abWorst>5__25 = null;
<abGen1Arr>5__26 = null;
<abMonoArr>5__27 = null;
<abOn>5__28 = null;
<perFrameMem>5__29 = null;
<scene>5__30 = default(SceneMetrics);
<scriptTimings>5__31 = null;
<upscalers>5__32 = null;
<presetLadder>5__33 = null;
<fogPasses>5__34 = null;
<sweepResults>5__35 = null;
<fr>5__41 = null;
<harmony>5__43 = null;
<patched>5__44 = null;
<>7__wrap44 = default(List<UpscaleMode>.Enumerator);
<>7__wrap46 = null;
<>7__wrap47 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_25d8: Unknown result type (might be due to invalid IL or missing references)
//IL_25e2: Expected O, but got Unknown
//IL_2a6f: Unknown result type (might be due to invalid IL or missing references)
//IL_2a79: Expected O, but got Unknown
//IL_0178: Unknown result type (might be due to invalid IL or missing references)
//IL_0213: Unknown result type (might be due to invalid IL or missing references)
//IL_0218: Unknown result type (might be due to invalid IL or missing references)
//IL_021c: Unknown result type (might be due to invalid IL or missing references)
//IL_0221: Unknown result type (might be due to invalid IL or missing references)
//IL_0742: Unknown result type (might be due to invalid IL or missing references)
//IL_074c: Expected O, but got Unknown
//IL_074c: Unknown result type (might be due to invalid IL or missing references)
//IL_0756: Expected O, but got Unknown
//IL_0762: Unknown result type (might be due to invalid IL or missing references)
//IL_076c: Expected O, but got Unknown
//IL_076c: Unknown result type (might be due to invalid IL or missing references)
//IL_0776: Expected O, but got Unknown
//IL_265d: Unknown result type (might be due to invalid IL or missing references)
//IL_2667: Expected O, but got Unknown
//IL_2da6: Unknown result type (might be due to invalid IL or missing references)
//IL_0395: Unknown result type (might be due to invalid IL or missing references)
//IL_039f: Expected O, but got Unknown
//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
//IL_040f: Unknown result type (might be due to invalid IL or missing references)
//IL_0414: Unknown result type (might be due to invalid IL or missing references)
//IL_0418: Unknown result type (might be due to invalid IL or missing references)
//IL_0423: Unknown result type (might be due to invalid IL or missing references)
//IL_0428: Unknown result type (might be due to invalid IL or missing references)
//IL_043e: Unknown result type (might be due to invalid IL or missing references)
//IL_0443: Unknown result type (might be due to invalid IL or missing references)
//IL_0445: Unknown result type (might be due to invalid IL or missing references)
//IL_0448: Unknown result type (might be due to invalid IL or missing references)
//IL_045a: Expected I4, but got Unknown
//IL_2816: Unknown result type (might be due to invalid IL or missing references)
//IL_2820: Expected O, but got Unknown
//IL_04af: Unknown result type (might be due to invalid IL or missing references)
//IL_04b9: Expected O, but got Unknown
//IL_04b9: Unknown result type (might be due to invalid IL or missing references)
//IL_04c3: Expected O, but got Unknown
//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
//IL_04d9: Expected O, but got Unknown
//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
//IL_04e3: Expected O, but got Unknown
//IL_04e9: Unknown result type (might be due to invalid IL or missing references)
//IL_04f3: Expected O, but got Unknown
//IL_2977: Unknown result type (might be due to invalid IL or missing references)
//IL_2981: Expected O, but got Unknown
//IL_2de6: Unknown result type (might be due to invalid IL or missing references)
//IL_2df0: Expected O, but got Unknown
//IL_0d38: Unknown result type (might be due to invalid IL or missing references)
//IL_0d42: Expected O, but got Unknown
//IL_24fa: Unknown result type (might be due to invalid IL or missing references)
//IL_2504: Expected O, but got Unknown
//IL_1eb1: Unknown result type (might be due to invalid IL or missing references)
//IL_1ebb: Expected O, but got Unknown
//IL_1eeb: Unknown result type (might be due to invalid IL or missing references)
//IL_1ef2: Expected O, but got Unknown
//IL_1ef2: Unknown result type (might be due to invalid IL or missing references)
//IL_1ef9: Expected O, but got Unknown
//IL_1fde: Unknown result type (might be due to invalid IL or missing references)
//IL_1fe8: Expected O, but got Unknown
try
{
int num = <>1__state;
CostProbe costProbe = <>4__this;
Sample sample;
double num10;
int num11;
(ProfilerRecorder, string, string) tuple3;
int num18;
int num19;
long monoUsedSizeLong;
int num20;
Sample sample2;
double num24;
double num25;
double num26;
double num27;
string text6;
long num28;
float num29;
float num30;
float num31;
float num32;
float num33;
long num34;
long num35;
float num36;
int num38;
List<(string, double, float, int)> list;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
<>8__1 = new <>c__DisplayClass39_0();
Running = true;
Progress = 0f;
costProbe._camTimings.Clear();
<>2__current = costProbe.WaitForAutotuneIfActive();
<>1__state = 1;
return true;
case 1:
{
<>1__state = -1;
<savedLockState>5__2 = Cursor.lockState;
<savedVisible>5__3 = Cursor.visible;
Cursor.lockState = (CursorLockMode)0;
Cursor.visible = true;
<origPreset>5__4 = Settings.Preset;
<origUpscaler>5__5 = Settings.UpscaleModeSetting;
<origFog>5__6 = Settings.FogDistanceMultiplier;
<origModEnabled>5__7 = Settings.ModEnabled;
if (!<origModEnabled>5__7)
{
Settings.ModEnabled = true;
SceneOptimizer.Apply();
QualityPatch.ApplyQualitySettings();
}
<>8__1.report = new StringBuilder();
<>8__1.report.AppendLine(string.Format("== REPOFidelity frame cost — {0:yyyy-MM-dd HH:mm:ss} (v{1}) ==", DateTime.Now, "1.6.3"));
<>8__1.report.AppendLine($"GPU: {SystemInfo.graphicsDeviceName} ({SystemInfo.graphicsMemorySize}MB, {SystemInfo.graphicsDeviceType})");
<>8__1.report.AppendLine($"CPU: {SystemInfo.processorType} ({SystemInfo.processorCount} cores, {SystemInfo.systemMemorySize}MB RAM)");
<>8__1.report.AppendLine("OS: " + SystemInfo.operatingSystem);
StringBuilder report = <>8__1.report;
object[] obj = new object[4]
{
Screen.width,
Screen.height,
null,
null
};
Resolution currentResolution = Screen.currentResolution;
RefreshRate refreshRateRatio = ((Resolution)(ref currentResolution)).refreshRateRatio;
obj[2] = ((RefreshRate)(ref refreshRateRatio)).value;
obj[3] = (Screen.fullScreen ? "fullscreen" : "windowed");
report.AppendLine(string.Format("Screen: {0}x{1} @ {2:F0}Hz ({3})", obj));
<>8__1.report.AppendLine($"Mod: [{Settings.Preset}] upscaler={Settings.ResolvedUpscaleMode} " + $"scale={Settings.ResolvedRenderScale}% shadowQ={Settings.ResolvedShadowQuality} " + $"shadowD={Settings.ResolvedShadowDistance:F0}m lights={Settings.ResolvedPixelLightCount} " + $"lod={Settings.ResolvedLODBias:F1} AF={Settings.ResolvedAnisotropicFiltering}x");
<>8__1.report.AppendLine($"Range: fog={Settings.ResolvedFogMultiplier:F2}x " + $"effectiveFogEnd={Settings.ResolvedEffectiveFogEnd:F0}m " + $"lightD={Settings.ResolvedLightDistance:F0}m shadowBudget={Settings.ResolvedShadowBudget}");
<>8__1.report.AppendLine($"Flags: modEnabled={Settings.ModEnabled} optEnabled={Settings.OptimizationsEnabled} cpuPatches={Settings.CpuPatchesActive}");
<>8__1.report.AppendLine();
Status = "Measuring (all markers + per-camera + scene)";
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 2;
return true;
}
case 2:
{
<>1__state = -1;
List<ProfilerRecorderHandle> list3 = new List<ProfilerRecorderHandle>();
ProfilerRecorderHandle.GetAvailable(list3);
<timeRecs>5__8 = new List<(ProfilerRecorder, string, string)>();
<countRecs>5__9 = new List<(ProfilerRecorder, string, string)>();
<memRecs>5__10 = new List<(ProfilerRecorder, string, string)>();
foreach (ProfilerRecorderHandle item13 in list3)
{
ProfilerRecorderDescription description = ProfilerRecorderHandle.GetDescription(item13);
ProfilerRecorder item11 = ProfilerRecorder.StartNew(((ProfilerRecorderDescription)(ref description)).Category, ((ProfilerRecorderDescription)(ref description)).Name, 256, (ProfilerRecorderOptions)24);
string name = ((ProfilerRecorderDescription)(ref description)).Name;
ProfilerCategory category = ((ProfilerRecorderDescription)(ref description)).Category;
(ProfilerRecorder, string, string) item12 = (item11, name, ((object)(ProfilerCategory)(ref category)).ToString());
ProfilerMarkerDataUnit unitType = ((ProfilerRecorderDescription)(ref description)).UnitType;
switch (unitType - 1)
{
case 0:
<timeRecs>5__8.Add(item12);
break;
case 2:
<countRecs>5__9.Add(item12);
break;
case 1:
<memRecs>5__10.Add(item12);
break;
}
}
Camera.onPreRender = (CameraCallback)Delegate.Combine((Delegate?)(object)Camera.onPreRender, (Delegate?)new CameraCallback(costProbe.OnCamPre));
Camera.onPostRender = (CameraCallback)Delegate.Combine((Delegate?)(object)Camera.onPostRender, (Delegate?)new CameraCallback(costProbe.OnCamPost));
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 3;
return true;
}
case 3:
<>1__state = -1;
Progress = 0.03f;
<timeTotals>5__11 = new double[<timeRecs>5__8.Count];
<countTotals>5__12 = new long[<countRecs>5__9.Count];
<memTotals>5__13 = new long[<memRecs>5__10.Count];
<gen0Start>5__14 = GC.CollectionCount(0);
<gen1Start>5__15 = GC.CollectionCount(1);
<monoStart>5__16 = Profiler.GetMonoUsedSizeLong();
<worstFrameMs>5__17 = 0f;
ModTiming.Reset();
<frames>5__18 = new List<float>(2048);
<elapsed>5__19 = 0f;
goto IL_06f2;
case 4:
<>1__state = -1;
goto IL_06f2;
case 5:
<>1__state = -1;
<g1Start>5__38 = GC.CollectionCount(1);
<mStart>5__39 = Profiler.GetMonoUsedSizeLong();
<worst>5__40 = 0f;
<fr>5__41 = new List<float>(2048);
<el>5__42 = 0f;
goto IL_0e1b;
case 6:
<>1__state = -1;
goto IL_0e1b;
case 7:
<>1__state = -1;
ScriptTiming.Reset();
<s>5__37 = 0;
<el>5__42 = 0f;
goto IL_2073;
case 8:
<>1__state = -1;
goto IL_2073;
case 9:
<>1__state = -1;
<>8__1.autoSample = default(Sample);
<>2__current = costProbe.SampleFrames(3f, delegate(Sample v)
{
<>8__1.autoSample = v;
});
<>1__state = 10;
return true;
case 10:
<>1__state = -1;
<sweepResults>5__35.Add(("Auto", <>8__1.autoSample.AvgMs, Settings.ResolvedShadowDistance, Settings.ResolvedLightDistance, <origPreset>5__4 == QualityPreset.Auto));
SweepProgress();
Settings.ApplyPreset(QualityPreset.Ultra);
Settings.ResolvedUpscaleMode = UpscaleMode.DLAA;
Settings.ResolvedRenderScale = 100;
Settings.ResolvedFogMultiplier = 1f;
QualityPatch.ApplyFogAndDrawDistance();
SceneOptimizer.Apply();
QualityPatch.ApplyQualitySettings();
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 11;
return true;
case 11:
<>1__state = -1;
<>7__wrap44 = <upscalers>5__32.GetEnumerator();
<>1__state = -3;
goto IL_2737;
case 12:
<>1__state = -3;
<>8__2.s = default(Sample);
<>2__current = costProbe.SampleFrames(3f, delegate(Sample v)
{
<>8__2.s = v;
});
<>1__state = 13;
return true;
case 13:
<>1__state = -3;
<sweepResults>5__35.Add(($"{<mode>5__46}", <>8__2.s.AvgMs, Settings.ResolvedShadowDistance, Settings.ResolvedLightDistance, <mode>5__46 == <origUpscaler>5__5 && <origPreset>5__4 == Settings.Preset));
SweepProgress();
<>8__2 = null;
goto IL_2737;
case 14:
<>1__state = -1;
<>8__3.ps = default(Sample);
<>2__current = costProbe.SampleFrames(3f, delegate(Sample v)
{
<>8__3.ps = v;
});
<>1__state = 15;
return true;
case 15:
<>1__state = -1;
<sweepResults>5__35.Add(($"{<p>5__49}@{<el>5__42:F1}x", <>8__3.ps.AvgMs, Settings.ResolvedShadowDistance, Settings.ResolvedLightDistance, false));
if (<p>5__49 == QualityPreset.Potato && Mathf.Approximately(<el>5__42, 1.1f))
{
<potatoSample>5__36 = <>8__3.ps;
}
SweepProgress();
<>8__3 = null;
<g1Start>5__38++;
goto IL_2915;
case 16:
<>1__state = -1;
<>8__1.vanillaSample = default(Sample);
<>2__current = costProbe.SampleFrames(3f, delegate(Sample v)
{
<>8__1.vanillaSample = v;
});
<>1__state = 17;
return true;
case 17:
<>1__state = -1;
<sweepResults>5__35.Add(("Vanilla (F10)", <>8__1.vanillaSample.AvgMs, QualitySettings.shadowDistance, 0f, false));
SweepProgress();
Settings.ModEnabled = <origModEnabled>5__7;
Settings.Preset = <origPreset>5__4;
Settings.UpscaleModeSetting = <origUpscaler>5__5;
Settings.FogDistanceMultiplier = <origFog>5__6;
SceneOptimizer.Apply();
QualityPatch.ApplyQualitySettings();
QualityPatch.ApplyFogAndDrawDistance();
costProbe.RestoreFrameLimit();
costProbe.RestorePresetRevertSuppression();
costProbe._sweepSmoothActive = false;
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 18;
return true;
case 18:
{
<>1__state = -1;
float num2 = <sweepResults>5__35.Min<(string, float, float, float, bool)>(((string label, float ms, float shadowD, float lightD, bool isActive) r) => r.ms);
foreach (var item14 in <sweepResults>5__35)
{
string item = item14.label;
float item2 = item14.ms;
float item3 = item14.shadowD;
float item4 = item14.lightD;
string text = (item14.isActive ? " (active)" : "");
string text2 = (Mathf.Approximately(item2, num2) ? " ← fastest" : $" {item2 - num2:+0.00;-0.00}");
string text3 = ((item4 > 0f) ? $" shadowD={item3:F0}m lightD={item4:F0}m" : $" shadowD={item3:F0}m");
<>8__1.report.AppendLine($" {item,-16} {item2,6:F2} ms{text3}{text}{text2}");
}
float num3 = <sweepResults>5__35.Where<(string, float, float, float, bool)>(((string label, float ms, float shadowD, float lightD, bool isActive) r) => r.label != "Vanilla (F10)").Min<(string, float, float, float, bool)>(((string label, float ms, float shadowD, float lightD, bool isActive) r) => r.ms) - <>8__1.vanillaSample.AvgMs;
float num4 = <potatoSample>5__36.AvgMs - <>8__1.vanillaSample.AvgMs;
<>8__1.report.AppendLine($" Mod overhead vs vanilla (best mod mode): {num3:+0.00;-0.00} ms");
<>8__1.report.AppendLine($" Potato vs vanilla: {num4:+0.00;-0.00} ms (negative = Potato wins)");
<>8__1.report.AppendLine();
<>8__1.report.AppendLine("== Optimization opportunities (ranked by likely impact) ==");
BuildOpportunities(<>8__1.report, <timeStats>5__21, <>8__1.countStats, <perFrameMem>5__29, <scene>5__30, <scriptTimings>5__31);
<>8__1.report.AppendLine();
AppendConfigFiles(<>8__1.report);
string text4 = <>8__1.report.ToString();
bool flag = false;
try
{
File.AppendAllText(OutputPath, text4);
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("Cost probe save failed: " + ex.Message));
}
try
{
flag = TrySystemClipboard(text4);
}
catch (Exception ex2)
{
Plugin.Log.LogWarning((object)("Clipboard copy failed: " + ex2.Message));
}
Plugin.Log.LogInfo((object)(flag ? ("Cost probe: appended to " + OutputPath + " (copied to clipboard)") : ("Cost probe: appended to " + OutputPath + " (clipboard unavailable — read the file)")));
Cursor.lockState = <savedLockState>5__2;
Cursor.visible = <savedVisible>5__3;
Status = (flag ? "Done (clipboard)" : "Done (file only)");
Progress = 1f;
Running = false;
<>2__current = (object)new WaitForSeconds(5f);
<>1__state = 19;
return true;
}
case 19:
{
<>1__state = -1;
Status = "";
return false;
}
IL_2737:
if (<>7__wrap44.MoveNext())
{
<mode>5__46 = <>7__wrap44.Current;
<>8__2 = new <>c__DisplayClass39_2();
Status = $"Sweep: {<mode>5__46}";
Settings.UpscaleModeSetting = <mode>5__46;
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 12;
return true;
}
<>m__Finally1();
<>7__wrap44 = default(List<UpscaleMode>.Enumerator);
<potatoSample>5__36 = default(Sample);
<>7__wrap46 = <fogPasses>5__34;
<s>5__37 = 0;
goto IL_293d;
IL_0e1b:
if (<el>5__42 < 8f)
{
float unscaledDeltaTime = Time.unscaledDeltaTime;
<fr>5__41.Add(unscaledDeltaTime);
<el>5__42 += unscaledDeltaTime;
float num5 = unscaledDeltaTime * 1000f;
if (num5 > <worst>5__40)
{
<worst>5__40 = num5;
}
Progress = 0.25f + 0.04f * ((float)(<s>5__37 - 1) + <el>5__42 / 8f);
<>2__current = null;
<>1__state = 6;
return true;
}
sample = ComputeSample(<fr>5__41);
<abMs>5__23[<s>5__37] = sample.AvgMs;
<abFps>5__24[<s>5__37] = sample.AvgFps;
<abWorst>5__25[<s>5__37] = <worst>5__40;
<abGen1Arr>5__26[<s>5__37] = GC.CollectionCount(1) - <g1Start>5__38;
<abMonoArr>5__27[<s>5__37] = (Profiler.GetMonoUsedSizeLong() - <mStart>5__39) / 1024;
<fr>5__41 = null;
<s>5__37++;
goto IL_0ec6;
IL_293d:
if (<s>5__37 < <>7__wrap46.Length)
{
<el>5__42 = <>7__wrap46[<s>5__37];
<>7__wrap47 = <presetLadder>5__33;
<g1Start>5__38 = 0;
goto IL_2915;
}
<>7__wrap46 = null;
Status = "Sweep: Vanilla (mod OFF)";
Settings.ModEnabled = false;
QualityPatch.RestoreVanillaQuality();
SceneOptimizer.Apply();
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 16;
return true;
IL_2915:
if (<g1Start>5__38 < <>7__wrap47.Length)
{
<p>5__49 = <>7__wrap47[<g1Start>5__38];
<>8__3 = new <>c__DisplayClass39_3();
Status = $"Sweep: {<p>5__49} @ fog {<el>5__42:F1}x";
Settings.ApplyPreset(<p>5__49);
Settings.ResolvedFogMultiplier = <el>5__42;
QualityPatch.ApplyFogAndDrawDistance();
SceneOptimizer.Apply();
QualityPatch.ApplyQualitySettings();
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 14;
return true;
}
<>7__wrap47 = null;
<s>5__37++;
goto IL_293d;
IL_220b:
<>8__1.report.AppendLine($"== Script cost per type (Harmony-instrumented, {4f:F0}s, top {20} types) ==");
if (<scriptTimings>5__31.Count == 0)
{
<>8__1.report.AppendLine(" (no script methods captured)");
}
else
{
<>8__1.report.AppendLine(" ms/frame calls/f µs/call method");
foreach (var (text5, num6, num7, num8) in <scriptTimings>5__31)
{
<>8__1.report.AppendLine($" {num6,7:F3} {num8,5} {num7,7:F2} {text5}");
}
double num9 = <scriptTimings>5__31.Sum<(string, double, double, int)>(((string label, double totalMs, double perCallUs, int calls) x) => x.totalMs);
<>8__1.report.AppendLine(" ──────");
<>8__1.report.AppendLine($" {num9,7:F3} (sum of instrumented methods)");
}
<>8__1.report.AppendLine();
costProbe._savedVSyncCount = QualitySettings.vSyncCount;
costProbe._savedTargetFrameRate = Application.targetFrameRate;
QualitySettings.vSyncCount = 0;
Application.targetFrameRate = -1;
costProbe._frameLimitUncapped = true;
Settings.PushPresetRevertSuppression();
costProbe._presetRevertSuppressed = true;
Status = "Sweep: Auto / DLSS / FSR / Off / Potato / Vanilla";
<>8__1.report.AppendLine($"== Sweep (Auto = autotune's picks; rest normalized Ultra + DLAA + fog 1.0×, VSync off + uncapped, {3f}s each) ==");
<upscalers>5__32 = new List<UpscaleMode>();
if (GPUDetector.IsUpscalerSupported(UpscaleMode.DLSS))
{
<upscalers>5__32.Add(UpscaleMode.DLSS);
}
if (GPUDetector.IsUpscalerSupported(UpscaleMode.FSR_Temporal))
{
<upscalers>5__32.Add(UpscaleMode.FSR_Temporal);
}
<upscalers>5__32.Add(UpscaleMode.Off);
<presetLadder>5__33 = new QualityPreset[5]
{
QualityPreset.Potato,
QualityPreset.Low,
QualityPreset.Medium,
QualityPreset.High,
QualityPreset.Ultra
};
<fogPasses>5__34 = new float[2] { 1.1f, 0.3f };
<sweepResults>5__35 = new List<(string, float, float, float, bool)>();
<>8__1.totalCells = 1 + <upscalers>5__32.Count + <presetLadder>5__33.Length * <fogPasses>5__34.Length + 1;
<>8__1.cellIdx = 0;
costProbe._sweepStartProgress = 0.38f;
costProbe._sweepEndProgress = 0.98f;
costProbe._sweepExpectedDuration = (float)<>8__1.totalCells * 4.5f;
costProbe._sweepStartTime = Time.unscaledTime;
costProbe._sweepSmoothActive = true;
Status = "Sweep: Auto (autotune's picks)";
Settings.ApplyPreset(QualityPreset.Auto);
QualityPatch.ApplyFogAndDrawDistance();
SceneOptimizer.Apply();
QualityPatch.ApplyQualitySettings();
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 9;
return true;
IL_2073:
if (<el>5__42 < 4f)
{
<el>5__42 += Time.unscaledDeltaTime;
<s>5__37++;
Progress = 0.28f + 0.09f * (<el>5__42 / 4f);
<>2__current = null;
<>1__state = 8;
return true;
}
foreach (MethodInfo item15 in <patched>5__44)
{
try
{
<harmony>5__43.Unpatch((MethodBase)item15, (HarmonyPatchType)1, <harmony>5__43.Id);
}
catch
{
}
try
{
<harmony>5__43.Unpatch((MethodBase)item15, (HarmonyPatchType)2, <harmony>5__43.Id);
}
catch
{
}
}
num10 = 1000.0 / (double)Stopwatch.Frequency;
num11 = Mathf.Max(1, <s>5__37);
foreach (MethodInfo item16 in <patched>5__44)
{
var (num12, num13) = ScriptTiming.Read(item16);
if (num13 != 0)
{
double item5 = (double)num12 * num10 / (double)num11;
double item6 = ((num13 == 0) ? 0.0 : ((double)num12 * 1000000.0 / (double)Stopwatch.Frequency / (double)num13));
string item7 = item16.DeclaringType.Name + "." + item16.Name;
<scriptTimings>5__31.Add((item7, item5, item6, num13 / num11));
}
}
<scriptTimings>5__31.Sort(((string label, double totalMs, double perCallUs, int calls) a, (string label, double totalMs, double perCallUs, int calls) b) => b.totalMs.CompareTo(a.totalMs));
ScriptTiming.Clear();
<harmony>5__43 = null;
<patched>5__44 = null;
goto IL_220b;
IL_06f2:
if (<elapsed>5__19 < 8f)
{
float unscaledDeltaTime2 = Time.unscaledDeltaTime;
<frames>5__18.Add(unscaledDeltaTime2);
<elapsed>5__19 += unscaledDeltaTime2;
float num14 = unscaledDeltaTime2 * 1000f;
if (num14 > <worstFrameMs>5__17)
{
<worstFrameMs>5__17 = num14;
}
Progress = 0.03f + 0.22f * (<elapsed>5__19 / 8f);
for (int i = 0; i < <timeRecs>5__8.Count; i++)
{
ref double reference = ref <timeTotals>5__11[i];
double num15 = reference;
tuple3 = <timeRecs>5__8[i];
reference = num15 + (double)((ProfilerRecorder)(ref tuple3.Item1)).LastValue;
}
for (int j = 0; j < <countRecs>5__9.Count; j++)
{
ref long reference2 = ref <countTotals>5__12[j];
long num16 = reference2;
tuple3 = <countRecs>5__9[j];
reference2 = num16 + ((ProfilerRecorder)(ref tuple3.Item1)).LastValue;
}
for (int k = 0; k < <memRecs>5__10.Count; k++)
{
ref long reference3 = ref <memTotals>5__13[k];
long num17 = reference3;
tuple3 = <memRecs>5__10[k];
reference3 = num17 + ((ProfilerRecorder)(ref tuple3.Item1)).LastValue;
}
<>2__current = null;
<>1__state = 4;
return true;
}
<modTimingSnapshot>5__20 = ModTiming.Read().ToList();
num18 = GC.CollectionCount(0) - <gen0Start>5__14;
num19 = GC.CollectionCount(1) - <gen1Start>5__15;
monoUsedSizeLong = Profiler.GetMonoUsedSizeLong();
Camera.onPreRender = (CameraCallback)Delegate.Remove((Delegate?)(object)Camera.onPreRender, (Delegate?)new CameraCallback(costProbe.OnCamPre));
Camera.onPostRender = (CameraCallback)Delegate.Remove((Delegate?)(object)Camera.onPostRender, (Delegate?)new CameraCallback(costProbe.OnCamPost));
Progress = 0.25f;
num20 = Mathf.Max(1, <frames>5__18.Count);
<timeStats>5__21 = new List<(string, string, double)>(<timeRecs>5__8.Count);
<>8__1.countStats = new List<(string, string, double)>(<countRecs>5__9.Count);
<memStats>5__22 = new List<(string, string, double)>(<memRecs>5__10.Count);
for (int l = 0; l < <timeRecs>5__8.Count; l++)
{
<timeStats>5__21.Add((<timeRecs>5__8[l].name, <timeRecs>5__8[l].cat, <timeTotals>5__11[l] / (double)num20 / 1000000.0));
}
for (int m = 0; m < <countRecs>5__9.Count; m++)
{
<>8__1.countStats.Add((<countRecs>5__9[m].name, <countRecs>5__9[m].cat, (double)<countTotals>5__12[m] / (double)num20));
}
for (int n = 0; n < <memRecs>5__10.Count; n++)
{
<memStats>5__22.Add((<memRecs>5__10[n].name, <memRecs>5__10[n].cat, (double)<memTotals>5__13[n] / (double)num20));
}
for (int num21 = 0; num21 < <timeRecs>5__8.Count; num21++)
{
tuple3 = <timeRecs>5__8[num21];
((ProfilerRecorder)(ref tuple3.Item1)).Dispose();
}
for (int num22 = 0; num22 < <countRecs>5__9.Count; num22++)
{
tuple3 = <countRecs>5__9[num22];
((ProfilerRecorder)(ref tuple3.Item1)).Dispose();
}
for (int num23 = 0; num23 < <memRecs>5__10.Count; num23++)
{
tuple3 = <memRecs>5__10[num23];
((ProfilerRecorder)(ref tuple3.Item1)).Dispose();
}
sample2 = ComputeSample(<frames>5__18);
<timeStats>5__21.Sort(((string name, string cat, double ms) a, (string name, string cat, double ms) b) => b.ms.CompareTo(a.ms));
<>8__1.countStats.Sort(((string name, string cat, double n) a, (string name, string cat, double n) b) => b.n.CompareTo(a.n));
<memStats>5__22.Sort(((string name, string cat, double bytes) a, (string name, string cat, double bytes) b) => b.bytes.CompareTo(a.bytes));
num24 = LookupMs(<timeStats>5__21, "CPU Main Thread Frame Time");
num25 = LookupMs(<timeStats>5__21, "CPU Render Thread Frame Time");
num26 = LookupMs(<timeStats>5__21, "CPU Total Frame Time");
num27 = LookupMs(<timeStats>5__21, "GPU Frame Time");
if (num27 > 100.0 || num27 < 0.0)
{
num27 = 0.0;
}
text6 = ((num27 <= 0.0) ? "CPU (main thread) [GPU marker unavailable]" : ((num27 > num24 + 0.2) ? "GPU" : ((num24 > num27 + 0.2) ? "CPU (main thread)" : "balanced CPU/GPU")));
<>8__1.report.AppendLine($"Baseline: {sample2.AvgMs:F2} ms ({sample2.AvgFps:F0} fps) 1%={sample2.P1Low:F0} fps 0.1%={sample2.P01Low:F0} fps worstFrame={<worstFrameMs>5__17:F1} ms ({sample2.FrameCount} frames)");
if (num26 > 0.0)
{
<>8__1.report.AppendLine($"CPU total: {num26:F2} ms main={num24:F2} render={num25:F2}");
}
if (num27 > 0.0)
{
<>8__1.report.AppendLine($"GPU total: {num27:F2} ms");
}
<>8__1.report.AppendLine("Bottleneck: " + text6);
num28 = (monoUsedSizeLong - <monoStart>5__16) / 1024;
num29 = (float)num18 / 8f;
<>8__1.report.AppendLine($"GC: gen0={num18} gen1={num19} over {8f:F0}s ({num29:F2}/s) mono Δ={num28:+0;-0} KB");
<>8__1.report.AppendLine();
<abMs>5__23 = new float[4] { sample2.AvgMs, 0f, 0f, 0f };
<abFps>5__24 = new float[4] { sample2.AvgFps, 0f, 0f, 0f };
<abWorst>5__25 = new float[4] { <worstFrameMs>5__17, 0f, 0f, 0f };
<abGen1Arr>5__26 = new int[4] { num19, 0, 0, 0 };
<abMonoArr>5__27 = new long[4] { num28, 0L, 0L, 0L };
<abOn>5__28 = new bool[4] { true, false, true, false };
<s>5__37 = 1;
goto IL_0ec6;
IL_0ec6:
if (<s>5__37 < 4)
{
Status = string.Format("A/B sample {0}/4 (patches {1})", <s>5__37 + 1, <abOn>5__28[<s>5__37] ? "ON" : "OFF");
Settings.AllocationFixesEnabled = <abOn>5__28[<s>5__37];
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 5;
return true;
}
Settings.AllocationFixesEnabled = true;
num30 = (<abMs>5__23[0] + <abMs>5__23[2]) / 2f;
num31 = (<abMs>5__23[1] + <abMs>5__23[3]) / 2f;
num32 = (<abWorst>5__25[0] + <abWorst>5__25[2]) / 2f;
num33 = (<abWorst>5__25[1] + <abWorst>5__25[3]) / 2f;
num34 = (<abMonoArr>5__27[0] + <abMonoArr>5__27[2]) / 2;
num35 = (<abMonoArr>5__27[1] + <abMonoArr>5__27[3]) / 2;
num36 = <abMs>5__23[2] - <abMs>5__23[0];
<>8__1.report.AppendLine("== A/B compare (allocation patches on/off, ON-OFF-ON-OFF, same scene) ==");
for (int num37 = 0; num37 < 4; num37++)
{
string text7 = (<abOn>5__28[num37] ? "ON " : "OFF");
<>8__1.report.AppendLine($" #{num37 + 1} {text7}: {<abMs>5__23[num37]:F2} ms ({<abFps>5__24[num37]:F0} fps) worst={<abWorst>5__25[num37]:F1} gen1={<abGen1Arr>5__26[num37]} mono Δ={<abMonoArr>5__27[num37]:+0;-0} KB");
}
<>8__1.report.AppendLine($" ON avg : {num30:F2} ms worst {num32:F1} mono {num34:+0;-0} KB");
<>8__1.report.AppendLine($" OFF avg : {num31:F2} ms worst {num33:F1} mono {num35:+0;-0} KB");
<>8__1.report.AppendLine($" Patches effect (OFF − ON): {num31 - num30:+0.00;-0.00} ms worst {num33 - num32:+0.0;-0.0} ms mono {num35 - num34:+0;-0} KB (positive = patches helped)");
<>8__1.report.AppendLine($" Order bias check (ON#2 − ON#1): {num36:+0.00;-0.00} ms (large negative = consistent second-window-faster bias, treat OFF − ON delta with caution)");
<>8__1.report.AppendLine();
<>8__1.report.AppendLine("== Frame cost — profiler markers ranked highest→lowest (ms/frame) ==");
num38 = 0;
foreach (var (arg, arg2, num39) in <timeStats>5__21)
{
if (!(num39 < 0.01))
{
<>8__1.report.AppendLine($" {num39,7:F2} ms [{arg2,-12}] {arg}");
if (++num38 >= 80)
{
break;
}
}
}
if (num38 == 0)
{
<>8__1.report.AppendLine(" (no profiler time markers captured — Unity build may strip them)");
}
<>8__1.report.AppendLine();
<>8__1.tickToMsMod = 1000.0 / (double)Stopwatch.Frequency;
<>8__1.baselineFrames = Mathf.Max(1, <frames>5__18.Count);
list = (from r in <modTimingSnapshot>5__20
select (r.name, (double)r.ticks * <>8__1.tickToMsMod / (double)<>8__1.baselineFrames, (float)r.calls / (float)<>8__1.baselineFrames, r.calls) into r
where r.calls > 0
orderby r.ms descending
select r).ToList();
<>8__1.report.AppendLine($"== Mod-internal cost (Stopwatch spans over {8f:F0}s baseline, ms/frame) ==");
if (list.Count == 0)
{
<>8__1.report.AppendLine(" (no mod spans hit — mod may be disabled or pipeline idle)");
}
else
{
<>8__1.report.AppendLine(" ms/frame calls/f name");
double num40 = 0.0;
foreach (var item17 in list)
{
<>8__1.report.AppendLine(string.Format(" {0,7:F3} {1,5:F1} {2}", item17.Item2, item17.Item3, item17.Item1.Substring("REPOFidelity.".Length)));
num40 += item17.Item2;
}
<>8__1.report.AppendLine(" ──────");
<>8__1.report.AppendLine($" {num40,7:F3} (sum of instrumented mod spans)");
}
<>8__1.report.AppendLine();
<>8__1.report.AppendLine("== Draw stats (per frame avg) ==");
<>8__1.anyCount = false;
EmitCount("Draw calls:", "Draw Calls Count");
EmitCount("Batches:", "Batches Count");
EmitCount("SetPass calls:", "SetPass Calls Count");
EmitCount("Triangles:", "Triangles Count");
EmitCount("Vertices:", "Vertices Count");
EmitCount("Shadow casters:", "Shadow Casters Count");
EmitCount("Used textures:", "Used Textures Count");
EmitCount("Render textures:", "Render Textures Count");
if (!<>8__1.anyCount)
{
<>8__1.report.AppendLine(" (no count markers captured)");
}
<>8__1.report.AppendLine();
if (<>8__1.countStats.Count > 0)
{
<>8__1.report.AppendLine("== All count markers, ranked (top 20) ==");
int num41 = 0;
foreach (var (arg3, arg4, num42) in <>8__1.countStats)
{
if (!(num42 < 1.0))
{
<>8__1.report.AppendLine($" {FmtBig(num42),10} [{arg4,-12}] {arg3}");
if (++num41 >= 20)
{
break;
}
}
}
<>8__1.report.AppendLine();
}
<perFrameMem>5__29 = <memStats>5__22.Where<(string, string, double)>(((string name, string cat, double bytes) x) => x.name.IndexOf("In Frame", StringComparison.OrdinalIgnoreCase) >= 0 || x.name.IndexOf("Alloc", StringComparison.OrdinalIgnoreCase) >= 0).ToList();
if (<perFrameMem>5__29.Count > 0)
{
<>8__1.report.AppendLine("== Allocations per frame (GC / buffer uploads) ==");
foreach (var (arg5, arg6, num43) in <perFrameMem>5__29)
{
if (!(num43 < 1.0))
{
<>8__1.report.AppendLine($" {FmtBytes(num43),10} [{arg6,-12}] {arg5}");
}
}
<>8__1.report.AppendLine();
}
<>8__1.report.AppendLine("== Per-camera render cost (CPU Stopwatch around onPreRender/onPostRender) ==");
if (costProbe._camTimings.Count == 0)
{
<>8__1.report.AppendLine(" (no camera events fired during sample — unusual)");
}
else
{
foreach (var item18 in (from kv in costProbe._camTimings
select (kv.Key, kv.Value.TotalMs / (double)Mathf.Max(1, kv.Value.Frames), kv.Value.Frames) into x
orderby x.ms descending
select x).ToList())
{
Camera item8 = item18.Item1;
double item9 = item18.Item2;
int item10 = item18.Item3;
string arg7 = (((Object)(object)item8 != (Object)null) ? ((Object)item8).name : "(destroyed)");
<>8__1.report.AppendLine($" {item9,7:F2} ms {arg7} ({item10} renders)");
}
}
costProbe._camTimings.Clear();
<>8__1.report.AppendLine();
<scene>5__30 = GatherSceneMetrics();
<>8__1.report.AppendLine("== Scene composition ==");
<>8__1.report.AppendLine($" Renderers: {<scene>5__30.Renderers.Total}");
<>8__1.report.AppendLine($" Visible: {<scene>5__30.Renderers.Visible} ({Pct(<scene>5__30.Renderers.Visible, <scene>5__30.Renderers.Total)})");
<>8__1.report.AppendLine($" Shadow casting: {<scene>5__30.Renderers.ShadowCasting} ({Pct(<scene>5__30.Renderers.ShadowCasting, <scene>5__30.Renderers.Total)})");
<>8__1.report.AppendLine($" Shadow casting + off-screen: {<scene>5__30.Renderers.ShadowCastingHidden} ({Pct(<scene>5__30.Renderers.ShadowCastingHidden, <scene>5__30.Renderers.Total)}) ← off-screen shadow work");
<>8__1.report.AppendLine($" No LODGroup: {<scene>5__30.Renderers.NoLODGroup} ({Pct(<scene>5__30.Renderers.NoLODGroup, <scene>5__30.Renderers.Total)})");
<>8__1.report.AppendLine(" Tris (sum of sharedMesh): " + FmtBig(<scene>5__30.TotalSceneTris));
<>8__1.report.AppendLine($" Skinned mesh renderers: {<scene>5__30.SkinnedRenderers}");
<>8__1.report.AppendLine($" Particle systems: {<scene>5__30.TotalParticles} total, {<scene>5__30.ActiveParticles} emitting, {FmtBig(<scene>5__30.ActiveParticleCount)} particles alive");
<>8__1.report.AppendLine($" Reflection probes: {<scene>5__30.ReflectionProbes}");
<>8__1.report.AppendLine($" Trail / Line renderers: {<scene>5__30.TrailRenderers} / {<scene>5__30.LineRenderers}");
<>8__1.report.AppendLine($" Audio sources (playing): {<scene>5__30.AudioSourcesPlaying} / {<scene>5__30.AudioSources}");
<>8__1.report.AppendLine($" Lights: {<scene>5__30.Lights.Active} active, {<scene>5__30.Lights.Shadowing} casting shadow");
<>8__1.report.AppendLine($" Directional + shadow: {<scene>5__30.Lights.Directional}");
<>8__1.report.AppendLine($" Point + shadow: {<scene>5__30.Lights.PointShadow} (×6 cubemap faces)");
<>8__1.report.AppendLine($" Spot + shadow: {<scene>5__30.Lights.SpotShadow}");
<>8__1.report.AppendLine($" MonoBehaviours w/ Update: {<scene>5__30.UpdatingBehaviours}");
<>8__1.report.AppendLine($" MonoBehaviours w/ LateUpdate: {<scene>5__30.LateUpdatingBehaviours}");
<>8__1.report.AppendLine($" MonoBehaviours w/ FixedUpdate: {<scene>5__30.FixedUpdatingBehaviours}");
<>8__1.report.AppendLine();
AppendMultiplayerSection(<>8__1.report);
if (<scene>5__30.TopBehaviourTypes.Count > 0)
{
<>8__1.report.AppendLine("== MonoBehaviour types with Update, ranked by live instance count (top 20) ==");
foreach (var (arg8, num44) in <scene>5__30.TopBehaviourTypes.Take(20))
{
<>8__1.report.AppendLine($" {num44,5}× {arg8}");
}
<>8__1.report.AppendLine();
}
if (<scene>5__30.LightDetail.Count > 0)
{
<>8__1.report.AppendLine("== Per-light shadow cost proxy, ranked (top 20) ==");
<>8__1.report.AppendLine(" score type range res shadow name");
foreach (LightInfo item19 in <scene>5__30.LightDetail.OrderByDescending((LightInfo x) => x.CostScore).Take(20))
{
<>8__1.report.AppendLine($" {item19.CostScore,5:F0} {item19.Type,-12} {item19.Range,5:F0}m {item19.Resolution,5} {item19.ShadowMode,-8} {item19.Name}");
}
<>8__1.report.AppendLine(" (proxy = faces × res² × range² for shadowers, 0 otherwise — higher = more shadow map work)");
<>8__1.report.AppendLine();
}
<scriptTimings>5__31 = new List<(string, double, double, int)>();
if (<scene>5__30.TopBehaviourTypes.Count > 0)
{
<>c__DisplayClass39_1 CS$<>8__locals0 = new <>c__DisplayClass39_1();
Status = "Script profiling (Harmony)";
List<Type> list2 = new List<Type>();
MonoBehaviour[] array = Object.FindObjectsOfType<MonoBehaviour>();
foreach (MonoBehaviour val in array)
{
if (((Behaviour)val).isActiveAndEnabled)
{
Type type = ((object)val).GetType();
if (!list2.Contains(type))
{
list2.Add(type);
}
}
}
CS$<>8__locals0.topSet = (from x in <scene>5__30.TopBehaviourTypes.Take(20)
select x.typeName).ToHashSet();
list2 = list2.Where((Type t) => CS$<>8__locals0.topSet.Contains(t.Name)).ToList();
<harmony>5__43 = new Harmony("REPOFidelity.CostProbe.ScriptTiming");
MethodInfo method = typeof(ScriptTiming).GetMethod("Prefix", BindingFlags.Static | BindingFlags.Public);
MethodInfo? method2 = typeof(ScriptTiming).GetMethod("Postfix", BindingFlags.Static | BindingFlags.Public);
HarmonyMethod prefix = new HarmonyMethod(method);
HarmonyMethod postfix = new HarmonyMethod(method2);
ScriptTiming.Clear();
<patched>5__44 = new List<MethodInfo>();
foreach (Type item20 in list2)
{
PatchIfPresent(item20, "Update", <harmony>5__43, prefix, postfix, <patched>5__44);
}
foreach (Type item21 in list2)
{
PatchIfPresent(item21, "LateUpdate", <harmony>5__43, prefix, postfix, <patched>5__44);
}
foreach (Type item22 in list2)
{
PatchIfPresent(item22, "FixedUpdate", <harmony>5__43, prefix, postfix, <patched>5__44);
}
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 7;
return true;
}
goto IL_220b;
}
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
void EmitCount(string label, string marker)
{
double num46 = LookupCount(((<>c__DisplayClass39_0)this).countStats, marker);
if (!(num46 <= 0.0))
{
((<>c__DisplayClass39_0)this).report.AppendLine($" {label,-22} {FmtBig(num46)}");
((<>c__DisplayClass39_0)this).anyCount = true;
}
}
void SweepProgress()
{
((<>c__DisplayClass39_0)this).cellIdx++;
Progress = 0.38f + 0.6f * ((float)((<>c__DisplayClass39_0)this).cellIdx / (float)((<>c__DisplayClass39_0)this).totalCells);
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
((IDisposable)<>7__wrap44).Dispose();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <RunSafe>d__36 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public CostProbe <>4__this;
private IEnumerator <inner>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <RunSafe>d__36(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<inner>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Expected O, but got Unknown
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Expected O, but got Unknown
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Expected O, but got Unknown
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Expected O, but got Unknown
int num = <>1__state;
CostProbe costProbe = <>4__this;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
}
else
{
<>1__state = -1;
<inner>5__2 = costProbe.Run();
}
bool flag;
try
{
flag = <inner>5__2.MoveNext();
}
catch (Exception arg)
{
Plugin.Log.LogError((object)$"Cost probe failed: {arg}");
Camera.onPreRender = (CameraCallback)Delegate.Remove((Delegate?)(object)Camera.onPreRender, (Delegate?)new CameraCallback(costProbe.OnCamPre));
Camera.onPostRender = (CameraCallback)Delegate.Remove((Delegate?)(object)Camera.onPostRender, (Delegate?)new CameraCallback(costProbe.OnCamPost));
costProbe.RestoreFrameLimit();
costProbe.RestorePresetRevertSuppression();
Settings.AllocationFixesEnabled = true;
Running = false;
Status = "ERROR";
return false;
}
if (!flag)
{
return false;
}
<>2__current = <inner>5__2.Current;
<>1__state = 1;
return true;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <SampleFrames>d__52 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public float seconds;
public Action<Sample> onDone;
private List<float> <frames>5__2;
private float <elapsed>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SampleFrames>d__52(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<frames>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<frames>5__2 = new List<float>(512);
<elapsed>5__3 = 0f;
break;
case 2:
<>1__state = -1;
break;
}
if (<elapsed>5__3 < seconds)
{
float unscaledDeltaTime = Time.unscaledDeltaTime;
<frames>5__2.Add(unscaledDeltaTime);
<elapsed>5__3 += unscaledDeltaTime;
<>2__current = null;
<>1__state = 2;
return true;
}
onDone(ComputeSample(<frames>5__2));
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();
}
}
[CompilerGenerated]
private sealed class <WaitForAutotuneIfActive>d__29 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForAutotuneIfActive>d__29(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
if (!UpscalerManager.BenchmarkActive)
{
return false;
}
Status = "Waiting for autotune to finish";
goto IL_004e;
case 1:
<>1__state = -1;
goto IL_004e;
case 2:
{
<>1__state = -1;
return false;
}
IL_004e:
if (UpscalerManager.BenchmarkActive)
{
<>2__current = null;
<>1__state = 1;
return true;
}
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 2;
return true;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
internal static string Status = "";
internal static float Progress;
private const float WarmupSeconds = 1.5f;
private const float SampleSeconds = 8f;
private const float SettleSeconds = 1.5f;
private const float UpscalerSampleSeconds = 3f;
private const float ScriptSampleSeconds = 4f;
private const int ScriptTopN = 20;
private static readonly string OutputPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? "", "frame_cost.txt");
private readonly Dictionary<Camera, CamTiming> _camTimings = new Dictionary<Camera, CamTiming>();
private int _savedVSyncCount;
private int _savedTargetFrameRate;
private bool _frameLimitUncapped;
private bool _presetRevertSuppressed;
private float _sweepStartTime;
private float _sweepExpectedDuration;
private float _sweepStartProgress;
private float _sweepEndProgress;
private bool _sweepSmoothActive;
private static readonly Dictionary<Type, (bool upd, bool late, bool fixedU)> _methodCache = new Dictionary<Type, (bool, bool, bool)>();
internal static CostProbe? Instance { get; private set; }
internal static bool Running { get; private set; }
internal static void Toggle()
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
if (Running)
{
Abort();
return;
}
if ((Object)(object)Instance == (Object)null)
{
GameObject val = new GameObject("REPOFidelity_CostProbe");
Object.DontDestroyOnLoad((Object)val);
Instance = val.AddComponent<CostProbe>();
}
((MonoBehaviour)Instance).StartCoroutine(Instance.RunSafe());
}
[IteratorStateMachine(typeof(<WaitForAutotuneIfActive>d__29))]
private IEnumerator WaitForAutotuneIfActive()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForAutotuneIfActive>d__29(0);
}
internal static void Abort()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Expected O, but got Unknown
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Expected O, but got Unknown
if (Running)
{
if ((Object)(object)Instance != (Object)null)
{
((MonoBehaviour)Instance).StopAllCoroutines();
Camera.onPreRender = (CameraCallback)Delegate.Remove((Delegate?)(object)Camera.onPreRender, (Delegate?)new CameraCallback(Instance.OnCamPre));
Camera.onPostRender = (CameraCallback)Delegate.Remove((Delegate?)(object)Camera.onPostRender, (Delegate?)new CameraCallback(Instance.OnCamPost));
Instance._camTimings.Clear();
Instance.RestoreFrameLimit();
Instance.RestorePresetRevertSuppression();
Settings.AllocationFixesEnabled = true;
}
Cursor.lockState = (CursorLockMode)1;
Cursor.visible = false;
Running = false;
Status = "";
Plugin.Log.LogInfo((object)"Cost probe cancelled");
}
}
private void RestoreFrameLimit()
{
if (_frameLimitUncapped)
{
QualitySettings.vSyncCount = _savedVSyncCount;
Application.targetFrameRate = _savedTargetFrameRate;
_frameLimitUncapped = false;
}
}
private void RestorePresetRevertSuppression()
{
if (_presetRevertSuppressed)
{
Settings.PopPresetRevertSuppression();
_presetRevertSuppressed = false;
}
}
private static void AppendConfigFiles(StringBuilder report)
{
string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? "";
AppendFileSection(report, "autotune.json", Path.Combine(path, "autotune.json"));
AppendFileSection(report, "settings.json", Path.Combine(path, "settings.json"));
}
private static void AppendFileSection(StringBuilder report, string label, string path)
{
report.AppendLine("== " + label + " ==");
try
{
report.AppendLine(File.Exists(path) ? File.ReadAllText(path).TrimEnd() : "(missing)");
}
catch (Exception ex)
{
report.AppendLine("(read failed: " + ex.Message + ")");
}
report.AppendLine();
}
private void Update()
{
if (!Running)
{
return;
}
if ((Object)(object)GameDirector.instance != (Object)null)
{
GameDirector.instance.SetDisableInput(1f);
}
if (_sweepSmoothActive && _sweepExpectedDuration > 0f)
{
float num = Mathf.Clamp01((Time.unscaledTime - _sweepStartTime) / _sweepExpectedDuration);
float num2 = Mathf.Lerp(_sweepStartProgress, _sweepEndProgress, num);
if (num2 > Progress)
{
Progress = num2;
}
}
}
[IteratorStateMachine(typeof(<RunSafe>d__36))]
private IEnumerator RunSafe()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <RunSafe>d__36(0)
{
<>4__this = this
};
}
private void OnCamPre(Camera cam)
{
if (Running && !((Object)(object)cam == (Object)null))
{
if (!_camTimings.TryGetValue(cam, out CamTiming value))
{
value = new CamTiming();
_camTimings[cam] = value;
}
value.Sw.Restart();
}
}
private void OnCamPost(Camera cam)
{
if (Running && !((Object)(object)cam == (Object)null) && _camTimings.TryGetValue(cam, out CamTiming value))
{
value.Sw.Stop();
value.TotalMs += value.Sw.Elapsed.TotalMilliseconds;
value.Frames++;
}
}
[IteratorStateMachine(typeof(<Run>d__39))]
private IEnumerator Run()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <Run>d__39(0)
{
<>4__this = this
};
}
private static bool TrySystemClipboard(string text)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Invalid comparison between Unknown and I4
GUIUtility.systemCopyBuffer = text;
if (GUIUtility.systemCopyBuffer == text)
{
return true;
}
if ((int)Application.platform == 13)
{
return TryLinuxClipboardFallback(text);
}
return false;
}
private static bool TryLinuxClipboardFallback(string text)
{
(string, string)[] array = new(string, string)[3]
{
("wl-copy", ""),
("xclip", "-selection clipboard"),
("xsel", "--clipboard --input")
};
for (int i = 0; i < array.Length; i++)
{
var (fileName, arguments) = array[i];
try
{
using Process process = Process.Start(new ProcessStartInfo(fileName, arguments)
{
RedirectStandardInput = true,
UseShellExecute = false,
CreateNoWindow = true
});
if (process != null)
{
process.StandardInput.Write(text);
process.StandardInput.Close();
if (process.WaitForExit(2000) && process.ExitCode == 0)
{
return true;
}
}
}
catch
{
}
}
return false;
}
private static void PatchIfPresent(Type type, string methodName, Harmony harmony, HarmonyMethod prefix, HarmonyMethod postfix, List<MethodInfo> patched)
{
MethodInfo method = type.GetMethod(methodName, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
if (method == null)
{
return;
}
try
{
ScriptTiming.Register(method);
harmony.Patch((MethodBase)method, prefix, postfix, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
patched.Add(method);
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("Probe: can't patch " + type.Name + "." + methodName + ": " + ex.Message));
}
}
private static void AppendMultiplayerSection(StringBuilder report)
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: 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_0202: Unknown result type (might be due to invalid IL or missing references)
//IL_0207: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
PlayerAvatar[] array = Object.FindObjectsOfType<PlayerAvatar>();
if (array.Length == 0)
{
return;
}
Camera main = Camera.main;
Vector3 val = (((Object)(object)main != (Object)null) ? ((Component)main).transform.position : Vector3.zero);
float resolvedEffectiveFogEnd = Settings.ResolvedEffectiveFogEnd;
float num = ((resolvedEffectiveFogEnd > 0f) ? (resolvedEffectiveFogEnd * 1.1f) : float.PositiveInfinity);
report.AppendLine($"== Multiplayer / per-player (fog cutoff {num:F0}m) ==");
report.AppendLine($" PlayerAvatars: {array.Length}");
int num2 = 0;
int num3 = 0;
PlayerAvatar[] array2 = array;
foreach (PlayerAvatar val2 in array2)
{
if ((Object)(object)val2 == (Object)null)
{
continue;
}
float num4 = (((Object)(object)main != (Object)null) ? Vector3.Distance(((Component)val2).transform.position, val) : 0f);
bool flag = num4 > num;
if (flag)
{
num2++;
}
int num5 = 0;
Renderer[] componentsInChildren = ((Component)val2).GetComponentsInChildren<Renderer>(true);
for (int j = 0; j < componentsInChildren.Length; j++)
{
if ((int)componentsInChildren[j].shadowCastingMode != 0)
{
num5++;
}
}
num3 += num5;
string text = (val2.isLocal ? "local" : "remote");
string text2 = (flag ? " past-fog" : "");
report.AppendLine(string.Format(" [{0,-6}] {1,-20} {2,5:F0}m {3,3} casters{4}", text, val2.playerName ?? "(unknown)", num4, num5, text2));
}
report.AppendLine($" Total shadow-casting player renderers: {num3} ({num2} players past fog)");
FlashlightController[] array3 = Object.FindObjectsOfType<FlashlightController>();
if (array3.Length != 0)
{
List<(FlashlightController, float)> list = new List<(FlashlightController, float)>();
FlashlightController[] array4 = array3;
foreach (FlashlightController val3 in array4)
{
if (!((Object)(object)val3.spotlight == (Object)null))
{
float item = (((Object)(object)main != (Object)null) ? Vector3.Distance(((Component)val3.spotlight).transform.position, val) : 0f);
list.Add((val3, item));
}
}
list.Sort(((FlashlightController fl, float dist) a, (FlashlightController fl, float dist) b) => a.dist.CompareTo(b.dist));
int num6 = 0;
int num7 = 0;
int num8 = 0;
foreach (var item2 in list)
{
if (item2.Item2 > num)
{
num8++;
}
else if (num6 < 4)
{
num6++;
}
else
{
num7++;
}
}
report.AppendLine($" Flashlights: {list.Count} total — {num6} within budget, {num7} culled over budget, {num8} past fog");
}
int num9 = Object.FindObjectsOfType<PlayerAvatarEyelids>().Length;
int num10 = Object.FindObjectsOfType<PlayerExpression>().Length;
int num11 = Object.FindObjectsOfType<PlayerAvatarOverchargeVisuals>().Length;
report.AppendLine($" Cosmetic components: Eyelids×{num9} Expression×{num10} Overcharge×{num11}");
report.AppendLine(" (components past fog cutoff skip their Update — see per-player distances above)");
report.AppendLine();
}
private static double LookupMs(List<(string name, string cat, double ms)> list, string marker)
{
foreach (var (text, _, result) in list)
{
if (text == marker)
{
return result;
}
}
return 0.0;
}
private static double LookupCount(List<(string name, string cat, double n)> list, string marker)
{
foreach (var (text, _, result) in list)
{
if (text == marker)
{
return result;
}
}
return 0.0;
}
private static double LookupBytes(List<(string name, string cat, double bytes)> list, string marker)
{
foreach (var (text, _, result) in list)
{
if (text == marker)
{
return result;
}
}
return 0.0;
}
private static string FmtBig(double n)
{
if (n >= 1000000.0)
{
return $"{n / 1000000.0:F2}M";
}
if (n >= 1000.0)
{
return $"{n / 1000.0:F1}K";
}
return $"{n:F0}";
}
private static string FmtBytes(double b)
{
if (b >= 1048576.0)
{
return $"{b / 1048576.0:F2} MB";
}
if (b >= 1024.0)
{
return $"{b / 1024.0:F1} KB";
}
return $"{b:F0} B";
}
private static string Pct(int n, int total)
{
if (total <= 0)
{
return "-";
}
return $"{100.0 * (double)n / (double)total:F0}%";
}
[IteratorStateMachine(typeof(<SampleFrames>d__52))]
private IEnumerator SampleFrames(float seconds, Action<Sample> onDone)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SampleFrames>d__52(0)
{
seconds = seconds,
onDone = onDone
};
}
private static Sample ComputeSample(List<float> frames)
{
if (frames.Count == 0)
{
return default(Sample);
}
float num = 0f;
for (int i = 0; i < frames.Count; i++)
{
num += frames[i];
}
float num2 = num / (float)frames.Count * 1000f;
frames.Sort();
Sample result = default(Sample);
result.AvgFps = 1000f / num2;
result.AvgMs = num2;
result.P1Low = PercentileLow(frames, 0.01f);
result.P01Low = PercentileLow(frames, 0.001f);
result.FrameCount = frames.Count;
return result;
}
private static float PercentileLow(List<float> sorted, float percentile)
{
int num = Mathf.Max(1, Mathf.CeilToInt((float)sorted.Count * percentile));
float num2 = 0f;
for (int num3 = sorted.Count - 1; num3 >= sorted.Count - num; num3--)
{
num2 += sorted[num3];
}
return 1f / (num2 / (float)num);
}
private static (bool upd, bool late, bool fixedU) GetMethodFlags(Type t)
{
if (_methodCache.TryGetValue(t, out (bool, bool, bool) value))
{
return value;
}
bool flag = false;
bool flag2 = false;
bool flag3 = false;
Type type = t;
while (type != null && type != typeof(MonoBehaviour) && type != typeof(Behaviour) && type != typeof(object))
{
if (!flag && type.GetMethod("Update", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null) != null)
{
flag = true;
}
if (!flag2 && type.GetMethod("LateUpdate", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null) != null)
{
flag2 = true;
}
if (!flag3 && type.GetMethod("FixedUpdate", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null) != null)
{
flag3 = true;
}
if (flag && flag2 && flag3)
{
break;
}
type = type.BaseType;
}
(bool, bool, bool) tuple = (flag, flag2, flag3);
_methodCache[t] = tuple;
return tuple;
}
private static SceneMetrics GatherSceneMetrics()
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Invalid comparison between Unknown and I4
//IL_0241: Unknown result type (might be due to invalid IL or missing references)
//IL_0247: Invalid comparison between Unknown and I4
//IL_0262: Unknown result type (might be due to invalid IL or missing references)
//IL_0267: Unknown result type (might be due to invalid IL or missing references)
//IL_0269: Unknown result type (might be due to invalid IL or missing references)
//IL_027c: Expected I4, but got Unknown
//IL_031e: Unknown result type (might be due to invalid IL or missing references)
//IL_0324: Invalid comparison between Unknown and I4
//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
//IL_02ef: Expected I4, but got Unknown
//IL_0328: Unknown result type (might be due to invalid IL or missing references)
//IL_032e: Invalid comparison between Unknown and I4
//IL_0348: Unknown result type (might be due to invalid IL or missing references)
//IL_034e: Invalid comparison between Unknown and I4
//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
SceneMetrics sceneMetrics = default(SceneMetrics);
sceneMetrics.LightDetail = new List<LightInfo>();
sceneMetrics.TopBehaviourTypes = new List<(string, int)>();
SceneMetrics result = sceneMetrics;
MeshRenderer[] array = Object.FindObjectsOfType<MeshRenderer>();
foreach (MeshRenderer obj in array)
{
result.Renderers.Total++;
bool isVisible = ((Renderer)obj).isVisible;
bool num = (int)((Renderer)obj).shadowCastingMode > 0;
if (isVisible)
{
result.Renderers.Visible++;
}
if (num)
{
result.Renderers.ShadowCasting++;
}
if (num && !isVisible)
{
result.Renderers.ShadowCastingHidden++;
}
if ((Object)(object)((Component)obj).GetComponentInParent<LODGroup>() == (Object)null)
{
result.Renderers.NoLODGroup++;
}
MeshFilter component = ((Component)obj).GetComponent<MeshFilter>();
if ((Object)(object)component != (Object)null && (Object)(object)component.sharedMesh != (Object)null)
{
Mesh sharedMesh = component.sharedMesh;
long num2 = 0L;
for (int j = 0; j < sharedMesh.subMeshCount; j++)
{
num2 += sharedMesh.GetIndexCount(j);
}
result.TotalSceneTris += num2 / 3;
}
}
result.SkinnedRenderers = Object.FindObjectsOfType<SkinnedMeshRenderer>().Length;
ParticleSystem[] array2 = Object.FindObjectsOfType<ParticleSystem>();
foreach (ParticleSystem val in array2)
{
result.TotalParticles++;
if (val.isPlaying && val.particleCount > 0)
{
result.ActiveParticles++;
result.ActiveParticleCount += val.particleCount;
}
}
result.ReflectionProbes = Object.FindObjectsOfType<ReflectionProbe>().Length;
result.TrailRenderers = Object.FindObjectsOfType<TrailRenderer>().Length;
result.LineRenderers = Object.FindObjectsOfType<LineRenderer>().Length;
AudioSource[] array3 = Object.FindObjectsOfType<AudioSource>();
foreach (AudioSource obj2 in array3)
{
result.AudioSources++;
if (obj2.isPlaying)
{
result.AudioSourcesPlaying++;
}
}
Light[] array4 = Object.FindObjectsOfType<Light>();
foreach (Light val2 in array4)
{
if (!((Behaviour)val2).enabled || !((Component)val2).gameObject.activeInHierarchy)
{
continue;
}
result.Lights.Active++;
bool flag = (int)val2.shadows > 0;
if (flag)
{
result.Lights.Shadowing++;
}
LightType type = val2.type;
switch ((int)type)
{
case 1:
if (flag)
{
result.Lights.Directional++;
}
break;
case 2:
if (flag)
{
result.Lights.PointShadow++;
}
break;
case 0:
if (flag)
{
result.Lights.SpotShadow++;
}
break;
}
int num3 = val2.shadowCustomResolution;
if (num3 <= 0)
{
LightShadowResolution shadowResolution = val2.shadowResolution;
num3 = (int)shadowResolution switch
{
3 => 4096,
2 => 2048,
1 => 1024,
0 => 512,
_ => 1024,
};
}
float num4 = (((int)val2.type == 2) ? 6f : (((int)val2.type == 1) ? ((float)QualitySettings.shadowCascades) : 1f));
float num5 = (((int)val2.type == 1) ? 2500f : (val2.range * val2.range));
float costScore = (flag ? (num4 * ((float)num3 / 1024f) * ((float)num3 / 1024f) * (num5 / 100f)) : 0f);
List<LightInfo> lightDetail = result.LightDetail;
LightInfo item = new LightInfo
{
Name = ((Object)val2).name
};
type = val2.type;
item.Type = ((object)(LightType)(ref type)).ToString();
item.Range = val2.range;
item.Resolution = num3;
object shadowMode;
if (!flag)
{
shadowMode = "Off";
}
else
{
LightShadows shadows = val2.shadows;
shadowMode = ((object)(LightShadows)(ref shadows)).ToString();
}
item.ShadowMode = (string)shadowMode;
item.CostScore = costScore;
lightDetail.Add(item);
}
Dictionary<Type, int> dictionary = new Dictionary<Type, int>();
MonoBehaviour[] array5 = Object.FindObjectsOfType<MonoBehaviour>();
foreach (MonoBehaviour val3 in array5)
{
if (!((Behaviour)val3).isActiveAndEnabled)
{
continue;
}
Type type2 = ((object)val3).GetType();
var (flag2, flag3, flag4) = GetMethodFlags(type2);
if (flag2)
{
result.UpdatingBehaviours++;
}
if (flag3)
{
result.LateUpdatingBehaviours++;
}
if (flag4)
{
result.FixedUpdatingBehaviours++;
}
if (flag2)
{
if (!dictionary.TryGetValue(type2, out var value))
{
value = 0;
}
dictionary[type2] = value + 1;
}
}
foreach (KeyValuePair<Type, int> item2 in dictionary.OrderByDescending((KeyValuePair<Type, int> k) => k.Value))
{
result.TopBehaviourTypes.Add((item2.Key.Name, item2.Value));
}
return result;
}
private static void BuildOpportunities(StringBuilder r, List<(string name, string cat, double ms)> timeStats, List<(string name, string cat, double n)> countStats, List<(string name, string cat, double bytes)> memStats, SceneMetrics scene, List<(string label, double totalMs, double perCallUs, int calls)> scriptTimings)
{
List<(double, string)> list = new List<(double, string)>();
double num = LookupMs(timeStats, "Physics.Simulate") + LookupMs(timeStats, "FixedUpdate.PhysicsFixedUpdate");
double num2 = LookupMs(timeStats, "Animators.Update");
double num3 = LookupMs(timeStats, "Particles.Update");
double num4 = LookupMs(timeStats, "Camera.ImageEffects");
double num5 = LookupBytes(memStats, "GC Allocated In Frame");
int num6 = 0;
foreach (var (text, num7, num8, num9) in scriptTimings)
{
if (num7 < 0.05 || num6 >= 3)
{
break;
}
list.Add((num7 * 200.0, $"Top script cost: {text} — {num7:F3} ms/frame ({num9} calls at {num8:F1} µs each). " + "Rate-limit, cache, or Harmony-prefix-skip when state hasn't changed."));
num6++;
}
if (scene.Renderers.ShadowCastingHidden > 0 && scene.Renderers.Total > 0)
{
double num10 = (double)scene.Renderers.ShadowCastingHidden / (double)scene.Renderers.Total;
list.Add((num10 * 300.0, $"{scene.Renderers.ShadowCastingHidden} off-screen shadow casters ({num10 * 100.0:F0}% of scene renderers). " + "Prefabs that don't need to cast shadows should set shadowCastingMode=Off — cost isn't directly visible in retail markers but cubemap passes are real."));
}
if (scene.Renderers.NoLODGroup > 300)
{
list.Add(((double)scene.Renderers.NoLODGroup / 4.0, $"{scene.Renderers.NoLODGroup} renderers have no LODGroup ({Pct(scene.Renderers.NoLODGroup, scene.Renderers.Total)}). Distant small objects render at full detail — most impactful when main-cam render cost is high."));
}
if (scene.Lights.PointShadow > 8)
{
list.Add((scene.Lights.PointShadow * 10, $"{scene.Lights.PointShadow} point lights with shadows × 6 faces = {scene.Lights.PointShadow * 6} cubemap passes/frame. Shadow budget + resolution tiering are the highest-leverage knobs."));
}
if (num > 0.3)
{
list.Add((num * 70.0, $"Physics costs {num:F2} ms/frame. Trim layer collision matrix, raise fixed timestep interval, switch non-dynamic rigidbodies to kinematic."));
}
if (num2 > 0.2)
{
list.Add((num2 * 60.0, $"Animators.Update costs {num2:F2} ms/frame across {scene.SkinnedRenderers} skinned renderers. Set Animator.cullingMode=BasedOnRenderers / CullCompletely on distant characters."));
}
if (num3 > 0.2)
{
list.Add((num3 * 60.0, $"Particles.Update costs {num3:F2} ms/frame across {scene.ActiveParticles} active systems ({FmtBig(scene.ActiveParticleCount)} particles alive). Distance-cull emit rate."));
}
if (num4 > 0.3)
{
list.Add((num4 * 50.0, $"Camera.ImageEffects (post-processing stack) costs {num4:F2} ms/frame. Audit which OnRenderImage passes are doing work."));
}
if (num5 > 1024.0)
{
list.Add((num5 / 64.0, "GC allocates " + FmtBytes(num5) + "/frame — hunt per-frame boxing, closures, and ToArray/ToList calls."));
}
double num11 = LookupCount(countStats, "Draw Calls Count");
if (num11 > 1500.0)
{
list.Add((num11 / 40.0, $"{num11:F0} draw calls / frame. Static batching or GPU instancing on recurring prefabs would cut CPU cost."));
}
if (scene.ReflectionProbes > 1)
{
list.Add((scene.ReflectionProbes * 3, $"{scene.ReflectionProbes} reflection probes — each realtime probe updating adds CPU+GPU cost. Mark as baked or type=Custom when possible."));
}
if (list.Count == 0)
{
r.AppendLine(" (no high-cost categories detected — baseline looks clean)");
return;
}
list.Sort(((double priority, string text) a, (double priority, string text) b) => b.priority.CompareTo(a.priority));
int num12 = 1;
foreach (var item2 in list)
{
string item = item2.Item2;
r.AppendLine($" {num12++}. {item}");
}
}
}
internal static class DLSSDownloader
{
private const string DllName = "nvngx_dlss.dll";
private const int MinDllSize = 10000000;
internal static string GetDllPath()
{
return Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? "", "nvngx_dlss.dll");
}
internal static bool EnsureAvailable()
{
string dllPath = GetDllPath();
int num;
if (File.Exists(dllPath))
{
num = ((new FileInfo(dllPath).Length >= 10000000) ? 1 : 0);
if (num != 0)
{
Plugin.Log.LogDebug((object)$"DLSS DLL: {dllPath} ({new FileInfo(dllPath).Length / 1024 / 1024}MB)");
return (byte)num != 0;
}
}
else
{
num = 0;
}
Plugin.Log.LogWarning((object)"nvngx_dlss.dll missing or invalid — DLSS/DLAA disabled. Reinstall the mod.");
return (byte)num != 0;
}
}
internal static class FrameTimeMeter
{
internal class Meter
{
public readonly string Name;
public readonly string ShortName;
private readonly float[] _samples;
private int _index;
private int _count;
private float _sum;
public float LastUs;
public float AverageUs
{
get
{
if (_count <= 0)
{
return 0f;
}
return _sum / (float)_count;
}
}
public float AverageMs => AverageUs / 1000f;
public Meter(string name, string shortName, int windowSize = 120)
{
Name = name;
ShortName = shortName;
_samples = new float[windowSize];
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Record(float microseconds)
{
LastUs = microseconds;
_sum -= _samples[_index];
_samples[_index] = microseconds;
_sum += microseconds;
_index = (_index + 1) % _samples.Length;
if (_count < _samples.Length)
{
_count++;
}
}
}
private static readonly Stopwatch _sw = Stopwatch.StartNew();
internal static readonly Meter EnemyDirector = new Meter("EnemyDirector Throttle", "EnemyDir");
internal static readonly Meter RoomVolumeCheck = new Meter("RoomVolume NonAlloc", "RoomVol");
internal static readonly Meter SemiFuncCache = new Meter("SemiFunc Cache", "SemiFunc");
internal static readonly Meter PhysGrabObjectFix = new Meter("PhysGrabObject Fix", "PhysGrab");
internal static readonly Meter LightManagerBatch = new Meter("LightManager Batch", "LightMgr");
internal static readonly Meter SceneApply = new Meter("SceneOptimizer Apply", "SceneApl");
internal static readonly Meter[] All = new Meter[6] { EnemyDirector, RoomVolumeCheck, SemiFuncCache, PhysGrabObjectFix, LightManagerBatch, SceneApply };
internal static bool Active
{
get
{
if (!Settings.DebugOverlay)
{
return OptimizerBenchmark.Running;
}
return true;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static long Begin()
{
if (!Active)
{
return 0L;
}
return _sw.ElapsedTicks;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void End(Meter meter, long startTicks)
{
if (startTicks != 0L)
{
float microseconds = (float)((double)(_sw.ElapsedTicks - startTicks) / 10.0);
meter.Record(microseconds);
}
}
}
internal enum GpuVendor
{
Nvidia,
Amd,
Intel,
Apple,
Unknown
}
internal enum GpuTier
{
High,
Mid,
Low
}
internal static class GPUDetector
{
private static readonly Regex ArcDiscretePattern = new Regex("\\b[AB]\\d{3}\\b", RegexOptions.Compiled);
public static string GpuName { get; private set; } = "Unknown";
public static GpuVendor Vendor { get; private set; } = GpuVendor.Unknown;
public static GpuTier Tier { get; private set; } = GpuTier.Low;
public static bool DlssAvailable { get; private set; }
public static int VramMb { get; private set; }
public static bool IsD3D11 { get; private set; }
public static bool IsIntegratedGpu { get; private set; }
public static void Detect()
{
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Invalid comparison between Unknown and I4
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
GpuName = SystemInfo.graphicsDeviceName ?? "Unknown";
VramMb = SystemInfo.graphicsMemorySize;
Vendor = DetectVendor(GpuName, SystemInfo.graphicsDeviceVendor);
Tier = DetectTier(VramMb);
IsD3D11 = (int)SystemInfo.graphicsDeviceType == 2;
IsIntegratedGpu = DetectIntegrated(GpuName, VramMb, Vendor);
DlssAvailable = Vendor == GpuVendor.Nvidia && IsD3D11 && !IsIntegratedGpu && GpuName.ToUpperInvariant().Contains("RTX");
Plugin.Log.LogInfo((object)($"GPU: {GpuName} | Vendor: {Vendor} | VRAM: {VramMb}MB | " + $"API: {SystemInfo.graphicsDeviceType} | iGPU: {IsIntegratedGpu} | Tier: {Tier}"));
}
public static bool IsUpscalerSupported(UpscaleMode mode)
{
switch (mode)
{
case UpscaleMode.Auto:
return true;
case UpscaleMode.Off:
return true;
case UpscaleMode.DLAA:
case UpscaleMode.DLSS:
return DlssAvailable;
case UpscaleMode.FSR_Temporal:
return true;
default:
return false;
}
}
public static string[] GetAvailableUpscalerNames()
{
List<string> list = new List<string>();
foreach (UpscaleMode value in Enum.GetValues(typeof(UpscaleMode)))
{
if (value != UpscaleMode.FSR && value != UpscaleMode.FSR4 && value != UpscaleMode.DLAA && IsUpscalerSupported(value))
{
string item = ((value == UpscaleMode.FSR_Temporal) ? "FSR" : value.ToString());
list.Add(item);
}
}
return list.ToArray();
}
private static GpuVendor DetectVendor(string name, string vendorString)
{
string text = (name + " " + vendorString).ToUpperInvariant();
if (text.Contains("NVIDIA"))
{
return GpuVendor.Nvidia;
}
if (text.Contains("AMD") || text.Contains("ATI"))
{
return GpuVendor.Amd;
}
if (text.Contains("INTEL"))
{
return GpuVendor.Intel;
}
if (text.Contains("APPLE"))
{
return GpuVendor.Apple;
}
return GpuVendor.Unknown;
}
private static GpuTier DetectTier(int vramMb)
{
if (vramMb >= 8000)
{
return GpuTier.High;
}
if (vramMb >= 6000)
{
return GpuTier.Mid;
}
return GpuTier.Low;
}
private static bool DetectIntegrated(string name, int vramMb, GpuVendor vendor)
{
string text = name.ToUpperInvariant();
if (vendor == GpuVendor.Intel && (text.Contains("UHD") || text.Contains("IRIS") || text.Contains("HD GRAPHICS") || (text.Contains("ARC") && !ArcDiscretePattern.IsMatch(text))))
{
return true;
}
if (vendor == GpuVendor.Amd && ((text.Contains("VEGA") && !text.Contains("VEGA 56") && !text.Contains("VEGA 64")) || (text.Contains("RADEON GRAPHICS") && !text.Contains("RX"))))
{
return true;
}
if (vramMb > 0 && vramMb < 2048)
{
return true;
}
return false;
}
}
internal static class LightDiagnostics
{
private struct LightEntry
{
public string Name;
public LightType Type;
public LightShadows ShadowMode;
public int ShadowRes;
public ShadowResolution GlobalShadowRes;
public int EffectiveRes;
public float Range;
public float Intensity;
public Color Color;
public bool Enabled;
public bool CastsShadows;
public LightRenderMode RenderMode;
public bool HasLightAnimator;
public bool HasItemLight;
public bool HasFlashlight;
public bool HasExplosion;
public int ShadowFaces;
public float ShadowCost;
public int RenderersInRange;
public int EstDrawCalls;
}
private static readonly string OutputPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? "", "light_diagnostics.txt");
internal static void Run()
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00d6: Invalid comparison between Unknown and I4
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_014a: Unknown result type (might be due to invalid IL or missing references)
//IL_014f: Unknown result type (might be due to invalid IL or missing references)
//IL_0151: Unknown result type (might be due to invalid IL or missing references)
//IL_0164: Expected I4, but got Unknown
//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
//IL_037c: Unknown result type (might be due to invalid IL or missing references)
//IL_0381: Unknown result type (might be due to invalid IL or missing references)
//IL_0383: Unknown result type (might be due to invalid IL or missing references)
//IL_0396: Expected I4, but got Unknown
//IL_0207: Unknown result type (might be due to invalid IL or missing references)
//IL_023e: Unknown result type (might be due to invalid IL or missing references)
//IL_0830: Unknown result type (might be due to invalid IL or missing references)
//IL_0849: Unknown result type (might be due to invalid IL or missing references)
//IL_088d: Unknown result type (might be due to invalid IL or missing references)
//IL_08a1: Unknown result type (might be due to invalid IL or missing references)
//IL_08b5: Unknown result type (might be due to invalid IL or missing references)
//IL_08f8: Unknown result type (might be due to invalid IL or missing references)
Light[] array = Object.FindObjectsOfType<Light>();
if (array.Length == 0)
{
Plugin.Log.LogInfo((object)"Light diagnostics: no lights found");
return;
}
List<LightEntry> list = new List<LightEntry>();
Light[] array2 = array;
foreach (Light val in array2)
{
LightEntry lightEntry = default(LightEntry);
lightEntry.Name = GetPath(((Component)val).transform);
lightEntry.Type = val.type;
lightEntry.ShadowMode = val.shadows;
lightEntry.ShadowRes = val.shadowCustomResolution;
lightEntry.GlobalShadowRes = QualitySettings.shadowResolution;
lightEntry.Range = val.range;
lightEntry.Intensity = val.intensity;
lightEntry.Color = val.color;
lightEntry.Enabled = ((Behaviour)val).enabled && ((Component)val).gameObject.activeInHierarchy;
lightEntry.CastsShadows = (int)val.shadows > 0;
lightEntry.RenderMode = val.renderMode;
LightEntry item = lightEntry;
GameObject gameObject = ((Component)val).gameObject;
item.HasLightAnimator = (Object)(object)gameObject.GetComponent<LightAnimator>() != (Object)null;
item.HasItemLight = (Object)(object)gameObject.GetComponent<ItemLight>() != (Object)null;
item.HasFlashlight = (Object)(object)gameObject.GetComponent<FlashlightController>() != (Object)null;
item.HasExplosion = (Object)(object)gameObject.GetComponentInParent<ParticlePrefabExplosion>() != (Object)null;
LightType type = val.type;
item.ShadowFaces = (int)type switch
{
2 => 6,
0 => 1,
1 => QualitySettings.shadowCascades,
_ => 0,
};
int num = (item.EffectiveRes = ((item.ShadowRes > 0) ? item.ShadowRes : GlobalResValue()));
if (item.CastsShadows && item.Enabled)
{
item.ShadowCost = (float)item.ShadowFaces * ((float)num * (float)num / 1048576f);
}
else
{
item.ShadowCost = 0f;
}
if (item.CastsShadows && item.Enabled)
{
int num2 = 0;
Collider[] array3 = Physics.OverlapSphere(((Component)val).transform.position, val.range);
HashSet<Renderer> hashSet = new HashSet<Renderer>();
Collider[] array4 = array3;
for (int j = 0; j < array4.Length; j++)
{
Renderer component = ((Component)array4[j]).GetComponent<Renderer>();
if ((Object)(object)component != (Object)null && (int)component.shadowCastingMode != 0 && hashSet.Add(component))
{
num2++;
}
}
item.RenderersInRange = num2;
item.EstDrawCalls = num2 * item.ShadowFaces;
}
list.Add(item);
}
list.Sort((LightEntry a, LightEntry b) => b.ShadowCost.CompareTo(a.ShadowCost));
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine("══════════════════════════════════════════════════════════════");
stringBuilder.AppendLine($" LIGHT DIAGNOSTICS — {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
stringBuilder.AppendLine("══════════════════════════════════════════════════════════════");
stringBuilder.AppendLine();
stringBuilder.AppendLine($" Total lights: {array.Length}");
int num3 = 0;
int num4 = 0;
int num5 = 0;
int num6 = 0;
int num7 = 0;
int num8 = 0;
int num9 = 0;
int num10 = 0;
int num11 = 0;
int num12 = 0;
int num13 = 0;
float num14 = 0f;
int num15 = 0;
foreach (LightEntry item2 in list)
{
if (item2.Enabled)
{
num3++;
}
if (item2.CastsShadows && item2.Enabled)
{
num4++;
}
LightType type = item2.Type;
switch ((int)type)
{
case 2:
num5++;
break;
case 0:
num6++;
break;
case 1:
num7++;
break;
default:
num8++;
break;
}
if (item2.HasLightAnimator)
{
num9++;
}
else if (item2.HasItemLight)
{
num10++;
}
else if (item2.HasFlashlight)
{
num11++;
}
else if (item2.HasExplosion)
{
num12++;
}
else
{
num13++;
}
num14 += item2.ShadowCost;
num15 += item2.EstDrawCalls;
}
stringBuilder.AppendLine($" Active: {num3}");
stringBuilder.AppendLine($" Casting shadows: {num4}");
stringBuilder.AppendLine();
stringBuilder.AppendLine($" By type: Point={num5} Spot={num6} Directional={num7} Area={num8}");
stringBuilder.AppendLine($" By component: Plain={num13} LightAnimator={num9} ItemLight={num10} Flashlight={num11} Explosion={num12}");
stringBuilder.AppendLine();
stringBuilder.AppendLine($" Global shadow res: {QualitySettings.shadowResolution}");
stringBuilder.AppendLine($" Shadow distance: {QualitySettings.shadowDistance:F0}m");
stringBuilder.AppendLine($" Shadow cascades: {QualitySettings.shadowCascades}");
stringBuilder.AppendLine();
stringBuilder.AppendLine($" Total shadow cost: {num14:F1} (relative units: faces x res²/1M)");
stringBuilder.AppendLine($" Est shadow draw calls:{num15}");
stringBuilder.AppendLine();
stringBuilder.AppendLine("──────────────────────────────────────────────────────────────");
stringBuilder.AppendLine(" COST BY CATEGORY");
stringBuilder.AppendLine("──────────────────────────────────────────────────────────────");
float num16 = 0f;
float num17 = 0f;
float num18 = 0f;
float num19 = 0f;
float num20 = 0f;
int num21 = 0;
int num22 = 0;
int num23 = 0;
int num24 = 0;
int num25 = 0;
foreach (LightEntry item3 in list)
{
if (item3.HasLightAnimator)
{
num17 += item3.ShadowCost;
num22 += item3.EstDrawCalls;
}
else if (item3.HasItemLight)
{
num18 += item3.ShadowCost;
num23 += item3.EstDrawCalls;
}
else if (item3.HasFlashlight)
{
num19 += item3.ShadowCost;
num24 += item3.EstDrawCalls;
}
else if (item3.HasExplosion)
{
num20 += item3.ShadowCost;
num25 += item3.EstDrawCalls;
}
else
{
num16 += item3.ShadowCost;
num21 += item3.EstDrawCalls;
}
}
stringBuilder.AppendLine($" Plain Light: cost={num16,8:F1} est draw calls={num21,6}");
stringBuilder.AppendLine($" LightAnimator: cost={num17,8:F1} est dra
