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 BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FPSCounter;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using PerformanceTracker.Util;
using PerformanceTracker.Util.Helpers;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("PerformanceTracker")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Azumatt")]
[assembly: AssemblyProduct("PerformanceTracker")]
[assembly: AssemblyCopyright("Copyright © 2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("E0E2F92E-557C-4A05-9D89-AA92A0BD75C4")]
[assembly: AssemblyFileVersion("1.0.3")]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.3.0")]
[module: UnverifiableCode]
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;
}
}
}
namespace PerformanceTracker
{
[BepInPlugin("Azumatt.PerformanceTracker", "PerformanceTracker", "1.0.3")]
public class PerformanceTrackerPlugin : BaseUnityPlugin
{
public enum Toggle
{
On = 1,
Off = 0
}
public enum CounterColors
{
White,
Black,
Outline
}
private class ConfigurationManagerAttributes
{
[UsedImplicitly]
public int? Order;
[UsedImplicitly]
public bool? Browsable;
[UsedImplicitly]
public string? Category;
[UsedImplicitly]
public Action<ConfigEntryBase>? CustomDrawer;
}
internal const string ModName = "PerformanceTracker";
internal const string ModVersion = "1.0.3";
internal const string Author = "Azumatt";
internal const string ModGUID = "Azumatt.PerformanceTracker";
private static string ConfigFileName = "Azumatt.PerformanceTracker.cfg";
private static string ConfigFileFullPath;
internal static string ConnectionError;
private readonly Harmony _harmony = new Harmony("Azumatt.PerformanceTracker");
internal static PerformanceTrackerPlugin ModContext;
internal static GameObject pluginGO;
public static readonly ManualLogSource PerformanceTrackerLogger;
private static ConfigEntry<Toggle> _serverConfigLocked;
private static ConfigEntry<KeyboardShortcut> _showCounter;
internal static ConfigEntry<CounterColors> _counterColor;
internal static ConfigEntry<TextAnchor> _position;
internal static ConfigEntry<Toggle> _shown;
internal static ConfigEntry<Toggle> _showPluginStats;
internal static ConfigEntry<Toggle> _showUnityMethodStats;
internal static ConfigEntry<Toggle> _measureMemory;
public void Awake()
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
ModContext = this;
pluginGO = ((Component)this).gameObject;
_showCounter = config<KeyboardShortcut>("1 - General", "Toggle counter and reset stats", new KeyboardShortcut((KeyCode)117, (KeyCode[])(object)new KeyCode[1] { (KeyCode)304 }), "Key to enable and disable the plugin.");
_shown = config("1 - General", "Enable", Toggle.On, "Monitor performance statistics and show them on the screen. When disabled the plugin has no effect on performance.");
_showPluginStats = config("1 - General", "Enable monitoring plugins", Toggle.On, "Count time each plugin takes every frame to execute. Only detects MonoBehaviour event methods, so results might be lower than expected. Has a small performance penalty.");
_showUnityMethodStats = config("1 - General", "Show detailed frame stats", Toggle.On, "Show how much time was spent by Unity in each part of the frame, for example how long it took to run all Update methods.");
try
{
MemoryInfo.PROCESS_MEMORY_COUNTERS pROCESS_MEMORY_COUNTERS = MemoryInfo.QueryProcessMemStatus();
MemoryInfo.MEMORYSTATUSEX mEMORYSTATUSEX = MemoryInfo.QuerySystemMemStatus();
if (pROCESS_MEMORY_COUNTERS.WorkingSetSize == 0 || mEMORYSTATUSEX.ullTotalPhys == 0)
{
throw new IOException("Empty data was returned");
}
_measureMemory = config("General", "Show memory and GC stats", Toggle.On, "Show memory usage of the process, free available physical memory and garbage collector statistics (if available).");
}
catch (Exception ex)
{
PerformanceTrackerLogger.LogWarning((object)("Memory statistics are not available - " + ex.Message));
}
_position = config<TextAnchor>("Interface", "Screen position", (TextAnchor)8, "Which corner of the screen to display the statistics in.");
_counterColor = config("Interface", "Color of the text", CounterColors.White, "Color of the displayed stats. Outline has a performance hit but it always easy to see.");
_position.SettingChanged += delegate
{
UIHelper.UpdateLooks();
};
_counterColor.SettingChanged += delegate
{
UIHelper.UpdateLooks();
};
_shown.SettingChanged += delegate
{
UIHelper.UpdateLooks();
Helpers.SetCapturingEnabled(_shown.Value == Toggle.On);
};
_showPluginStats.SettingChanged += delegate
{
Helpers.SetCapturingEnabled(_shown.Value == Toggle.On);
};
OnEnable();
Assembly executingAssembly = Assembly.GetExecutingAssembly();
_harmony.PatchAll(executingAssembly);
SetupWatcher();
}
private void OnEnable()
{
Helpers.OnEnable();
}
private void OnDisable()
{
Helpers.OnDisable();
}
private void Update()
{
//IL_0005: 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)
KeyboardShortcut value = _showCounter.Value;
if (((KeyboardShortcut)(ref value)).IsDown())
{
_shown.Value = ((_shown.Value == Toggle.Off) ? Toggle.On : Toggle.Off);
}
}
private void OnDestroy()
{
((BaseUnityPlugin)this).Config.Save();
Helpers.SetCapturingEnabled(enableCapturing: false);
}
private void SetupWatcher()
{
FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
fileSystemWatcher.Changed += ReadConfigValues;
fileSystemWatcher.Created += ReadConfigValues;
fileSystemWatcher.Renamed += ReadConfigValues;
fileSystemWatcher.IncludeSubdirectories = true;
fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
fileSystemWatcher.EnableRaisingEvents = true;
}
private void ReadConfigValues(object sender, FileSystemEventArgs e)
{
if (!File.Exists(ConfigFileFullPath))
{
return;
}
try
{
PerformanceTrackerLogger.LogDebug((object)"ReadConfigValues called");
((BaseUnityPlugin)this).Config.Reload();
}
catch
{
PerformanceTrackerLogger.LogError((object)("There was an issue loading your " + ConfigFileName));
PerformanceTrackerLogger.LogError((object)"Please check your config entries for spelling and format!");
}
}
private ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description)
{
return ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, description);
}
private ConfigEntry<T> config<T>(string group, string name, T value, string description)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Expected O, but got Unknown
return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
}
static PerformanceTrackerPlugin()
{
string configPath = Paths.ConfigPath;
char directorySeparatorChar = Path.DirectorySeparatorChar;
ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
ConnectionError = "";
pluginGO = null;
PerformanceTrackerLogger = Logger.CreateLogSource("PerformanceTracker");
_serverConfigLocked = null;
}
}
}
namespace PerformanceTracker.Util
{
internal static class MemoryInfo
{
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public class MEMORYSTATUSEX
{
public uint dwLength;
public uint dwMemoryLoad;
public ulong ullTotalPhys;
public ulong ullAvailPhys;
public ulong ullTotalPageFile;
public ulong ullAvailPageFile;
public ulong ullTotalVirtual;
public ulong ullAvailVirtual;
public ulong ullAvailExtendedVirtual;
public MEMORYSTATUSEX()
{
dwLength = (uint)Marshal.SizeOf(typeof(MEMORYSTATUSEX));
}
}
[StructLayout(LayoutKind.Sequential, Size = 72)]
public class PROCESS_MEMORY_COUNTERS
{
public uint cb;
public uint PageFaultCount;
public ulong PeakWorkingSetSize;
public ulong WorkingSetSize;
public ulong QuotaPeakPagedPoolUsage;
public ulong QuotaPagedPoolUsage;
public ulong QuotaPeakNonPagedPoolUsage;
public ulong QuotaNonPagedPoolUsage;
public ulong PagefileUsage;
public ulong PeakPagefileUsage;
public PROCESS_MEMORY_COUNTERS()
{
cb = (uint)Marshal.SizeOf(typeof(PROCESS_MEMORY_COUNTERS));
}
}
private static readonly IntPtr _currentProcessHandle = GetCurrentProcess();
private static readonly MEMORYSTATUSEX _memorystatusex = new MEMORYSTATUSEX();
private static readonly PROCESS_MEMORY_COUNTERS _memoryCounters = new PROCESS_MEMORY_COUNTERS();
public static MEMORYSTATUSEX QuerySystemMemStatus()
{
if (GlobalMemoryStatusEx(_memorystatusex))
{
return _memorystatusex;
}
throw new Exception("GlobalMemoryStatusEx returned false. Error Code is " + Marshal.GetLastWin32Error());
}
public static PROCESS_MEMORY_COUNTERS QueryProcessMemStatus()
{
if (GetProcessMemoryInfo(_currentProcessHandle, _memoryCounters, _memoryCounters.cb))
{
return _memoryCounters;
}
throw new Exception("GetProcessMemoryInfo returned false. Error Code is " + Marshal.GetLastWin32Error());
}
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool GlobalMemoryStatusEx([In][Out] MEMORYSTATUSEX lpBuffer);
[DllImport("kernel32.dll")]
private static extern IntPtr GetCurrentProcess();
[DllImport("psapi.dll", SetLastError = true)]
private static extern bool GetProcessMemoryInfo(IntPtr hProcess, [In][Out] PROCESS_MEMORY_COUNTERS counters, uint size);
}
internal class MovingAverage
{
private readonly int _windowSize;
private readonly Queue<long> _samples;
private long _sampleAccumulator;
public MovingAverage(int windowSize = 11)
{
_windowSize = windowSize;
_samples = new Queue<long>(_windowSize + 1);
}
public long GetAverage()
{
return _sampleAccumulator / _samples.Count;
}
public float GetAverageFloat()
{
return _sampleAccumulator / _samples.Count;
}
public void Sample(long newSample)
{
_sampleAccumulator += newSample;
_samples.Enqueue(newSample);
if (_samples.Count > _windowSize)
{
_sampleAccumulator -= _samples.Dequeue();
}
}
}
internal static class PluginCounter
{
private static readonly Dictionary<BepInPlugin, KeyValuePair<MovingAverage, List<Stopwatch>>> _averages = new Dictionary<BepInPlugin, KeyValuePair<MovingAverage, List<Stopwatch>>>();
private static readonly Dictionary<Type, KeyValuePair<BepInPlugin, Stopwatch>> _timers = new Dictionary<Type, KeyValuePair<BepInPlugin, Stopwatch>>();
private static List<KeyValuePair<string, long>> _sortedList;
private static Harmony _harmonyInstance;
private static bool _running;
private static Action _stopAction;
private static readonly WaitForEndOfFrame _waitForEndOfFrame = new WaitForEndOfFrame();
public static List<KeyValuePair<string, long>> SlowPlugins => _sortedList;
public static void Start(MonoBehaviour mb, BaseUnityPlugin thisPlugin)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Expected O, but got Unknown
//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
//IL_01e9: Expected O, but got Unknown
//IL_01e9: Expected O, but got Unknown
BaseUnityPlugin thisPlugin2 = thisPlugin;
MonoBehaviour mb2 = mb;
if (_running)
{
return;
}
_running = true;
if (_harmonyInstance == null)
{
_harmonyInstance = new Harmony("Azumatt.PerformanceTracker");
}
int num = 0;
Type baseType = typeof(MonoBehaviour);
string[] array = new string[4] { "FixedUpdate", "Update", "LateUpdate", "OnGUI" };
foreach (BaseUnityPlugin item in Chainloader.Plugins.Where((BaseUnityPlugin x) => (Object)(object)x != (Object)null && (Object)(object)x != (Object)(object)thisPlugin2))
{
Stopwatch stopwatch = new Stopwatch();
foreach (Type item2 in (from x in SafeGetTypes(((object)item).GetType().Assembly)
where baseType.IsAssignableFrom(x) && !x.IsAbstract
select x).ToList())
{
string[] array2 = array;
foreach (string name in array2)
{
MethodInfo method = item2.GetMethod(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (method == null)
{
continue;
}
if (!_timers.ContainsKey(item2))
{
BepInPlugin metadata = item.Info.Metadata;
_timers[item2] = new KeyValuePair<BepInPlugin, Stopwatch>(metadata, stopwatch);
if (!_averages.TryGetValue(metadata, out KeyValuePair<MovingAverage, List<Stopwatch>> value))
{
value = new KeyValuePair<MovingAverage, List<Stopwatch>>(new MovingAverage(60), new List<Stopwatch>());
_averages.Add(metadata, value);
}
value.Value.Add(stopwatch);
}
try
{
_harmonyInstance.Patch((MethodBase)method, new HarmonyMethod(AccessTools.Method(typeof(PluginCounter), "Pre", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.Method(typeof(PluginCounter), "Post", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
num++;
}
catch (Exception ex)
{
PerformanceTrackerPlugin.PerformanceTrackerLogger.LogError((object)ex);
}
}
}
}
_sortedList = new List<KeyValuePair<string, long>>(_averages.Count);
Coroutine co = mb2.StartCoroutine(CollectLoop());
_stopAction = delegate
{
mb2.StopCoroutine(co);
};
PerformanceTrackerPlugin.PerformanceTrackerLogger.LogDebug((object)$"Attached timers to {num} unity methods in {Chainloader.Plugins.Count} plugins");
}
public static void Stop()
{
if (!_running)
{
return;
}
_harmonyInstance.UnpatchSelf();
_running = false;
foreach (KeyValuePair<Type, KeyValuePair<BepInPlugin, Stopwatch>> timer in _timers)
{
timer.Value.Value.Reset();
}
_timers.Clear();
_averages.Clear();
_stopAction();
_sortedList = null;
}
private static IEnumerator CollectLoop()
{
long num = 100000000 / Stopwatch.Frequency;
_ = 1f / ((float)num * 1000f);
long cutoffTicks = num * 100;
while (true)
{
yield return _waitForEndOfFrame;
_sortedList.Clear();
foreach (KeyValuePair<BepInPlugin, KeyValuePair<MovingAverage, List<Stopwatch>>> average2 in _averages)
{
long num2 = 0L;
int count = average2.Value.Value.Count;
for (int i = 0; i < count; i++)
{
num2 += average2.Value.Value[i].ElapsedTicks;
}
MovingAverage key = average2.Value.Key;
key.Sample(num2);
long average = key.GetAverage();
if (average > cutoffTicks)
{
_sortedList.Add(new KeyValuePair<string, long>(average2.Key.Name, average));
}
}
foreach (KeyValuePair<Type, KeyValuePair<BepInPlugin, Stopwatch>> timer in _timers)
{
timer.Value.Value.Reset();
}
}
}
private static void Post(MonoBehaviour __instance, MethodInfo __originalMethod)
{
if ((FrameCounterHelper.CanProcessOnGui || !(__originalMethod.Name == "OnGUI")) && _timers.TryGetValue(((object)__instance).GetType(), out KeyValuePair<BepInPlugin, Stopwatch> value))
{
value.Value.Stop();
}
}
private static void Pre(MonoBehaviour __instance, MethodInfo __originalMethod)
{
if ((FrameCounterHelper.CanProcessOnGui || !(__originalMethod.Name == "OnGUI")) && _timers.TryGetValue(((object)__instance).GetType(), out KeyValuePair<BepInPlugin, Stopwatch> value))
{
value.Value.Start();
}
}
private static IEnumerable<Type> SafeGetTypes(Assembly ass)
{
try
{
return ass.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
return ex.Types.Where((Type x) => x != null);
}
}
}
internal static class ShadowAndOutline
{
public static void DrawOutline(Rect rect, string text, GUIStyle style, Color outColor, Color inColor, float size)
{
//IL_0009: 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_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
float num = size * 0.5f;
Color color = GUI.color;
style.normal.textColor = outColor;
GUI.color = outColor;
((Rect)(ref rect)).x = ((Rect)(ref rect)).x - num;
GUI.Label(rect, text, style);
((Rect)(ref rect)).x = ((Rect)(ref rect)).x + size;
GUI.Label(rect, text, style);
((Rect)(ref rect)).x = ((Rect)(ref rect)).x - num;
((Rect)(ref rect)).y = ((Rect)(ref rect)).y - num;
GUI.Label(rect, text, style);
((Rect)(ref rect)).y = ((Rect)(ref rect)).y + size;
GUI.Label(rect, text, style);
((Rect)(ref rect)).y = ((Rect)(ref rect)).y - num;
style.normal.textColor = inColor;
GUI.color = color;
GUI.Label(rect, text, style);
}
public static void DrawShadow(Rect rect, GUIContent content, GUIStyle style, Color txtColor, Color shadowColor, Vector2 direction)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: 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_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
style.normal.textColor = shadowColor;
((Rect)(ref rect)).x = ((Rect)(ref rect)).x + direction.x;
((Rect)(ref rect)).y = ((Rect)(ref rect)).y + direction.y;
GUI.Label(rect, content, style);
style.normal.textColor = txtColor;
((Rect)(ref rect)).x = ((Rect)(ref rect)).x - direction.x;
((Rect)(ref rect)).y = ((Rect)(ref rect)).y - direction.y;
GUI.Label(rect, content, style);
}
public static void DrawLayoutShadow(GUIContent content, GUIStyle style, Color txtColor, Color shadowColor, Vector2 direction, params GUILayoutOption[] options)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
DrawShadow(GUILayoutUtility.GetRect(content, style, options), content, style, txtColor, shadowColor, direction);
}
public static bool DrawButtonWithShadow(Rect r, GUIContent content, GUIStyle style, float shadowAlpha, Vector2 direction)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
//IL_002b: 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_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: 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_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
GUIStyle val = new GUIStyle(style);
val.normal.background = null;
val.hover.background = null;
val.active.background = null;
bool result = GUI.Button(r, content, style);
DrawShadow(txtColor: ((Rect)(ref r)).Contains(Event.current.mousePosition) ? val.hover.textColor : val.normal.textColor, rect: r, content: content, style: val, shadowColor: new Color(0f, 0f, 0f, shadowAlpha), direction: direction);
return result;
}
public static bool DrawLayoutButtonWithShadow(GUIContent content, GUIStyle style, float shadowAlpha, Vector2 direction, params GUILayoutOption[] options)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
return DrawButtonWithShadow(GUILayoutUtility.GetRect(content, style, options), content, style, shadowAlpha, direction);
}
}
}
namespace PerformanceTracker.Util.Helpers
{
[DefaultExecutionOrder(int.MinValue)]
internal sealed class FrameCounterHelper : MonoBehaviour
{
[DefaultExecutionOrder(int.MaxValue)]
internal sealed class FrameCounterHelper2 : MonoBehaviour
{
private void LateUpdate()
{
_lateUpdateTime.Sample(TakeMeasurement());
_onGuiHit = false;
CanProcessOnGui = true;
}
}
private static readonly MovingAverage _fixedUpdateTime = new MovingAverage();
private static readonly MovingAverage _updateTime = new MovingAverage();
private static readonly MovingAverage _yieldTime = new MovingAverage();
private static readonly MovingAverage _lateUpdateTime = new MovingAverage();
private static readonly MovingAverage _renderTime = new MovingAverage();
private static readonly MovingAverage _onGuiTime = new MovingAverage();
private static readonly MovingAverage _gcAddedSize = new MovingAverage(60);
private static readonly MovingAverage _frameTime = new MovingAverage();
private static Stopwatch _measurementStopwatch;
internal static bool CanProcessOnGui;
private static bool _onGuiHit;
private static readonly WaitForEndOfFrame WaitForEndOfFrame = new WaitForEndOfFrame();
private static readonly KVPluginDataComparer Comparer = new KVPluginDataComparer();
private static long TakeMeasurement()
{
long elapsedTicks = _measurementStopwatch.ElapsedTicks;
_measurementStopwatch.Reset();
_measurementStopwatch.Start();
return elapsedTicks;
}
private IEnumerator Start()
{
_measurementStopwatch = new Stopwatch();
Stopwatch totalStopwatch = new Stopwatch();
float nanosecPerTick = 100000000f / (float)Stopwatch.Frequency;
float msScale = 1f / (nanosecPerTick * 1000f);
long gcPreviousAmount = 0L;
while (true)
{
yield return null;
_updateTime.Sample(TakeMeasurement());
yield return WaitForEndOfFrame;
if (!_onGuiHit)
{
_renderTime.Sample(TakeMeasurement());
_onGuiHit = true;
}
CanProcessOnGui = false;
_onGuiTime.Sample(TakeMeasurement());
_measurementStopwatch.Reset();
_frameTime.Sample(totalStopwatch.ElapsedTicks);
totalStopwatch.Reset();
totalStopwatch.Start();
long average = _frameTime.GetAverage();
float float_val = 1000000f / ((float)average / nanosecPerTick);
UIHelper.fString.Append(float_val, 2u, 2u).Append(" FPS");
if (PerformanceTrackerPlugin._showUnityMethodStats.Value == PerformanceTrackerPlugin.Toggle.On)
{
long average2 = _fixedUpdateTime.GetAverage();
long average3 = _updateTime.GetAverage();
long average4 = _yieldTime.GetAverage();
long average5 = _lateUpdateTime.GetAverage();
long average6 = _renderTime.GetAverage();
long average7 = _onGuiTime.GetAverage();
long num = average2 + average3 + average4 + average5 + average6 + average7;
long num2 = average - num;
UIHelper.fString.Append(", ").Append((float)average * msScale, 2u, 2u);
UIHelper.fString.Append("ms\nFixed: ").Append((float)average2 * msScale, 2u, 2u);
UIHelper.fString.Append("ms\nUpdate: ").Append((float)average3 * msScale, 2u, 2u);
UIHelper.fString.Append("ms\nYield/anim: ").Append((float)average4 * msScale, 2u, 2u);
UIHelper.fString.Append("ms\nLate: ").Append((float)average5 * msScale, 2u, 2u);
UIHelper.fString.Append("ms\nRender/VSync: ").Append((float)average6 * msScale, 2u, 2u);
UIHelper.fString.Append("ms\nOnGUI: ").Append((float)average7 * msScale, 2u, 2u);
UIHelper.fString.Append("ms\nOther: ").Append((float)num2 * msScale, 2u, 2u).Append("ms");
}
if (PerformanceTrackerPlugin._measureMemory != null && PerformanceTrackerPlugin._measureMemory.Value == PerformanceTrackerPlugin.Toggle.On)
{
ulong num3 = MemoryInfo.QueryProcessMemStatus().WorkingSetSize / 1024 / 1024;
ulong num4 = MemoryInfo.QuerySystemMemStatus().ullAvailPhys / 1024 / 1024;
UIHelper.fString.Append("\nRAM: ").Append((uint)num3).Append("MB used, ");
UIHelper.fString.Append((uint)num4).Append("MB free");
long totalMemory = GC.GetTotalMemory(forceFullCollection: false);
if (totalMemory != 0L)
{
long newSample = totalMemory - gcPreviousAmount;
long num5 = totalMemory / 1024 / 1024;
_gcAddedSize.Sample(newSample);
UIHelper.fString.Append("\nGC: ").Append((int)num5).Append("MB (");
UIHelper.fString.Append(_gcAddedSize.GetAverageFloat() / 1024f, 2u, 4u).Append("KB/s)");
gcPreviousAmount = totalMemory;
}
int maxGeneration = GC.MaxGeneration;
if (maxGeneration > 0)
{
UIHelper.fString.Append("\nGC hits:");
for (int i = 0; i < maxGeneration; i++)
{
int int_val = GC.CollectionCount(i);
UIHelper.fString.Append(' ').Append(i).Append(':')
.Append(int_val);
}
}
}
List<KeyValuePair<string, long>> slowPlugins = PluginCounter.SlowPlugins;
if (slowPlugins != null)
{
if (slowPlugins.Count > 0)
{
slowPlugins.Sort(Comparer);
int count = slowPlugins.Count;
for (int j = 0; j < count && j < 5; j++)
{
KeyValuePair<string, long> keyValuePair = slowPlugins[j];
int count2 = ((keyValuePair.Key.Length > 20) ? 20 : keyValuePair.Key.Length);
UIHelper.fString.Append("\n[").Append(keyValuePair.Key, 0, count2).Append(": ")
.Append((float)keyValuePair.Value * msScale, 1u, 2u)
.Append("ms]");
}
}
else
{
UIHelper.fString.Append("\nNo slow plugins");
}
}
UIHelper._frameOutputText = UIHelper.fString.Finalize();
_measurementStopwatch.Reset();
}
}
private void FixedUpdate()
{
_measurementStopwatch.Start();
}
private void Update()
{
_fixedUpdateTime.Sample(TakeMeasurement());
}
private void LateUpdate()
{
_yieldTime.Sample(TakeMeasurement());
}
private void OnGUI()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Invalid comparison between Unknown and I4
if (!_onGuiHit)
{
_renderTime.Sample(TakeMeasurement());
_onGuiHit = true;
}
if ((int)Event.current.type == 7)
{
UIHelper.DrawCounter();
}
}
}
public class Helpers
{
private static readonly MonoBehaviour[] _helpers = (MonoBehaviour[])(object)new MonoBehaviour[2];
internal static void SetCapturingEnabled(bool enableCapturing)
{
if (!enableCapturing)
{
PluginCounter.Stop();
Object.Destroy((Object)(object)_helpers[0]);
Object.Destroy((Object)(object)_helpers[1]);
return;
}
if ((Object)(object)_helpers[0] == (Object)null)
{
_helpers[0] = (MonoBehaviour)(object)PerformanceTrackerPlugin.pluginGO.AddComponent<FrameCounterHelper>();
}
if ((Object)(object)_helpers[1] == (Object)null)
{
_helpers[1] = (MonoBehaviour)(object)PerformanceTrackerPlugin.pluginGO.AddComponent<FrameCounterHelper.FrameCounterHelper2>();
}
if (PerformanceTrackerPlugin._showPluginStats.Value == PerformanceTrackerPlugin.Toggle.On)
{
PluginCounter.Start(_helpers[0], (BaseUnityPlugin)(object)PerformanceTrackerPlugin.ModContext);
}
else
{
PluginCounter.Stop();
}
}
internal static void OnEnable()
{
ConfigEntry<PerformanceTrackerPlugin.Toggle> shown = PerformanceTrackerPlugin._shown;
if (shown != null && shown.Value == PerformanceTrackerPlugin.Toggle.On)
{
UIHelper.UpdateLooks();
SetCapturingEnabled(enableCapturing: true);
}
}
internal static void OnDisable()
{
SetCapturingEnabled(enableCapturing: false);
}
}
public class UIHelper
{
private const int MAX_STRING_SIZE = 499;
private static readonly GUIStyle _style = new GUIStyle();
private static Rect _screenRect;
private const int ScreenOffset = 10;
internal static MutableString fString = new MutableString(499, ignoreOverflow: true);
internal static string _frameOutputText;
internal static void DrawCounter()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
if (PerformanceTrackerPlugin._counterColor.Value == PerformanceTrackerPlugin.CounterColors.Outline)
{
ShadowAndOutline.DrawOutline(_screenRect, _frameOutputText, _style, Color.black, Color.white, 1.5f);
}
else
{
GUI.Label(_screenRect, _frameOutputText, _style);
}
}
internal static void UpdateLooks()
{
//IL_0016: 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_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
if (PerformanceTrackerPlugin._counterColor.Value == PerformanceTrackerPlugin.CounterColors.White)
{
_style.normal.textColor = Color.white;
}
if (PerformanceTrackerPlugin._counterColor.Value == PerformanceTrackerPlugin.CounterColors.Black)
{
_style.normal.textColor = Color.black;
}
int width = Screen.width;
int height = Screen.height;
_screenRect = new Rect(10f, 10f, (float)(width - 20), (float)(height - 20));
_style.alignment = PerformanceTrackerPlugin._position.Value;
_style.fontSize = height / 65;
}
}
}
namespace FPSCounter
{
internal class KVPluginDataComparer : IComparer<KeyValuePair<string, long>>
{
public int Compare(KeyValuePair<string, long> val1, KeyValuePair<string, long> val2)
{
return val2.Value.CompareTo(val1.Value);
}
}
public class MutableString
{
public enum BaseValue
{
Binary = 2,
Decimal = 10,
Hex = 16
}
private const uint MAX_DECIMALS = 2u;
private const BaseValue DEFAULT_BASE = BaseValue.Decimal;
private static readonly char[] DIGITS_LUT = new char[16]
{
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F'
};
private int m_Pos;
private string m_valueStr;
private char m_defaultPadChar = '0';
private readonly bool dontThrow;
public char DefaultPadChar
{
get
{
return m_defaultPadChar;
}
set
{
m_defaultPadChar = value;
}
}
public int Capacity => m_valueStr.Length;
public int Length
{
get
{
return m_Pos;
}
set
{
m_Pos = value;
}
}
public string CurrentRaw => m_valueStr;
public MutableString(int size)
: this(size, '\0', ignoreOverflow: false)
{
}
public MutableString(int size, bool ignoreOverflow)
: this(size, '\0', ignoreOverflow)
{
}
public MutableString(int size, char fillChar)
: this(size, fillChar, ignoreOverflow: false)
{
}
public MutableString(int size, char fillChar, bool ignoreOverflow)
{
if (size < 2)
{
throw new ArgumentException("Size cannot be 1 or less");
}
m_valueStr = new string(fillChar, size);
dontThrow = ignoreOverflow;
}
public string Finalize()
{
if (m_Pos == 0)
{
return string.Empty;
}
int num = m_valueStr.Length - m_Pos;
if (num > 0)
{
repeatChar('\0', num);
}
m_Pos = 0;
return m_valueStr;
}
public MutableString Append(bool value)
{
Append(value.ToString());
return this;
}
public MutableString Append(byte value)
{
Append((uint)value);
return this;
}
public MutableString Append(sbyte value)
{
Append((int)value);
return this;
}
public MutableString Append(short value)
{
Append((int)value);
return this;
}
public MutableString Append(ushort value)
{
Append((int)value);
return this;
}
public MutableString Append(char[] value, int indx, int count)
{
if (value == null)
{
return this;
}
int num = value.Length;
if (count < 1 || indx < 0 || num < count + indx)
{
return this;
}
if (num > 1)
{
AppendInternal(value, indx, count);
}
else
{
Append(value[0]);
}
return this;
}
public MutableString Append(char[] value)
{
if (value == null)
{
return this;
}
int num = value.Length;
if (num > 1)
{
AppendInternal(value, 0, num);
}
else
{
Append(value[0]);
}
return this;
}
public MutableString Append(char value)
{
if (m_Pos >= m_valueStr.Length)
{
if (dontThrow)
{
return this;
}
throw new ArgumentException("Not enough free space to accomodate element!");
}
singleChar(value);
m_Pos++;
return this;
}
private void AppendInternal(char[] value, int indx, int count)
{
int num = m_valueStr.Length - m_Pos;
if (count > num)
{
if (!dontThrow)
{
throw new ArgumentException($"Not enough free space to accomodate {count} elements!");
}
}
else
{
charCopy(value, indx, count);
m_Pos += count;
}
}
private void AppendInternal(string value, int indx, int count)
{
int num = m_valueStr.Length - m_Pos;
if (count > num)
{
if (!dontThrow)
{
throw new ArgumentOutOfRangeException($"Not enough free space to accomodate {count} elements!");
}
}
else
{
stringCopy(value, indx, count);
m_Pos += count;
}
}
public MutableString Append(string value, int indx, int count)
{
if (value == null)
{
return this;
}
int length = value.Length;
if (count < 1 || indx < 0 || length < count + indx)
{
return this;
}
if (length > 1)
{
AppendInternal(value, indx, count);
}
else
{
Append(value[0]);
}
return this;
}
public MutableString Append(string value)
{
if (value == null)
{
return this;
}
int length = value.Length;
if (length > 1)
{
AppendInternal(value, 0, length);
}
else
{
Append(value[0]);
}
return this;
}
private unsafe void AppendUINT32(uint uint_val, uint pad_base, char pad_char, bool negative)
{
int num = CountDigits(uint_val);
int num2 = (int)((pad_base > num) ? (pad_base - num) : 0);
int num3 = Convert.ToInt32(negative) + num2 + num;
int num4 = m_Pos + num3;
if (num4 > m_valueStr.Length)
{
if (!dontThrow)
{
throw new ArgumentOutOfRangeException($"Not enough free space to accomodate {num3} elements!");
}
return;
}
fixed (char* ptr = m_valueStr)
{
char* ptr2 = ptr + num4;
do
{
uint num5 = uint_val / 10;
*(--ptr2) = (char)(48 + uint_val - num5 * 10);
uint_val = num5;
}
while (uint_val != 0);
while (num2 > 0)
{
*(--ptr2) = pad_char;
num2--;
}
if (negative)
{
*(--ptr2) = '-';
}
}
m_Pos = num4;
}
public MutableString Append(uint uint_val)
{
AppendUINT32(uint_val, 0u, m_defaultPadChar, negative: false);
return this;
}
public MutableString Append(uint uint_val, uint pad_amount)
{
AppendUINT32(uint_val, pad_amount, m_defaultPadChar, negative: false);
return this;
}
public MutableString Append(uint uint_val, uint pad_amount, char pad_char)
{
AppendUINT32(uint_val, pad_amount, pad_char, negative: false);
return this;
}
public MutableString Append(int int_val)
{
Append(int_val, 0u, m_defaultPadChar);
return this;
}
public MutableString Append(int int_val, uint pad_amount)
{
Append(int_val, pad_amount, m_defaultPadChar);
return this;
}
public MutableString Append(int int_val, uint pad_base, char pad_char)
{
bool isNegative;
uint positiveEqv = GetPositiveEqv(int_val, out isNegative);
AppendUINT32(positiveEqv, pad_base, pad_char, isNegative);
return this;
}
private unsafe void AppendULONG(ulong ulong_val, uint pad_base, char pad_char, bool negative)
{
int num = CountDigits(ulong_val);
int num2 = (int)((pad_base > num) ? (pad_base - num) : 0);
int num3 = Convert.ToInt32(negative) + num + num2;
int num4 = m_Pos + num3;
if (num4 > m_valueStr.Length)
{
if (!dontThrow)
{
throw new ArgumentOutOfRangeException($"Not enough free space to accomodate {num3} elements!");
}
return;
}
fixed (char* ptr = m_valueStr)
{
char* ptr2 = ptr + num4;
do
{
ulong num5 = ulong_val / 10;
*(--ptr2) = (char)(48 + ulong_val - num5 * 10);
ulong_val = num5;
}
while (ulong_val != 0L);
while (num2 > 0)
{
*(--ptr2) = pad_char;
num2--;
}
if (negative)
{
*(--ptr2) = '-';
}
}
m_Pos = num4;
}
public MutableString Append(ulong ulong_val)
{
AppendULONG(ulong_val, 0u, m_defaultPadChar, negative: false);
return this;
}
public MutableString Append(ulong ulong_val, uint pad_amount)
{
AppendULONG(ulong_val, pad_amount, m_defaultPadChar, negative: false);
return this;
}
public MutableString Append(ulong ulong_val, uint pad_amount, char pad_char)
{
AppendULONG(ulong_val, pad_amount, pad_char, negative: false);
return this;
}
public MutableString Append(long long_val)
{
Append(long_val, 0u, m_defaultPadChar);
return this;
}
public MutableString Append(long long_val, uint pad_base)
{
Append(long_val, pad_base, m_defaultPadChar);
return this;
}
public MutableString Append(long long_val, uint pad_base, char pad_char)
{
bool flag = long_val < 0;
ulong ulong_val = (ulong)(flag ? (-1 - long_val + 1) : long_val);
AppendULONG(ulong_val, pad_base, pad_char, flag);
return this;
}
public unsafe MutableString Append(float float_val, uint decimal_places, uint pad_base, char pad_char)
{
decimal_places = ((decimal_places > 2) ? 2u : decimal_places);
bool flag = float_val < 0f;
float num = 5f / (float)Math.Pow(10.0, 1 + decimal_places);
float num2 = (flag ? (float_val + (0f - num)) : (float_val + num));
if (!IsFinite(float_val))
{
if (float_val != float_val)
{
AppendInternal("NaN", 0, 3);
}
else
{
AppendInternal(flag ? "-∞" : "+∞", 0, 2);
}
return this;
}
bool isNegative;
uint positiveEqv = GetPositiveEqv((int)num2, out isNegative);
if (decimal_places == 0)
{
AppendUINT32(positiveEqv, pad_base, pad_char, flag);
return this;
}
int num3 = CountDigits(positiveEqv);
int num4 = num3 + 1 + (int)decimal_places;
int num5 = (int)((pad_base > num3) ? (pad_base - num3) : 0);
int num6 = Convert.ToInt32(flag) + num5 + num4;
int num7 = m_Pos + num6;
if (num7 > m_valueStr.Length)
{
if (dontThrow)
{
return this;
}
throw new ArgumentOutOfRangeException($"Not enough free space to accomodate {num6} elements!");
}
fixed (char* ptr = m_valueStr)
{
char* ptr2 = ptr + num7;
uint num8 = (uint)(num2 * (float)Math.Pow(10.0, decimal_places));
do
{
uint num9 = num8 / 10;
*(--ptr2) = (char)(48 + num8 - num9 * 10);
num8 = num9;
decimal_places--;
}
while (decimal_places != 0);
*(--ptr2) = '.';
do
{
uint num10 = num8 / 10;
*(--ptr2) = (char)(48 + num8 - num10 * 10);
num8 = num10;
num3--;
}
while (num3 != 0);
while (num5 > 0)
{
*(--ptr2) = pad_char;
num5--;
}
if (flag)
{
*(--ptr2) = '-';
}
}
m_Pos = num7;
return this;
}
public MutableString Append(float float_val)
{
return Append(float_val, 2u, 0u, m_defaultPadChar);
}
public MutableString Append(float float_val, uint decimal_places)
{
return Append(float_val, decimal_places, 0u, m_defaultPadChar);
}
public MutableString Append(float float_val, uint decimal_places, uint pad_amount)
{
return Append(float_val, decimal_places, pad_amount, m_defaultPadChar);
}
private static uint GetPositiveEqv(int val, out bool isNegative)
{
isNegative = val < 0;
if (!isNegative)
{
return (uint)val;
}
return (uint)(-1 - val + 1);
}
private static int CountDigits(ulong value)
{
int num = 1;
uint num2;
if (value >= 10000000)
{
if (value >= 100000000000000L)
{
num2 = (uint)(value / 100000000000000L);
num += 14;
}
else
{
num2 = (uint)(value / 10000000);
num += 7;
}
}
else
{
num2 = (uint)value;
}
if (num2 >= 10)
{
num = ((num2 < 100) ? (num + 1) : ((num2 < 1000) ? (num + 2) : ((num2 < 10000) ? (num + 3) : ((num2 < 100000) ? (num + 4) : ((num2 >= 1000000) ? (num + 6) : (num + 5))))));
}
return num;
}
private static int CountDigits(uint value)
{
int num = 1;
if (value >= 100000)
{
value /= 100000;
num += 5;
}
if (value >= 10)
{
num = ((value < 100) ? (num + 1) : ((value < 1000) ? (num + 2) : ((value >= 10000) ? (num + 4) : (num + 3))));
}
return num;
}
private static int CountDecimalTrailingZeros(uint value, out uint valueWithoutTrailingZeros)
{
int num = 0;
if (value != 0)
{
while (true)
{
uint num2 = value / 10;
if (value != num2 * 10)
{
break;
}
value = num2;
num++;
}
}
valueWithoutTrailingZeros = value;
return num;
}
private static uint Low32(ulong value)
{
return (uint)value;
}
private static uint High32(ulong value)
{
return (uint)((value & 0xFFFFFFFF00000000uL) >> 32);
}
private unsafe static int SingleToInt32Bits(float value)
{
return *(int*)(&value);
}
private static bool IsFinite(float f)
{
return (SingleToInt32Bits(f) & 0x7FFFFFFF) < 2139095040;
}
private unsafe void stringCopy(string value, int indx, int charCount)
{
fixed (char* ptr = m_valueStr)
{
fixed (char* ptr2 = value)
{
wstrCpy(ptr + m_Pos, ptr2 + indx, charCount);
}
}
}
private unsafe void charCopy(char[] value, int indx, int charCount)
{
fixed (char* ptr = m_valueStr)
{
fixed (char* ptr2 = value)
{
wstrCpy(ptr + m_Pos, ptr2 + indx, charCount);
}
}
}
private unsafe void singleChar(char value)
{
fixed (char* ptr = m_valueStr)
{
ptr[m_Pos] = value;
}
}
private unsafe void repeatChar(char value, int count)
{
int num = m_Pos + count;
fixed (char* ptr = m_valueStr)
{
for (int i = m_Pos; i < num; i++)
{
ptr[i] = value;
}
}
m_Pos = num;
}
private unsafe void rawCopy(char* dest, char* src, int charCount)
{
for (int i = 0; i < charCount; i++)
{
dest[i] = src[i];
}
}
private unsafe static void wstrCpy(char* dmem, char* smem, int charCount)
{
if (((uint)(int)dmem & 2u) != 0)
{
*dmem = *smem;
dmem++;
smem++;
charCount--;
}
while (charCount >= 8)
{
*(int*)dmem = *(int*)smem;
*(int*)(dmem + 2) = *(int*)(smem + 2);
*(int*)(dmem + 4) = *(int*)(smem + 4);
*(int*)(dmem + 6) = *(int*)(smem + 6);
dmem += 8;
smem += 8;
charCount -= 8;
}
if (((uint)charCount & 4u) != 0)
{
*(int*)dmem = *(int*)smem;
*(int*)(dmem + 2) = *(int*)(smem + 2);
dmem += 4;
smem += 4;
}
if (((uint)charCount & 2u) != 0)
{
*(int*)dmem = *(int*)smem;
dmem += 2;
smem += 2;
}
if (((uint)charCount & (true ? 1u : 0u)) != 0)
{
*dmem = *smem;
}
}
}
}
